@aeternity/aepp-sdk 12.1.3 → 13.0.0-alpha.1

package/es/channel/Contract.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Contract.mjs","names":["snakeToPascal","MIN_GAS_PRICE","Tag","signAndNotify","awaitingCompletion","channelClosed","channelOpen","handleUnexpectedMessage","notify","call","changeState","emit","Channel","ChannelSpend","UnexpectedChannelMessageError","unpackTx","encodeContractAddress","snakeToPascalObjKeys","obj","Object","entries","reduce","result","key","val","ChannelContract","initialize","options","_initialize","createContract","sign","code","callData","deposit","vmVersion","abiVersion","enqueueAction","call_data","vm_version","abi_version","handler","_","message","state","method","params","data","tx","_2","message2","state2","round","SignedTx","encodedTx","addressKey","_options","role","owner","resolve","accepted","address","signedTx","callContract","amount","contract","contract_id","updates","forceProgress","gasLimit","gasPrice","onOnChainTx","gas_price","gas","info","type","callContractStatic","getContractCall","caller","caller_id","getContractState","pubkey","cleanContractCalls","reject"],"sources":["../../src/channel/Contract.ts"],"sourcesContent":["/*\n * ISC License (ISC)\n * Copyright (c) 2022 aeternity developers\n *\n *  Permission to use, copy, modify, and/or distribute this software for any\n *  purpose with or without fee is hereby granted, provided that the above\n *  copyright notice and this permission notice appear in all copies.\n *\n *  THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\n *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\n *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\n *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\n *  PERFORMANCE OF THIS SOFTWARE.\n */\nimport BigNumber from 'bignumber.js';\nimport { snakeToPascal } from '../utils/string';\nimport {\n  MIN_GAS_PRICE, Tag, AbiVersion, VmVersion,\n} from '../tx/builder/constants';\nimport {\n  signAndNotify,\n  awaitingCompletion,\n  channelClosed,\n  channelOpen,\n  handleUnexpectedMessage,\n} from './handlers';\nimport {\n  notify, call, SignTx, ChannelState, ChannelOptions, ChannelMessage, ChannelFsm, changeState, emit,\n} from './internal';\nimport { Encoded } from '../utils/encoder';\nimport { ContractCallReturnType } from '../apis/node';\nimport { ContractCallObject } from '../contract/Contract';\nimport Channel from './Base';\nimport ChannelSpend from './Spend';\nimport { UnexpectedChannelMessageError } from '../utils/errors';\nimport { unpackTx } from '../tx/builder';\nimport { encodeContractAddress } from '../utils/crypto';\n\nfunction snakeToPascalObjKeys<Type>(obj: object): Type {\n  return Object.entries(obj).reduce((result, [key, val]) => ({\n    ...result,\n    [snakeToPascal(key)]: val,\n  }), {}) as Type;\n}\n\ninterface CallContractOptions {\n  amount?: number | BigNumber;\n  callData?: Encoded.ContractBytearray;\n  abiVersion?: AbiVersion;\n  contract?: Encoded.ContractAddress;\n  returnValue?: any;\n  gasUsed?: number | BigNumber;\n  gasPrice?: number | BigNumber;\n  height?: number;\n  callerNonce?: number;\n  log?: any;\n  returnType?: ContractCallReturnType;\n}\n\ninterface Contract {\n  abiVersion: AbiVersion;\n  active: boolean;\n  deposit: number | BigNumber;\n  id: string;\n  ownerId: string;\n  referrerIds: string[];\n  vmVersion: VmVersion;\n}\n\nexport default class ChannelContract extends ChannelSpend {\n  static override async initialize(options: ChannelOptions): Promise<ChannelContract> {\n    return Channel._initialize(new ChannelContract(), options);\n  }\n\n  /**\n   * Trigger create contract update\n   *\n   * The create contract update is creating a contract inside the channel's internal state tree.\n   * The update is a change to be applied on top of the latest state.\n   *\n   * That would create a contract with the poster being the owner of it. Poster commits initially\n   * a deposit amount of coins to the new contract.\n   *\n   * @param options - Options\n   * @param options.code - Api encoded compiled AEVM byte code\n   * @param options.callData - Api encoded compiled AEVM call data for the code\n   * @param options.deposit - Initial amount the owner of the contract commits to it\n   * @param options.vmVersion - Version of the Virtual Machine\n   * @param options.abiVersion - Version of the Application Binary Interface\n   * @param sign - Function which verifies and signs create contract transaction\n   * @example\n   * ```js\n   * channel.createContract({\n   *   code: 'cb_HKtpipK4aCgYb17wZ...',\n   *   callData: 'cb_1111111111111111...',\n   *   deposit: 10,\n   *   vmVersion: 3,\n   *   abiVersion: 1\n   * }).then(({ accepted, signedTx, address }) => {\n   *   if (accepted) {\n   *     console.log('New contract has been created')\n   *     console.log('Contract address:', address)\n   *   } else {\n   *     console.log('New contract has been rejected')\n   *   }\n   * })\n   * ```\n   */\n  async createContract(\n    {\n      code, callData, deposit, vmVersion, abiVersion,\n    }: {\n      code: Encoded.ContractBytearray;\n      callData: Encoded.ContractBytearray;\n      deposit: number | BigNumber;\n      vmVersion: VmVersion;\n      abiVersion: AbiVersion;\n    },\n    sign: SignTx,\n  ): Promise<{\n      accepted: boolean; signedTx: Encoded.Transaction; address: Encoded.ContractAddress;\n    }> {\n    return this.enqueueAction(() => {\n      notify(this, 'channels.update.new_contract', {\n        code,\n        call_data: callData,\n        deposit,\n        vm_version: vmVersion,\n        abi_version: abiVersion,\n      });\n      return {\n        handler: async (\n          _: Channel,\n          message: ChannelMessage,\n          state: ChannelState,\n        ): Promise<ChannelFsm> => {\n          if (message.method !== 'channels.sign.update') {\n            return handleUnexpectedMessage(this, message, state);\n          }\n          await signAndNotify(\n            this,\n            'channels.update',\n            message.params.data,\n            async (tx) => state.sign(tx),\n          );\n          return {\n            handler: (\n              _2: Channel,\n              message2: ChannelMessage,\n              state2: ChannelState,\n            ): ChannelFsm => (\n              awaitingCompletion(this, message2, state2, () => {\n                const { round } = unpackTx(message2.params.data.state, Tag.SignedTx).encodedTx;\n                const addressKey = this._options.role === 'initiator'\n                  ? 'initiatorId' : 'responderId';\n                const owner = this._options[addressKey];\n                changeState(this, message2.params.data.state);\n                state2.resolve({\n                  accepted: true,\n                  address: encodeContractAddress(owner, round),\n                  signedTx: message2.params.data.state,\n                });\n                return { handler: channelOpen };\n              })\n            ),\n            state,\n          };\n        },\n        state: { sign },\n      };\n    });\n  }\n\n  /**\n   * Trigger call a contract update\n   *\n   * The call contract update is calling a preexisting contract inside the channel's\n   * internal state tree. The update is a change to be applied on top of the latest state.\n   *\n   * That would call a contract with the poster being the caller of it. Poster commits\n   * an amount of coins to the contract.\n   *\n   * The call would also create a call object inside the channel state tree. It contains\n   * the result of the contract call.\n   *\n   * It is worth mentioning that the gas is not consumed, because this is an off-chain\n   * contract call. It would be consumed if it were an on-chain one. This could happen\n   * if a call with a similar computation amount is to be forced on-chain.\n   *\n   * @param options - Options\n   * @param options.amount - Amount the caller of the contract commits to it\n   * @param options.callData - ABI encoded compiled AEVM call data for the code\n   * @param options.contract - Address of the contract to call\n   * @param options.abiVersion - Version of the ABI\n   * @param sign - Function which verifies and signs contract call transaction\n   * @example\n   * ```js\n   * channel.callContract({\n   *   contract: 'ct_9sRA9AVE4BYTAkh5RNfJYmwQe1NZ4MErasQLXZkFWG43TPBqa',\n   *   callData: 'cb_1111111111111111...',\n   *   amount: 0,\n   *   abiVersion: 1\n   * }).then(({ accepted, signedTx }) => {\n   *   if (accepted) {\n   *     console.log('Contract called succesfully')\n   *   } else {\n   *     console.log('Contract call has been rejected')\n   *   }\n   * })\n   * ```\n   */\n  async callContract(\n    {\n      amount, callData, contract, abiVersion,\n    }: CallContractOptions,\n    sign: SignTx,\n  ): Promise<{ accepted: boolean; signedTx: Encoded.Transaction }> {\n    return this.enqueueAction(() => {\n      notify(this, 'channels.update.call_contract', {\n        amount,\n        call_data: callData,\n        contract_id: contract,\n        abi_version: abiVersion,\n      });\n      return {\n        handler: async (\n          _: Channel,\n          message: ChannelMessage,\n          state: ChannelState,\n        ): Promise<ChannelFsm> => {\n          if (message.method !== 'channels.sign.update') {\n            return handleUnexpectedMessage(this, message, state);\n          }\n          await signAndNotify(\n            this,\n            'channels.update',\n            message.params.data,\n            async (tx) => state.sign(tx, { updates: message.params.data.updates }),\n          );\n          return {\n            handler: (\n              _2: Channel,\n              message2: ChannelMessage,\n              state2: ChannelState,\n            ): ChannelFsm => (\n              awaitingCompletion(this, message2, state2, () => {\n                changeState(this, message2.params.data.state);\n                state2.resolve({ accepted: true, signedTx: message2.params.data.state });\n                return { handler: channelOpen };\n              })\n            ),\n            state,\n          };\n        },\n        state: { sign },\n      };\n    });\n  }\n\n  /**\n   * Trigger a force progress contract call\n   * This call is going on-chain\n   * @param options - Options\n   * @param options.amount - Amount the caller of the contract commits to it\n   * @param options.callData - ABI encoded compiled AEVM call data for the code\n   * @param options.contract - Address of the contract to call\n   * @param options.abiVersion - Version of the ABI\n   * @param options.gasPrice=1000000000]\n   * @param options.gasLimit=1000000]\n   * @param sign - Function which verifies and signs contract force progress transaction\n   * @param callbacks - Callbacks\n   * @example\n   * ```js\n   * channel.forceProgress({\n   *   contract: 'ct_9sRA9AVE4BYTAkh5RNfJYmwQe1NZ4MErasQLXZkFWG43TPBqa',\n   *   callData: 'cb_1111111111111111...',\n   *   amount: 0,\n   *   abiVersion: 1,\n   *   gasPrice: 1000005554\n   * }).then(({ accepted, signedTx }) => {\n   *   if (accepted) {\n   *     console.log('Contract force progress call successful')\n   *   } else {\n   *     console.log('Contract force progress call has been rejected')\n   *   }\n   * })\n   * ```\n   */\n  async forceProgress(\n    {\n      amount, callData, contract, abiVersion, gasLimit = 1000000, gasPrice = MIN_GAS_PRICE,\n    }: {\n      amount: number;\n      callData: Encoded.ContractBytearray;\n      contract: Encoded.ContractAddress;\n      abiVersion: AbiVersion;\n      gasLimit?: number;\n      gasPrice?: number;\n    },\n    sign: SignTx,\n    { onOnChainTx }: Pick<ChannelState, 'onOnChainTx'> = {},\n  ): Promise<{\n      accepted: boolean;\n      signedTx: Encoded.Transaction;\n      tx: Encoded.Transaction | Uint8Array;\n    }> {\n    return this.enqueueAction(() => {\n      notify(this, 'channels.force_progress', {\n        amount,\n        call_data: callData,\n        contract_id: contract,\n        abi_version: abiVersion,\n        gas_price: gasPrice,\n        gas: gasLimit,\n      });\n      return {\n        handler: async (\n          _: Channel,\n          message: ChannelMessage,\n          state: ChannelState,\n        ): Promise<ChannelFsm> => {\n          if (message.method !== 'channels.sign.force_progress_tx') {\n            return handleUnexpectedMessage(this, message, state);\n          }\n          await signAndNotify(\n            this,\n            'channels.force_progress_sign',\n            message.params.data,\n            async (tx) => state.sign(tx, { updates: message.params.data.updates }),\n          );\n          return {\n            handler: (\n              _2: Channel,\n              message2: ChannelMessage,\n              state2: ChannelState,\n            ): ChannelFsm => {\n              if (message2.method === 'channels.on_chain_tx') {\n                state2.onOnChainTx?.(message2.params.data.tx);\n                emit(this, 'onChainTx', message2.params.data.tx, {\n                  info: message2.params.data.info,\n                  type: message2.params.data.type,\n                });\n                state2.resolve({ accepted: true, tx: message2.params.data.tx });\n                // TODO: shouldn't be unexpected message in this case\n              }\n              return handleUnexpectedMessage(this, message2, state2);\n            },\n            state,\n          };\n        },\n        state: { sign, onOnChainTx },\n      };\n    });\n  }\n\n  /**\n   * Call contract using dry-run\n   *\n   * In order to get the result of a potential contract call, one might need to\n   * dry-run a contract call. It takes the exact same arguments as a call would\n   * and returns the call object.\n   *\n   * The call is executed in the channel's state, but it does not impact the state\n   * whatsoever. It uses as an environment the latest channel's state and the current\n   * top of the blockchain as seen by the node.\n   *\n   * @param options - Options\n   * @param options.amount - Amount the caller of the contract commits to it\n   * @param options.callData - ABI encoded compiled AEVM call data for the code\n   * @param options.contract - Address of the contract to call\n   * @param options.abiVersion - Version of the ABI\n   * @example\n   * ```js\n   * channel.callContractStatic({\n   *   contract: 'ct_9sRA9AVE4BYTAkh5RNfJYmwQe1NZ4MErasQLXZkFWG43TPBqa',\n   *   callData: 'cb_1111111111111111...',\n   *   amount: 0,\n   *   abiVersion: 1\n   * }).then(({ returnValue, gasUsed }) => {\n   *   console.log('Returned value:', returnValue)\n   *   console.log('Gas used:', gasUsed)\n   * })\n   * ```\n   */\n  async callContractStatic(\n    {\n      amount, callData, contract, abiVersion,\n    }: {\n      amount: number;\n      callData: Encoded.ContractBytearray;\n      contract: Encoded.ContractAddress;\n      abiVersion: AbiVersion;\n    },\n  ): Promise<CallContractOptions> {\n    return snakeToPascalObjKeys(await call(this, 'channels.dry_run.call_contract', {\n      amount,\n      call_data: callData,\n      contract_id: contract,\n      abi_version: abiVersion,\n    }));\n  }\n\n  /**\n   * Get contract call result\n   *\n   * The combination of a caller, contract and a round of execution determines the\n   * contract call. Providing an incorrect set of those results in an error response.\n   *\n   * @param options - Options\n   * @param options.caller - Address of contract caller\n   * @param options.contract - Address of the contract\n   * @param options.round - Round when contract was called\n   * @example\n   * ```js\n   * channel.getContractCall({\n   *   caller: 'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH',\n   *   contract: 'ct_9sRA9AVE4BYTAkh5RNfJYmwQe1NZ4MErasQLXZkFWG43TPBqa',\n   *   round: 3\n   * }).then(({ returnType, returnValue }) => {\n   *   if (returnType === 'ok') console.log(returnValue)\n   * })\n   * ```\n   */\n  async getContractCall(\n    { caller, contract, round }: {\n      caller: Encoded.AccountAddress;\n      contract: Encoded.ContractAddress;\n      round: number;\n    },\n  ): Promise<ContractCallObject> {\n    return snakeToPascalObjKeys(\n      await call(this, 'channels.get.contract_call', {\n        caller_id: caller,\n        contract_id: contract,\n        round,\n      }),\n    );\n  }\n\n  /**\n   * Get the latest contract state\n   *\n   * @param contract - Address of the contract\n   * @example\n   * ```js\n   * channel.getContractState(\n   *   'ct_9sRA9AVE4BYTAkh5RNfJYmwQe1NZ4MErasQLXZkFWG43TPBqa'\n   * ).then(({ contract }) => {\n   *   console.log('deposit:', contract.deposit)\n   * })\n   * ```\n   */\n  async getContractState(\n    contract: Encoded.ContractAddress,\n  ): Promise<{ contract: Contract; contractState: object }> {\n    const result = await call(this, 'channels.get.contract', { pubkey: contract });\n    return snakeToPascalObjKeys({\n      ...result,\n      contract: snakeToPascalObjKeys(result.contract),\n    });\n  }\n\n  /**\n   * Clean up all locally stored contract calls\n   *\n   * Contract calls are kept locally in order for the participant to be able to look them up.\n   * They consume memory and in order for the participant to free it - one can prune all messages.\n   * This cleans up all locally stored contract calls and those will no longer be available for\n   * fetching and inspection.\n   */\n  async cleanContractCalls(): Promise<void> {\n    return this.enqueueAction(() => {\n      notify(this, 'channels.clean_contract_calls');\n      return {\n        handler(_: Channel, message: ChannelMessage, state: ChannelState): ChannelFsm {\n          if (message.method === 'channels.calls_pruned.reply') {\n            state.resolve();\n            return { handler: channelOpen };\n          }\n          state.reject(new UnexpectedChannelMessageError('Unexpected message received'));\n          return { handler: channelClosed };\n        },\n      };\n    });\n  }\n}\n"],"mappings":"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"}

package/es/channel/Spend.d.ts

@@ -0,0 +1,219 @@
+import BigNumber from 'bignumber.js';
+import { SignTx, ChannelState } from './internal';
+import { Encoded } from '../utils/encoder';
+import Channel from './Base';
+import { unpackTx } from '../tx/builder';
+import { Tag } from '../tx/builder/constants';
+export default class ChannelSpend extends Channel {
+    /**
+     * Trigger a transfer update
+     *
+     * The transfer update is moving coins from one channel account to another.
+     * The update is a change to be applied on top of the latest state.
+     *
+     * Sender and receiver are the channel parties. Both the initiator and responder
+     * can take those roles. Any public key outside the channel is considered invalid.
+     *
+     * @param from - Sender's public address
+     * @param to - Receiver's public address
+     * @param amount - Transaction amount
+     * @param sign - Function which verifies and signs offchain transaction
+     * @param metadata - Metadata
+  
+     * @example
+     * ```js
+     * channel.update(
+     *   'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH',
+     *   'ak_V6an1xhec1xVaAhLuak7QoEbi6t7w5hEtYWp9bMKaJ19i6A9E',
+     *   10,
+     *   async (tx) => await account.signTransaction(tx)
+     * ).then(({ accepted, signedTx }) =>
+     *   if (accepted) {
+     *     console.log('Update has been accepted')
+     *   }
+     * )
+     * ```
+     */
+    update(from: Encoded.AccountAddress, to: Encoded.AccountAddress, amount: number | BigNumber, sign: SignTx, metadata?: string[]): Promise<{
+        accepted: boolean;
+        signedTx?: Encoded.Transaction;
+        errorCode?: number;
+        errorMessage?: string;
+    }>;
+    /**
+     * Get proof of inclusion
+     *
+     * If a certain address of an account or a contract is not found
+     * in the state tree - the response is an error.
+     *
+     * @param addresses - Addresses
+     * @param addresses.accounts - List of account addresses to include in poi
+     * @param addresses.contracts - List of contract addresses to include in poi
+     * @example
+     * ```js
+     * channel.poi({
+     *   accounts: [
+     *     'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH',
+     *     'ak_V6an1xhec1xVaAhLuak7QoEbi6t7w5hEtYWp9bMKaJ19i6A9E'
+     *   ],
+     *   contracts: ['ct_2dCUAWYZdrWfACz3a2faJeKVTVrfDYxCQHCqAt5zM15f3u2UfA']
+     * }).then(poi => console.log(poi))
+     * ```
+     */
+    poi({ accounts, contracts }: {
+        accounts: Encoded.AccountAddress[];
+        contracts?: Encoded.ContractAddress[];
+    }): Promise<ReturnType<typeof unpackTx<Tag.TreesPoi>>>;
+    /**
+     * Get balances
+     *
+     * The accounts param contains a list of addresses to fetch balances of.
+     * Those can be either account balances or a contract ones, encoded as an account addresses.
+     *
+     * If a certain account address had not being found in the state tree - it is simply
+     * skipped in the response.
+     *
+     * @param accounts - List of addresses to fetch balances from
+     * @example
+     * ```js
+     * channel.balances([
+     *   'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH',
+     *   'ak_V6an1xhec1xVaAhLuak7QoEbi6t7w5hEtYWp9bMKaJ19i6A9E'
+     *   'ct_2dCUAWYZdrWfACz3a2faJeKVTVrfDYxCQHCqAt5zM15f3u2UfA'
+     * ]).then(balances =>
+     *   console.log(balances['ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH'])
+     * )
+     * ```
+     */
+    balances(accounts: Encoded.AccountAddress[]): Promise<{
+        [key: Encoded.AccountAddress]: string;
+    }>;
+    private awaitingActionTx;
+    /**
+     * Withdraw coins from the channel
+     *
+     * After the channel had been opened any of the participants can initiate a withdrawal.
+     * The process closely resembles the update. The most notable difference is that the
+     * transaction has been co-signed: it is channel_withdraw_tx and after the procedure
+     * is finished - it is being posted on-chain.
+     *
+     * Any of the participants can initiate a withdrawal. The only requirements are:
+     *
+     *   - Channel is already opened
+     *   - No off-chain update/deposit/withdrawal is currently being performed
+     *   - Channel is not being closed or in a solo closing state
+     *   - The withdrawal amount must be equal to or greater than zero, and cannot exceed
+     *     the available balance on the channel (minus the channel_reserve)
+     *
+     * After the other party had signed the withdraw transaction, the transaction is posted
+     * on-chain and onOnChainTx callback is called with on-chain transaction as first argument.
+     * After computing transaction hash it can be tracked on the chain: entering the mempool,
+     * block inclusion and a number of confirmations.
+     *
+     * After the minimum_depth block confirmations onOwnWithdrawLocked callback is called
+     * (without any arguments).
+     *
+     * When the other party had confirmed that the block height needed is reached
+     * onWithdrawLocked callback is called (without any arguments).
+     *
+     * @param amount - Amount of coins to withdraw
+     * @param sign - Function which verifies and signs withdraw transaction
+     * @param callbacks - Callbacks
+     * @param callbacks.onOnChainTx - Called when withdraw transaction has been posted
+     * on chain
+     * @param callbacks.onOwnWithdrawLocked
+     * @param callbacks.onWithdrawLocked
+     * @example
+     * ```js
+     * channel.withdraw(
+     *   100,
+     *   async (tx) => await account.signTransaction(tx),
+     *   { onOnChainTx: (tx) => console.log('on_chain_tx', tx) }
+     * ).then(({ accepted, signedTx }) => {
+     *   if (accepted) {
+     *     console.log('Withdrawal has been accepted')
+     *   } else {
+     *     console.log('Withdrawal has been rejected')
+     *   }
+     * })
+     * ```
+     */
+    withdraw(amount: number | BigNumber, sign: SignTx, { onOnChainTx, onOwnWithdrawLocked, onWithdrawLocked }?: Pick<ChannelState, 'onOnChainTx' | 'onOwnWithdrawLocked' | 'onWithdrawLocked'>): Promise<{
+        accepted: boolean;
+        signedTx: Encoded.Transaction;
+    }>;
+    /**
+     * Deposit coins into the channel
+     *
+     * After the channel had been opened any of the participants can initiate a deposit.
+     * The process closely resembles the update. The most notable difference is that the
+     * transaction has been co-signed: it is channel_deposit_tx and after the procedure
+     * is finished - it is being posted on-chain.
+     *
+     * Any of the participants can initiate a deposit. The only requirements are:
+     *
+     *   - Channel is already opened
+     *   - No off-chain update/deposit/withdrawal is currently being performed
+     *   - Channel is not being closed or in a solo closing state
+     *   - The deposit amount must be equal to or greater than zero, and cannot exceed
+     *     the available balance on the channel (minus the channel_reserve)
+     *
+     * After the other party had signed the deposit transaction, the transaction is posted
+     * on-chain and onOnChainTx callback is called with on-chain transaction as first argument.
+     * After computing transaction hash it can be tracked on the chain: entering the mempool,
+     * block inclusion and a number of confirmations.
+     *
+     * After the minimum_depth block confirmations onOwnDepositLocked callback is called
+     * (without any arguments).
+     *
+     * When the other party had confirmed that the block height needed is reached
+     * onDepositLocked callback is called (without any arguments).
+     *
+     * @param amount - Amount of coins to deposit
+     * @param sign - Function which verifies and signs deposit transaction
+     * @param callbacks - Callbacks
+     * @param callbacks.onOnChainTx - Called when deposit transaction has been posted
+     * on chain
+     * @param callbacks.onOwnDepositLocked
+     * @param callbacks.onDepositLocked
+     * @example
+     * ```js
+     * channel.deposit(
+     *   100,
+     *   async (tx) => await account.signTransaction(tx),
+     *   { onOnChainTx: (tx) => console.log('on_chain_tx', tx) }
+     * ).then(({ accepted, state }) => {
+     *   if (accepted) {
+     *     console.log('Deposit has been accepted')
+     *     console.log('The new state is:', state)
+     *   } else {
+     *     console.log('Deposit has been rejected')
+     *   }
+     * })
+     * ```
+     */
+    deposit(amount: number | BigNumber, sign: SignTx, { onOnChainTx, onOwnDepositLocked, onDepositLocked }?: Pick<ChannelState, 'onOnChainTx' | 'onOwnDepositLocked' | 'onDepositLocked'>): Promise<{
+        accepted: boolean;
+        state: ChannelState;
+    }>;
+    /**
+     * Send generic message
+     *
+     * If message is an object it will be serialized into JSON string
+     * before sending.
+     *
+     * If there is ongoing update that has not yet been finished the message
+     * will be sent after that update is finalized.
+     *
+     * @param message - Message
+     * @param recipient - Address of the recipient
+     * @example
+     * ```js
+     * channel.sendMessage(
+     *   'hello world',
+     *   'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH'
+     * )
+     * ```
+     */
+    sendMessage(message: string | object, recipient: Encoded.AccountAddress): Promise<void>;
+}

package/es/channel/Spend.mjs

@@ -0,0 +1,385 @@
+/*
+ * ISC License (ISC)
+ * Copyright (c) 2022 aeternity developers
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any
+ *  purpose with or without fee is hereby granted, provided that the above
+ *  copyright notice and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ *  PERFORMANCE OF THIS SOFTWARE.
+ */
+import { notify, call, changeState } from "./internal.mjs";
+import { pause } from "../utils/other.mjs";
+import Channel from "./Base.mjs";
+import { ChannelConnectionError } from "../utils/errors.mjs";
+import { awaitingCompletion, channelOpen, handleUnexpectedMessage, signAndNotify } from "./handlers.mjs";
+import { unpackTx } from "../tx/builder/index.mjs";
+import { Tag } from "../tx/builder/constants.mjs";
+export default class ChannelSpend extends Channel {
+  /**
+   * Trigger a transfer update
+   *
+   * The transfer update is moving coins from one channel account to another.
+   * The update is a change to be applied on top of the latest state.
+   *
+   * Sender and receiver are the channel parties. Both the initiator and responder
+   * can take those roles. Any public key outside the channel is considered invalid.
+   *
+   * @param from - Sender's public address
+   * @param to - Receiver's public address
+   * @param amount - Transaction amount
+   * @param sign - Function which verifies and signs offchain transaction
+   * @param metadata - Metadata
+    * @example
+   * ```js
+   * channel.update(
+   *   'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH',
+   *   'ak_V6an1xhec1xVaAhLuak7QoEbi6t7w5hEtYWp9bMKaJ19i6A9E',
+   *   10,
+   *   async (tx) => await account.signTransaction(tx)
+   * ).then(({ accepted, signedTx }) =>
+   *   if (accepted) {
+   *     console.log('Update has been accepted')
+   *   }
+   * )
+   * ```
+   */
+  async update(from, to, amount, sign) {
+    let metadata = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
+    return this.enqueueAction(() => {
+      notify(this, 'channels.update.new', {
+        from,
+        to,
+        amount,
+        meta: metadata
+      });
+      const awaitingOffChainTx = async (_, message, state) => {
+        if (message.method === 'channels.sign.update') {
+          const isError = await signAndNotify(this, 'channels.update', message.params.data, async tx => sign(tx, {
+            updates: message.params.data.updates
+          }));
+          if (isError) return {
+            handler: awaitingOffChainTx,
+            state
+          };
+          return {
+            handler: (_2, message2) => awaitingCompletion(this, message2, state, () => {
+              changeState(this, message2.params.data.state);
+              state.resolve({
+                accepted: true,
+                signedTx: message2.params.data.state
+              });
+              return {
+                handler: channelOpen
+              };
+            }),
+            state
+          };
+        }
+        if (message.method === 'channels.error') {
+          state.reject(new ChannelConnectionError(message.data.message));
+          return {
+            handler: channelOpen
+          };
+        }
+        return awaitingCompletion(this, message, state);
+      };
+      return {
+        handler: awaitingOffChainTx
+      };
+    });
+  }
+
+  /**
+   * Get proof of inclusion
+   *
+   * If a certain address of an account or a contract is not found
+   * in the state tree - the response is an error.
+   *
+   * @param addresses - Addresses
+   * @param addresses.accounts - List of account addresses to include in poi
+   * @param addresses.contracts - List of contract addresses to include in poi
+   * @example
+   * ```js
+   * channel.poi({
+   *   accounts: [
+   *     'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH',
+   *     'ak_V6an1xhec1xVaAhLuak7QoEbi6t7w5hEtYWp9bMKaJ19i6A9E'
+   *   ],
+   *   contracts: ['ct_2dCUAWYZdrWfACz3a2faJeKVTVrfDYxCQHCqAt5zM15f3u2UfA']
+   * }).then(poi => console.log(poi))
+   * ```
+   */
+  async poi(_ref) {
+    let {
+      accounts,
+      contracts
+    } = _ref;
+    return unpackTx((await call(this, 'channels.get.poi', {
+      accounts,
+      contracts
+    })).poi, Tag.TreesPoi);
+  }
+
+  /**
+   * Get balances
+   *
+   * The accounts param contains a list of addresses to fetch balances of.
+   * Those can be either account balances or a contract ones, encoded as an account addresses.
+   *
+   * If a certain account address had not being found in the state tree - it is simply
+   * skipped in the response.
+   *
+   * @param accounts - List of addresses to fetch balances from
+   * @example
+   * ```js
+   * channel.balances([
+   *   'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH',
+   *   'ak_V6an1xhec1xVaAhLuak7QoEbi6t7w5hEtYWp9bMKaJ19i6A9E'
+   *   'ct_2dCUAWYZdrWfACz3a2faJeKVTVrfDYxCQHCqAt5zM15f3u2UfA'
+   * ]).then(balances =>
+   *   console.log(balances['ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH'])
+   * )
+   * ```
+   */
+  async balances(accounts) {
+    return Object.fromEntries((await call(this, 'channels.get.balances', {
+      accounts
+    })).map(item => [item.account, item.balance]));
+  }
+  async awaitingActionTx(action, message, state) {
+    if (message.method !== `channels.sign.${action}_tx`) {
+      return handleUnexpectedMessage(this, message, state);
+    }
+    const awaitingActionCompletion = (_, message2) => {
+      if (message2.method === 'channels.on_chain_tx') {
+        var _state$onOnChainTx;
+        (_state$onOnChainTx = state.onOnChainTx) === null || _state$onOnChainTx === void 0 ? void 0 : _state$onOnChainTx.call(state, message2.params.data.tx);
+        return {
+          handler: awaitingActionCompletion,
+          state
+        };
+      }
+      if (message2.method === 'channels.info' && [`own_${action}_locked`, `${action}_locked`].includes(message2.params.data.event)) {
+        var _state;
+        const Action = action === 'deposit' ? 'Deposit' : 'Withdraw';
+        const isOwn = message2.params.data.event.startsWith('own_');
+        (_state = state[`on${isOwn ? 'Own' : ''}${Action}Locked`]) === null || _state === void 0 ? void 0 : _state.call(state);
+        return {
+          handler: awaitingActionCompletion,
+          state
+        };
+      }
+      return awaitingCompletion(this, message2, state, () => {
+        changeState(this, message2.params.data.state);
+        state.resolve({
+          accepted: true,
+          signedTx: message2.params.data.state
+        });
+        return {
+          handler: channelOpen
+        };
+      });
+    };
+    const {
+      sign
+    } = state;
+    await signAndNotify(this, `channels.${action}_tx`, message.params.data, async tx => sign(tx, {
+      updates: message.params.data.updates
+    }));
+    return {
+      handler: awaitingActionCompletion,
+      state
+    };
+  }
+
+  /**
+   * Withdraw coins from the channel
+   *
+   * After the channel had been opened any of the participants can initiate a withdrawal.
+   * The process closely resembles the update. The most notable difference is that the
+   * transaction has been co-signed: it is channel_withdraw_tx and after the procedure
+   * is finished - it is being posted on-chain.
+   *
+   * Any of the participants can initiate a withdrawal. The only requirements are:
+   *
+   *   - Channel is already opened
+   *   - No off-chain update/deposit/withdrawal is currently being performed
+   *   - Channel is not being closed or in a solo closing state
+   *   - The withdrawal amount must be equal to or greater than zero, and cannot exceed
+   *     the available balance on the channel (minus the channel_reserve)
+   *
+   * After the other party had signed the withdraw transaction, the transaction is posted
+   * on-chain and onOnChainTx callback is called with on-chain transaction as first argument.
+   * After computing transaction hash it can be tracked on the chain: entering the mempool,
+   * block inclusion and a number of confirmations.
+   *
+   * After the minimum_depth block confirmations onOwnWithdrawLocked callback is called
+   * (without any arguments).
+   *
+   * When the other party had confirmed that the block height needed is reached
+   * onWithdrawLocked callback is called (without any arguments).
+   *
+   * @param amount - Amount of coins to withdraw
+   * @param sign - Function which verifies and signs withdraw transaction
+   * @param callbacks - Callbacks
+   * @param callbacks.onOnChainTx - Called when withdraw transaction has been posted
+   * on chain
+   * @param callbacks.onOwnWithdrawLocked
+   * @param callbacks.onWithdrawLocked
+   * @example
+   * ```js
+   * channel.withdraw(
+   *   100,
+   *   async (tx) => await account.signTransaction(tx),
+   *   { onOnChainTx: (tx) => console.log('on_chain_tx', tx) }
+   * ).then(({ accepted, signedTx }) => {
+   *   if (accepted) {
+   *     console.log('Withdrawal has been accepted')
+   *   } else {
+   *     console.log('Withdrawal has been rejected')
+   *   }
+   * })
+   * ```
+   */
+  async withdraw(amount, sign) {
+    let {
+      onOnChainTx,
+      onOwnWithdrawLocked,
+      onWithdrawLocked
+    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    return this.enqueueAction(() => {
+      notify(this, 'channels.withdraw', {
+        amount
+      });
+      return {
+        handler: async (_, message, state) => this.awaitingActionTx('withdraw', message, state),
+        state: {
+          sign,
+          onOnChainTx,
+          onOwnWithdrawLocked,
+          onWithdrawLocked
+        }
+      };
+    });
+  }
+
+  /**
+   * Deposit coins into the channel
+   *
+   * After the channel had been opened any of the participants can initiate a deposit.
+   * The process closely resembles the update. The most notable difference is that the
+   * transaction has been co-signed: it is channel_deposit_tx and after the procedure
+   * is finished - it is being posted on-chain.
+   *
+   * Any of the participants can initiate a deposit. The only requirements are:
+   *
+   *   - Channel is already opened
+   *   - No off-chain update/deposit/withdrawal is currently being performed
+   *   - Channel is not being closed or in a solo closing state
+   *   - The deposit amount must be equal to or greater than zero, and cannot exceed
+   *     the available balance on the channel (minus the channel_reserve)
+   *
+   * After the other party had signed the deposit transaction, the transaction is posted
+   * on-chain and onOnChainTx callback is called with on-chain transaction as first argument.
+   * After computing transaction hash it can be tracked on the chain: entering the mempool,
+   * block inclusion and a number of confirmations.
+   *
+   * After the minimum_depth block confirmations onOwnDepositLocked callback is called
+   * (without any arguments).
+   *
+   * When the other party had confirmed that the block height needed is reached
+   * onDepositLocked callback is called (without any arguments).
+   *
+   * @param amount - Amount of coins to deposit
+   * @param sign - Function which verifies and signs deposit transaction
+   * @param callbacks - Callbacks
+   * @param callbacks.onOnChainTx - Called when deposit transaction has been posted
+   * on chain
+   * @param callbacks.onOwnDepositLocked
+   * @param callbacks.onDepositLocked
+   * @example
+   * ```js
+   * channel.deposit(
+   *   100,
+   *   async (tx) => await account.signTransaction(tx),
+   *   { onOnChainTx: (tx) => console.log('on_chain_tx', tx) }
+   * ).then(({ accepted, state }) => {
+   *   if (accepted) {
+   *     console.log('Deposit has been accepted')
+   *     console.log('The new state is:', state)
+   *   } else {
+   *     console.log('Deposit has been rejected')
+   *   }
+   * })
+   * ```
+   */
+  async deposit(amount, sign) {
+    let {
+      onOnChainTx,
+      onOwnDepositLocked,
+      onDepositLocked
+    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    return this.enqueueAction(() => {
+      notify(this, 'channels.deposit', {
+        amount
+      });
+      return {
+        handler: async (_, message, state) => this.awaitingActionTx('deposit', message, state),
+        state: {
+          sign,
+          onOnChainTx,
+          onOwnDepositLocked,
+          onDepositLocked
+        }
+      };
+    });
+  }
+
+  /**
+   * Send generic message
+   *
+   * If message is an object it will be serialized into JSON string
+   * before sending.
+   *
+   * If there is ongoing update that has not yet been finished the message
+   * will be sent after that update is finalized.
+   *
+   * @param message - Message
+   * @param recipient - Address of the recipient
+   * @example
+   * ```js
+   * channel.sendMessage(
+   *   'hello world',
+   *   'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH'
+   * )
+   * ```
+   */
+  async sendMessage(message, recipient) {
+    const info = typeof message === 'object' ? JSON.stringify(message) : message;
+    if (this.status() === 'connecting') {
+      await new Promise(resolve => {
+        const onStatusChanged = status => {
+          if (status === 'connecting') return;
+          resolve();
+          this.off('statusChanged', onStatusChanged);
+        };
+        this.on('statusChanged', onStatusChanged);
+      });
+      // For some reason we can't immediately send a message when connection is
+      // established. Thus we wait 500ms which seems to work.
+      await pause(500);
+    }
+    notify(this, 'channels.message', {
+      info,
+      to: recipient
+    });
+  }
+}
+//# sourceMappingURL=Spend.mjs.map