Class ClientEmitter

Main class for work with API for Node.js

Library for Node.js default export this class

Hierarchy (View Summary)

Client
- ClientEmitter

Constructors

constructor

new ClientEmitter(apiKey: string, endpoint?: string): ClientEmitter
Create class instance
Parameters
- apiKey: string
  Crypto Bot API key, looks like '1234:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
- endpoint: string = 'mainnet'
  API endpoint url or 'mainnet' or 'testnet' for hardcoded in library endpoint urls
Returns ClientEmitter
Overrides Client.constructor
- Defined in classes/ClientEmitter.ts:85

Properties

`Static`CheckStatus

CheckStatus: typeof CheckStatus = CheckStatus

Access to CheckStatus enumeration, used in Check type, Client.getChecks and Client.getChecksPaginate methods options

`Static`CurrencyType

CurrencyType: typeof CurrencyType = CurrencyType

Access to CurrencyType enumeration, used in Invoice type

`Static`DetailedCurrencyType

DetailedCurrencyType: typeof DetailedCurrencyType = DetailedCurrencyType

Access to DetailedCurrencyType enumeration, used in Store.getCurrencies and Client.getCurrency methods results

`Static`InvoiceStatus

InvoiceStatus: typeof InvoiceStatus = InvoiceStatus

Access to InvoiceStatus enumeration, used in Invoice type, Client.getInvoices and Client.getInvoicesPaginate methods options

`Static`TransferStatus

TransferStatus: typeof TransferStatus = TransferStatus

Access to TransferStatus enumeration, used in Transfer type, Client.getTransfers and Client.getTransfersPaginate methods options

`Protected`_transport

_transport: Transport

Transport class instance

`Private`_apiKey

_apiKey: string

Api key

`Private`_events

_events: { [key: string]: ((...args: any) => any)[] } = {}

Event listeners store

`Private`_server

_server: Server

Handling webhooks created Node.js built-in server

Methods

call

call(method: string, options?: object): Promise<any>
Call backend API method directly (types unsafe)

Use it if backend API update (add new methods, change request or response fileds), but library is not
Parameters
- method: string
  Backend API method name
- options: object = {}
  Backend API options object
Returns Promise<any>
Promise, what resolved to backend API response result field value

Throws
Error - If there is an error sending request to backend API or parsing response
Inherited from Client.call
- Defined in classes/Client.ts:476

closeServer

closeServer(): Promise<void>
Close created handling webhooks server

Returns Promise<void>
Promise, what resolved void

Throws
Error - If server not was started or closing error
- Defined in classes/ClientEmitter.ts:152

createCheck

createCheck(options: CreateCheckOptions): Promise<Check>
Create check

Use toCheck backend API result convert function and prepare backend API parameters prepareCreateCheckOptions function
Parameters
- options: CreateCheckOptions
  New check options
Returns Promise<Check>
Promise, what resolved to created check information object

Throws
Error - If there is an error sending request to backend API, parsing response error or options object is invalid
Inherited from Client.createCheck
- Defined in classes/Client.ts:309

createInvoice

createInvoice(options: CreateInvoiceOptions): Promise<Invoice>
Create invoice

Use toInvoice backend API result convert function and prepare backend API parameters prepareCreateInvoiceOptions function
Parameters
- options: CreateInvoiceOptions
  New invoice options
Returns Promise<Invoice>
Promise, what resolved to created invoice information object

Throws
Error - If there is an error sending request to backend API, parsing response error or options object is invalid
Inherited from Client.createInvoice
- Defined in classes/Client.ts:291

createServer

createServer(
    serverOptions: SecureContextOptions & TlsOptions & ServerOptions<
        typeof IncomingMessage,
        typeof ServerResponse,
    > & { http?: boolean },
    secretPath?: string,
    listenOptions?: ListenOptions,
): Promise<void>
Create handling webhooks server

If you app work behind proxy and no need create HTTPS server, no pass key and cert fields and add http field with true value: { http: true }

Note: if you want to use self-signed certificate you must uploat it in CryptoBot API application settings
Parameters
- serverOptions: SecureContextOptions & TlsOptions & ServerOptions<
  typeof IncomingMessage,
  typeof ServerResponse,
  > & { http?: boolean }
  Node.js built-in server options
- secretPath: string = '/'
  Webhooks secret path, processing webhooks takes place only on it
- listenOptions: ListenOptions = ...
  Node.js built-in server listen options
Returns Promise<void>
Promise, what resolved void

Throws
Error - If create server error
- Defined in classes/ClientEmitter.ts:107

deleteCheck

deleteCheck(id: number): Promise<boolean>
Delete check
Parameters
- id: number
  Check identifier
Returns Promise<boolean>
Promise, what resolved to boolean operation result status

Throws
Error - If there is an error sending request to backend API or parsing response error
Inherited from Client.deleteCheck
- Defined in classes/Client.ts:336

deleteInvoice

deleteInvoice(id: number): Promise<boolean>
Delete invoice
Parameters
- id: number
  Invoice identifier
Returns Promise<boolean>
Promise, what resolved to boolean operation result status

Throws
Error - If there is an error sending request to backend API or parsing response error
Inherited from Client.deleteInvoice
- Defined in classes/Client.ts:323

getBalance

getBalance(currencyCode: CryptoCurrencyCode): Promise<Balance>
Get API app balance value for passed currency

Call Client.getBalances method to fetch balances information
Parameters
- currencyCode: CryptoCurrencyCode
  Crypto currency code
Returns Promise<Balance>
Promise, what resolved to API app balance value for passed currency

Throws
Error - If there is an error sending request to backend API or parsing response
Inherited from Client.getBalance
- Defined in classes/Client.ts:169

getBalanceAvailable

getBalanceAvailable(currencyCode: CryptoCurrencyCode): Promise<string>
Get API app balance value for passed currency

Call Client.getBalances method to fetch balances information
Parameters
- currencyCode: CryptoCurrencyCode
  Crypto currency code
Returns Promise<string>
Promise, what resolved to API app available balance value for passed currency

Throws
Error - If there is an error sending request to backend API or parsing response
Inherited from Client.getBalanceAvailable
- Defined in classes/Client.ts:188

getBalanceOnhold

getBalanceOnhold(currencyCode: CryptoCurrencyCode): Promise<string>
Get API app balance value for passed currency

Call Client.getBalances method to fetch balances information
Parameters
- currencyCode: CryptoCurrencyCode
  Crypto currency code
Returns Promise<string>
Promise, what resolved to API app balance on hold value for passed currency

Throws
Error - If there is an error sending request to backend API or parsing response
Inherited from Client.getBalanceOnhold
- Defined in classes/Client.ts:207

getBalances

getBalances(): Promise<Balances>
Get API app balances infomation

Use toBalances backend API result convert function

Returns Promise<Balances>
Promise, what resolved to API app balances infomation object

Throws
Error - If there is an error sending request to backend API or parsing response
Inherited from Client.getBalances
- Defined in classes/Client.ts:108

getBalancesAvailable

getBalancesAvailable(): Promise<BalancesType>
Get API app balances infomation

Use toBalances backend API result convert function

Returns Promise<BalancesType>
Promise, what resolved to API app available balances infomation object

Throws
Error - If there is an error sending request to backend API or parsing response
Inherited from Client.getBalancesAvailable
- Defined in classes/Client.ts:121

getBalancesOnhold

getBalancesOnhold(): Promise<BalancesType>
Get API app balances infomation

Use toBalances backend API result convert function

Returns Promise<BalancesType>
Promise, what resolved to API app balances on hold infomation object

Throws
Error - If there is an error sending request to backend API or parsing response
Inherited from Client.getBalancesOnhold
- Defined in classes/Client.ts:144

getChecks

getChecks(options?: GetChecksOptions): Promise<Check[]>
Get checks

Use toChecks backend API result convert function and prepare backend API parameters prepareGetChecksOptions function
Parameters
- options: GetChecksOptions = {}
  Filters options
Returns Promise<Check[]>
Promise, what resolved to checks information object

Throws
Error - If there is an error sending request to backend API or parsing response
Inherited from Client.getChecks
- Defined in classes/Client.ts:393

getChecksPaginate

getChecksPaginate(options?: GetChecksPaginateOptions): Promise<Check[]>
Get checks paginated

Fetch checks with page options parameter, except count and offset

See Client.getPageSize and Client.setPageSize

Use toChecks backend API result convert function and prepare backend API parameters prepareGetChecksPaginateOptions function
Parameters
- options: GetChecksPaginateOptions = {}
  Filters options
Returns Promise<Check[]>
Promise, what resolved to checks information object

Throws
Error - If there is an error sending request to backend API, parsing response error or options object is invalid
Inherited from Client.getChecksPaginate
- Defined in classes/Client.ts:415

getCurrencies

getCurrencies(isForce?: boolean): Promise<Currencies>
Get API supported currencies infomation

Use toCurrencies backend API result convert function
Parameters
- OptionalisForce: boolean
  If true, return fresh data from backend API, not from cache
Returns Promise<Currencies>
Promise, what resolved to API supported currencies infomation object

Throws
Error - If there is an error sending request to backend API or parsing response
Inherited from Client.getCurrencies
- Defined in classes/Store.ts:128

getCurrency

getCurrency(currencyCode: CurrencyCode, isForce?: boolean): Promise<Currency>
Get currency with passed code infomation

Call Store.getCurrencies method to fetch currencies information
Parameters
- currencyCode: CurrencyCode
  Currency code
- isForce: boolean = false
  If true, return fresh data from backend API, not from cache
Returns Promise<Currency>
Promise, what resolved to currency with passed code infomation object or null, if currency with passed code not exists

Throws
Error - If there is an error sending request to backend API or parsing response
Inherited from Client.getCurrency
- Defined in classes/Client.ts:228

getExchangeRate

getExchangeRate(
    source: string,
    target: string,
    isForce?: boolean,
): Promise<string>
Get one exchange rate infomation to passed currencies pair

Call Store.getExchangeRates method to fetch exchange rates information, Store.getCurrencies method to fetch currencies information and use getExchageRate function to get signle exchange rate
Parameters
- source: string
  Source currency code
- target: string
  Target currency code
- isForce: boolean = false
  If true, return fresh data from backend API, not from cache
Returns Promise<string>
Promise, what resolved to exchange rate or zero, if currencies pair not exists

Throws
Error - If there is an error sending request to backend API or parsing response
Inherited from Client.getExchangeRate
- Defined in classes/Client.ts:251

getExchangeRates

getExchangeRates(isForce?: boolean): Promise<ExchangeRates>
Get API supported currencies exchange rate infomation

Use toExchangeRates backend API result convert function
Parameters
- OptionalisForce: boolean
  If true, return fresh data from backend API, not from cache
Returns Promise<ExchangeRates>
Promise, what resolved to API supported currencies exchange rate infomation object

Throws
Error - If there is an error sending request to backend API or parsing response
Inherited from Client.getExchangeRates
- Defined in classes/Store.ts:148

getInvoices

getInvoices(options?: GetInvoicesOptions): Promise<Invoice[]>
Get invoices

Use toInvoices backend API result convert function and prepare backend API parameters prepareGetInvoicesOptions function
Parameters
- options: GetInvoicesOptions = {}
  Filters options
Returns Promise<Invoice[]>
Promise, what resolved to invoices information object

Throws
Error - If there is an error sending request to backend API or parsing response
Inherited from Client.getInvoices
- Defined in classes/Client.ts:352

getInvoicesPaginate

getInvoicesPaginate(options?: GetInvoicesPaginateOptions): Promise<Invoice[]>
Get invoices paginated

Fetch invoices with page options parameter, except count and offset

See Client.getPageSize and Client.setPageSize

Use toInvoices backend API result convert function and prepare backend API parameters prepareGetInvoicesPaginateOptions function
Parameters
- options: GetInvoicesPaginateOptions = {}
  Filters options
Returns Promise<Invoice[]>
Promise, what resolved to invoices information object

Throws
Error - If there is an error sending request to backend API, parsing response error or options object is invalid
Inherited from Client.getInvoicesPaginate
- Defined in classes/Client.ts:374

getMe

getMe(isForce?: boolean): Promise<Me>
Get associated with passed API key app infomation

Use toMe backend API result convert function
Parameters
- isForce: boolean = false
  If true, return fresh data from backend API, not from cache
Returns Promise<Me>
Promise, what resolved to associated with passed API key app infomation object

Throws
Error - If there is an error sending request to backend API or parsing response
Inherited from Client.getMe
- Defined in classes/Store.ts:168

getPageSize

getPageSize(): number
Return count invoices per page for Client.getInvoicesPaginate method

Returns number
Inherited from Client.getPageSize
- Defined in classes/Client.ts:64

getStats

getStats(options?: GetStatsOptions): Promise<Stats>
Get associated with passed API key app statistics

Use toStats backend API result convert function
Parameters
- options: GetStatsOptions = {}
  New receive statistics options
Returns Promise<Stats>
Promise, what resolved to associated with passed API key app statistics object

Throws
Error - If there is an error sending request to backend API or parsing response
Inherited from Client.getStats
- Defined in classes/Client.ts:94

getTransfers

getTransfers(options?: GetTransfersOptions): Promise<Transfer[]>
Get transfers

Use toTransfers backend API result convert function and prepare backend API parameters prepareGetTransfersOptions function
Parameters
- options: GetTransfersOptions = {}
  Filters options
Returns Promise<Transfer[]>
Promise, what resolved to transfers information object

Throws
Error - If there is an error sending request to backend API or parsing response
Inherited from Client.getTransfers
- Defined in classes/Client.ts:434

getTransfersPaginate

getTransfersPaginate(options?: GetTransfersPaginateOptions): Promise<Transfer[]>
Get transfers paginated

Fetch checks with page options parameter, except count and offset

See Client.getPageSize and Client.setPageSize

Use toTransfers backend API result convert function and prepare backend API parameters prepareGetTransfersOptions function
Parameters
- options: GetTransfersPaginateOptions = {}
  Filters options
Returns Promise<Transfer[]>
Promise, what resolved to transfers information object

Throws
Error - If there is an error sending request to backend API, parsing response error or options object is invalid
Inherited from Client.getTransfersPaginate
- Defined in classes/Client.ts:456

middleware

middleware(): Middleware
Create middleware function for Express.js-like API

Returns Middleware
Middleware function
- Defined in classes/ClientEmitter.ts:168

off

off(event: "paid", listener: (invoice: Invoice, requestDate: Date) => any): void
Unsubscribes from paid event
Parameters
- event: "paid"
  paid event name
- listener: (invoice: Invoice, requestDate: Date) => any
  Event listener with invoice and requestDate callback parameters
Returns void
- Defined in classes/ClientEmitter.ts:203

on

on(event: "paid", listener: (invoice: Invoice, requestDate: Date) => any): void
Subscribes to paid event

See ClientEmitter._emit to more about event listener
Parameters
- event: "paid"
  paid event name
- listener: (invoice: Invoice, requestDate: Date) => any
  Event listener with invoice and requestDate callback parameters
Returns void
- Defined in classes/ClientEmitter.ts:184

setPageSize

setPageSize(pageSizeParam: number): void
Set count invoices per page for Client.getInvoicesPaginate method
Parameters
- pageSizeParam: number
  Invoices per page
Returns void
Throws
Error - If pageSize parameter is invalid
Inherited from Client.setPageSize
- Defined in classes/Client.ts:75

transfer

transfer(options: TransferOptions): Promise<Transfer>
Transfer

Use toTransfer backend API result convert function and prepare backend API parameters prepareTransferOptions function
Parameters
- options: TransferOptions
  Transfer options
Returns Promise<Transfer>
Promise, what resolved to completed transfer information object

Throws
Error - If there is an error sending request to backend API, parsing response error or options object is invalid
Inherited from Client.transfer
- Defined in classes/Client.ts:273

`Private`_emit

_emit(event: "paid", invoice: Invoice, requestDate: Date): void
Emit event to listeners
Parameters
- event: "paid"
  paid event name
- invoice: Invoice
  Paid invoice information object
- requestDate: Date
  Date of occurrence of event, need to filter old event. If server is not available, backend API try resend webhooks by timeout, so when server becomes available again, many old events will be sent from backend API.
Returns void
- Defined in classes/ClientEmitter.ts:228

`Private`_handleWebhook

_handleWebhook(data: any, req: IncomingMessage, res: ServerResponse): void
Handling webhook data, send response and emit events
Parameters
- data: any
  Parsed request body
- req: IncomingMessage
  Node.js built-in IncomingMessage object
- res: ServerResponse
  Node.js built-in ServerResponse object
Returns void
- Defined in classes/ClientEmitter.ts:251

Class ClientEmitter

Hierarchy (View Summary)

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns ClientEmitter

Properties

StaticCheckStatus

StaticCurrencyType

StaticDetailedCurrencyType

StaticInvoiceStatus

StaticTransferStatus

Protected_transport

Private_apiKey

Private_events

Private_server

Methods

call

Parameters

Returns Promise<any>

Throws

closeServer

Returns Promise<void>

Throws

createCheck

Parameters

Returns Promise<Check>

Throws

createInvoice

Parameters

Returns Promise<Invoice>

Throws

createServer

Parameters

Returns Promise<void>

Throws

deleteCheck

Parameters

Returns Promise<boolean>

Throws

deleteInvoice

Parameters

Returns Promise<boolean>

Throws

getBalance

Parameters

Returns Promise<Balance>

Throws

getBalanceAvailable

Parameters

Returns Promise<string>

Throws

getBalanceOnhold

Parameters

Returns Promise<string>

Throws

getBalances

Returns Promise<Balances>

Throws

getBalancesAvailable

Returns Promise<BalancesType>

Throws

getBalancesOnhold

Returns Promise<BalancesType>

Throws

getChecks

Parameters

Returns Promise<Check[]>

Throws

getChecksPaginate

Parameters

Returns Promise<Check[]>

Throws

getCurrencies

Parameters

Returns Promise<Currencies>

`Static`CheckStatus

`Static`CurrencyType

`Static`DetailedCurrencyType

`Static`InvoiceStatus

`Static`TransferStatus

`Protected`_transport

`Private`_apiKey

`Private`_events

`Private`_server

`Private`_emit

`Private`_handleWebhook