NPM link: https://www.npmjs.com/package/nocust-client​

NOCUSTTransfer

Interface For the parameters object required to make nocust transfers.

Parameters:

TransferDataInterface

Full transfer details including signatures and status.

NOCUSTManager

approveAndDeposit

▸ approveAndDeposit(address: string, amount: BigNumber | BN | string, gasPrice: BigNumber | BN | string, gas: number, tokenAddress?: string): Promise<string>

Similarly to the deposit function but prior check to send the deposit transaction it checks for token transfer allowance of the NOCUST smart contract. If the allowance is not sufficient it sends an ERC-20 aprove transaction. Approving token transfers is a required operation by the ERC-20 standard. If the depositor does not have sufficient allowance the deposit will fail. Note that this function will make 2 on-chain transaction (contract calls) with the specified gas price and gas limit. Approvals are not required for Ether.

Parameters:

Returns: Promise<string> Hash of the on-chain transaction of the deposit.

buySLA

▸ buySLA(address: string): Promise<void>

Buys a SLA. The address needs to have the token amount available as a nocust balance on the address as specified by the getSLADetail function. This function will make a nocust transfer to pay for the SLA.

Parameters:

Returns: Promise<void>

deposit

▸ deposit(address: string, amount: BigNumber | BN | string, gasPrice: BigNumber | BN | string, gas: number, tokenAddress?: string): Promise<string>

Make an on-chain transaction to deposit funds into the NOCUST commit-chain. This funds can be later used for making off-chain NOCUST transfers. The operator will credit the deposit after 20 blocks of confirmation.

Parameters:

Returns: Promise<string> Hash of the on-chain transaction of the deposit.

getBlockPerEon

▸ getBlockPerEon(): Promise<number>

Get the number of Eras (blocks) per Eon.

Returns: Promise<number>

getBlocksToWithdrawalConfirmation

▸ getBlocksToWithdrawalConfirmation(address: string, txHash?: string, tokenAddress?: string): Promise<number>

Get the number of blocks until it is possible to send the withdrawal confirmation on-chain transaction. It will return -1 if no withdrawals are pending or 0 if the withdrawal is ready to be confirmed.

Parameters:

Returns: Promise<number>

getEonNumber

▸ getEonNumber(): Promise<number>

Get the current Eon or round number.

Returns: Promise<number>

getEraNumber

▸ getEraNumber(): Promise<number>

Get the current Era or sub-block number. The number of block since the current Eon started.

Returns: Promise<number> Era

getNOCUSTBalance

▸ getNOCUSTBalance(address: string, tokenAddress?: string): Promise<BigNumber>

Fetch the current NOCUST balance.

Parameters:

Returns: Promise<BigNumber> Nocust balance

getOnChainBalance

▸ getOnChainBalance(address: string, tokenAddress?: string): Promise<BigNumber>

Get current on-chain balance.

Parameters:

Returns: Promise<BigNumber> On-chain balance.

getOrderBook

▸ getOrderBook(buyTokenAddress: string, sellTokenAddress: string): Promise<OrderBookDataInterface>

Parameters:

Returns: Promise<OrderBookDataInterface>

getSLADetail

▸ getSLADetail(): Promise<SLADetailsInterface>

Get informations about the SLA pricing model.

Returns: Promise<SLADetailsInterface> Object with the token address with which to pay the SLA, the cost/amount of the SLA in this token, the recipient of the SLA payment, the transaction limit per month without SLA.

getSLAStatus

▸ getSLAStatus(address: string): Promise<number>

Get the SLA status for a given address.

Parameters:

Returns: Promise<number> 0 if not under SLA, expiry date unix timestamp in millisecond if currently enroll with a SLA.

getSupportedTokens

▸ getSupportedTokens(): Promise<object[]>

Fetch the smart contract addresses of the supported token by the commit-chain.

Returns: Promise<object[]> Promise that resolves with an array of objects { tokenAddress: string, name: string, shortName: string } for each token supported by the commit-chain. Address is the address of the ERC-20 contract of the token.

getTransaction

▸ getTransaction(transactionId: number): Promise<TransferDataInterface>

Fetch the transaction details given a transaction ID

Parameters:

Returns: Promise<TransferDataInterface> Transaction details }`

getTransactionsForAddress

▸ getTransactionsForAddress(address: string, tokenAddress?: string, roundNumber?: number): Promise<TransferDataInterface[]>

Get the list of transactions for a given address and token (Incoming and outgoing).

Parameters:

Returns: Promise<TransferDataInterface[]> Array of transactions

getWalletState

▸ getWalletState(address: string, tokenAddress?: string): Promise<WalletState>

Get the WalletState object for lower level API use.

Parameters:

Returns: Promise<WalletState>

getWithdrawalFee

▸ getWithdrawalFee(withdrawalRequestGasPrice: BigNumber | BN | string): Promise<BigNumber>

Doing a withdrawal request involve a fee to the operator. This function gets the current fee.

Parameters:

Returns: Promise<BigNumber> Fee amount

getWithdrawalLimit

▸ getWithdrawalLimit(address: string, tokenAddress?: string): Promise<BigNumber>

Withdrawals are limited to a certain amount (Because funds need to committed into a check point) and the limit increase over time. This method gets you the current available off-chain funds for withdrawal.

Parameters:

Returns: Promise<BigNumber> Withdrawal limit.

subscribeToIncomingTransfer

▸ subscribeToIncomingTransfer(address: string, callBack: function, tokenAddress?: any): function

Return an observable to notify of incoming transfers.

Parameters:

Returns: Promise< unsubscribe () => Void> A promise that resolves when the callback is registered. The promise resolves with the unsubscribe function of the callback.

Example:

const unsubscribe = await nocustManager.subscribeToIncomingTransfer(
        bob,
        tx => console.log(`Incoming transaction from: ${tx.wallet.address} of: ${tx.amount.toString()} wei of token ${tx.wallet.token}.`), 
        'all'
    )
// Unsubscribe when it is not needed anymore
unsubscribe()

isAddressRegistered

▸ isAddressRegistered(address: string, tokenAddress?: string): Promise<boolean>

Check if an address is registered with the nocust commit-chain.

Parameters:

Returns: Promise<boolean> Return true if the registration is successful

isAddressRegisteredWithOperator

▸ isAddressRegisteredWithOperator(address: string, tokenAddress?: string): Promise<boolean>

Check whether an address is registered with the commit-chain and can therefore receive payments.

Parameters:

Returns: Promise<boolean>

isRecovery

▸ isRecovery(): Promise<boolean>

Check whether the commit-chain is in recovery mode. If it is the case, the commit-chain can't be used anymore and funds need to be recovered.

Returns: Promise<boolean> Recovery status.

issueDeliveryChallenge

▸ issueDeliveryChallenge(address: string, txId: number, gasPrice: any, gas: any, tokenAddress?: string): Promise<string>

Make an on-chain transaction to initiate a delivery challenge.

Parameters:

Returns: Promise<string>

issueStateUpdateChallenge

▸ issueStateUpdateChallenge(address: string, gasPrice: any, gas: any, tokenAddress?: string): Promise<string>

Make an on-chain transaction to initiate a state update challenge.

Parameters:

Returns: Promise<string>

recoverFunds

▸ recoverFunds(address: string, gasPrice: any, gas: any, tokenAddress?: string): Promise<string>

Make an on-chain transaction to recover funds whenever the commit-chain falls into recovery mode.

Parameters:

Returns: Promise<string>

registerAddress

▸ registerAddress(address: string, tokenAddress?: string): Promise<void>

Register an address for a given token with the commit-chain. An address needs to be registered with the commit-chain for each token separately in order to send or receive transfers. This operation is done implicitly when sending a transfer if the address is not yet registered. Note that for a transfer to succeed the recipient need to have registered.

Parameters:

Returns: Promise<void>

sendSwap

▸ sendSwap(address: string, buyTokenAddress: string, sellTokenAddress: string, buyAmount: BigNumber | BN | string, sellAmount: BigNumber | BN | string): Promise<number>

Parameters:

Returns: Promise<number>

sendTransaction

▸ sendTransaction(transfer: NocustTransfer): Promise<number>

Send a NOCUST transfer.

Parameters:

Returns: Promise<number> Transaction Id of the NOCUST transfer

synchronizeSwapOrders

▸ synchronizeSwapOrders(address: string, subWalletSeedPhrase?: string): Promise<TransferDataInterface[]>

Claims all auxilary wallet's fulfilled swap orders and returns a list of unfulfilled swaps.

Parameters:

syncWallet

▸ syncWallet(address: string, tokenAddress?: string): Promise<void>

Force synchronize the wallet of the given public key for the given token. The result will be cached making later calls of this wallet faster. This function can be useful to pre-cache required internal data (for example on starup of your app) to make later function calls faster.

Parameters:

Returns: Promise<void>

withdrawalConfirmation

▸ withdrawalConfirmation(address: string, gasPrice: BigNumber | BN | string, gas: number, tokenAddress?: string): Promise<string>

Make an on-chain transaction to confirm a withdrawal previously initialized and effectively transfer the funds.

Parameters:

Returns: Promise<string> Hash of the on-chain transaction of the withdrawal confirmation.

withdrawalRequest

▸ withdrawalRequest(address: string, amount: BigNumber | BN | string, gasPrice: BigNumber | BN | string, gas: number, tokenAddress?: string): Promise<string>

Make an on-chain transaction to initiate a withdrawal to remove the funds from the NOCUST smart contract and to get them at the specified address. The amount specified needs to be available for withdrawal . The withdrawal will have to be confirmed after a certain period of time (Currently between 36 and 72h). On the top the gas fee, this function will take an Ether fee from the on-chain balance for the commit-chain operator.

Parameters:

Returns: Promise<string> Hash of the on-chain transaction of the withdrawal request.

Errors handling

The NOCUSTManager instance throws errors that can be catch and easily handled.

  import { NOCUSTManager, NOCUSTError } from 'nocust-client'
  
  try {
    balance = await nocustManager.getNOCUSTBalance(address)
  } catch(err) {
    if(err.code === NOCUSTError.UNREGISTERED_WITH_COMMIT_CHAIN) {
      // Register...
    } else {
      console.error(err.message)
    }
  }

Error codes

The library supports the following error code that can be checked as in the example above. The error codes are available in the NOCUSTError enum.

UNKNOWN_ERROR

Unknown error.

UNREGISTERED_WITH_COMMIT_CHAIN

Wallet not registered with the commit-chain ledger. The address was not register with the commit-chain, the registerAddress function need to be called for the specific address and token.

PREPARE_TRANSFER_FAILURE

Could not prepare transfer/swap hashes.

SIGNING_FAILURE

Was not able to produce a signature. The function called require to sign a message with the corresponding private key. Ensure that the private key was added to the web3 object passed to the NOCUSTManager instance. To add a private key to a web3 instance do: web3.eth.accounts.wallet.add(privateKey)

POST_FAILURE

Post request to operator server failed. The server most likely replied with a more specific error.

REGISTRATION_THROTTLING

This means that the DoS protection of the server was triggered. Human verification is required. The complete the human verification the user is required to solve a captcha. The captcha page is available at <server URL>/whitelist/

FETCH_OPERATOR_DATA_ERROR

Error when fetching data from the operator HTTP or Websocket API. Please ensure that the operatorUrl parameter passed to the NOCUSTManager instance is correct and that the URL is reachable.

FETCH_PARENT_CHAIN_DATA_ERROR

Error when fetching data from contract/blockchain. Ensure that your RPC endpoint (infura ?) is working correctly. The RPC endpoint URL is passe to the NOCUSTManager instance by the parameter rpcApi.

CONFIRMATION_TIMEOUT

Confirmation timeout of transfer/registration/swap. The server could not process the action.

NON_UNIQUE_TRANSFER

The exact same transfer/swap/registration was already posted. To solve this issue adjust nonce in the transfer NOCUSTTransfer object. The nonce can also be set it to undefined to automatically assign a random nonce.

PARENT_CHAIN_TRANSACTION_FAILURE

Could not execute a blockchain transaction. Please verify that the gas limit is sufficiently high. Verify contract address and gas price. Ensure that you have enough Ether to pay for gas fees and amount,

INSUFFICIENT_WITHDRAWAL_LIMIT

You do not have enough withdrawal allowances (Yet). It is required to wait one full Eon (round) to pass for freshly received or deposited funds to be withdrawable. Use the getWithdrawalLimit function to get your current withdrawal limit.

NO_ETHER_TO_PAY_FOR_GAS

Some Ether are needed to pay for gas fees. Send a small amount of Ether to the address trying to execute the operation.

WALLET_STATE_ERROR

Wallet state service failed, meaning that there is some inconsistent data from the operator API. The error message will likely give you more information. Note this can mean that the account is potentially unsafe/out of service and you might need to initiate a challenge/recover.

INSUFFICIENT_COMMIT_CHAIN_BALANCE

Not enough commit-chain/off-chain funds

​

SWAP_PENDING

A swap is pending so the account can't be use until the swap is finalized, canceled or the eon ends.

​

​

​