@aeternity/aepp-sdk 13.3.3 → 14.1.0

package/es/channel/Spend.js

@@ -0,0 +1,357 @@
+import { notify, call, changeState } from './internal.js';
+import { pause } from '../utils/other.js';
+import Channel from './Base.js';
+import { ChannelConnectionError } from '../utils/errors.js';
+import { awaitingCompletion, channelOpen, handleUnexpectedMessage, signAndNotify } from './handlers.js';
+import { unpackEntry } from '../tx/builder/entry/index.js';
+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, metadata = []) {
+    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({
+    accounts,
+    contracts
+  }) {
+    const {
+      poi
+    } = await call(this, 'channels.get.poi', {
+      accounts,
+      contracts
+    });
+    return unpackEntry(poi);
+  }
+
+  /**
+   * 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') {
+        state.onOnChainTx?.(message2.params.data.tx);
+        return {
+          handler: awaitingActionCompletion,
+          state
+        };
+      }
+      if (message2.method === 'channels.info' && [`own_${action}_locked`, `${action}_locked`].includes(message2.params.data.event)) {
+        const Action = action === 'deposit' ? 'Deposit' : 'Withdraw';
+        const isOwn = message2.params.data.event.startsWith('own_');
+        state[`on${isOwn ? 'Own' : ''}${Action}Locked`]?.();
+        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
+   * @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, {
+    onOnChainTx,
+    onOwnWithdrawLocked,
+    onWithdrawLocked
+  } = {}) {
+    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
+   * @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, {
+    onOnChainTx,
+    onOwnDepositLocked,
+    onDepositLocked
+  } = {}) {
+    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.js.map

package/es/channel/Spend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Spend.js","names":["notify","call","changeState","pause","Channel","ChannelConnectionError","awaitingCompletion","channelOpen","handleUnexpectedMessage","signAndNotify","unpackEntry","ChannelSpend","update","from","to","amount","sign","metadata","enqueueAction","meta","awaitingOffChainTx","_","message","state","method","isError","params","data","tx","updates","handler","_2","message2","resolve","accepted","signedTx","reject","poi","accounts","contracts","balances","Object","fromEntries","map","item","account","balance","awaitingActionTx","action","awaitingActionCompletion","onOnChainTx","includes","event","Action","isOwn","startsWith","withdraw","onOwnWithdrawLocked","onWithdrawLocked","deposit","onOwnDepositLocked","onDepositLocked","sendMessage","recipient","info","JSON","stringify","status","Promise","onStatusChanged","off","on"],"sources":["../../src/channel/Spend.ts"],"sourcesContent":["import BigNumber from 'bignumber.js';\nimport {\n  notify,\n  call,\n  SignTx,\n  ChannelState,\n  ChannelMessage,\n  ChannelFsm,\n  changeState,\n} from './internal.js';\nimport { Encoded } from '../utils/encoder.js';\nimport { pause } from '../utils/other.js';\nimport Channel from './Base.js';\nimport { ChannelConnectionError } from '../utils/errors.js';\nimport {\n  awaitingCompletion,\n  channelOpen,\n  handleUnexpectedMessage,\n  signAndNotify,\n} from './handlers.js';\nimport { EntryTag } from '../tx/builder/entry/constants.js';\nimport { EntUnpacked } from '../tx/builder/entry/schema.generated.js';\nimport { unpackEntry } from '../tx/builder/entry/index.js';\n\nexport default class ChannelSpend extends Channel {\n  /**\n   * Trigger a transfer update\n   *\n   * The transfer update is moving coins from one channel account to another.\n   * The update is a change to be applied on top of the latest state.\n   *\n   * Sender and receiver are the channel parties. Both the initiator and responder\n   * can take those roles. Any public key outside the channel is considered invalid.\n   *\n   * @param from - Sender's public address\n   * @param to - Receiver's public address\n   * @param amount - Transaction amount\n   * @param sign - Function which verifies and signs offchain transaction\n   * @param metadata - Metadata\n\n   * @example\n   * ```js\n   * channel.update(\n   *   'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH',\n   *   'ak_V6an1xhec1xVaAhLuak7QoEbi6t7w5hEtYWp9bMKaJ19i6A9E',\n   *   10,\n   *   async (tx) => await account.signTransaction(tx)\n   * ).then(({ accepted, signedTx }) =>\n   *   if (accepted) {\n   *     console.log('Update has been accepted')\n   *   }\n   * )\n   * ```\n   */\n  async update(\n    from: Encoded.AccountAddress,\n    to: Encoded.AccountAddress,\n    amount: number | BigNumber,\n    sign: SignTx,\n    metadata: string[] = [],\n  ): Promise<{\n    accepted: boolean;\n    signedTx?: Encoded.Transaction;\n    errorCode?: number;\n    errorMessage?: string;\n  }> {\n    return this.enqueueAction(() => {\n      notify(this, 'channels.update.new', {\n        from,\n        to,\n        amount,\n        meta: metadata,\n      });\n\n      const awaitingOffChainTx = async (\n        _: Channel,\n        message: ChannelMessage,\n        state: ChannelState,\n      ): Promise<ChannelFsm> => {\n        if (message.method === 'channels.sign.update') {\n          const isError = await signAndNotify(\n            this,\n            'channels.update',\n            message.params.data,\n            async (tx) => sign(tx, { updates: message.params.data.updates }),\n          );\n          if (isError) return { handler: awaitingOffChainTx, state };\n          return {\n            handler: (_2: Channel, message2: ChannelMessage): ChannelFsm =>\n              awaitingCompletion(this, message2, state, () => {\n                changeState(this, message2.params.data.state);\n                state.resolve({ accepted: true, signedTx: message2.params.data.state });\n                return { handler: channelOpen };\n              }),\n            state,\n          };\n        }\n        if (message.method === 'channels.error') {\n          state.reject(new ChannelConnectionError(message.data.message));\n          return { handler: channelOpen };\n        }\n        return awaitingCompletion(this, message, state);\n      };\n\n      return { handler: awaitingOffChainTx };\n    });\n  }\n\n  /**\n   * Get proof of inclusion\n   *\n   * If a certain address of an account or a contract is not found\n   * in the state tree - the response is an error.\n   *\n   * @param addresses - Addresses\n   * @param addresses.accounts - List of account addresses to include in poi\n   * @param addresses.contracts - List of contract addresses to include in poi\n   * @example\n   * ```js\n   * channel.poi({\n   *   accounts: [\n   *     'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH',\n   *     'ak_V6an1xhec1xVaAhLuak7QoEbi6t7w5hEtYWp9bMKaJ19i6A9E'\n   *   ],\n   *   contracts: ['ct_2dCUAWYZdrWfACz3a2faJeKVTVrfDYxCQHCqAt5zM15f3u2UfA']\n   * }).then(poi => console.log(poi))\n   * ```\n   */\n  async poi({\n    accounts,\n    contracts,\n  }: {\n    accounts: Encoded.AccountAddress[];\n    contracts?: Encoded.ContractAddress[];\n  }): Promise<EntUnpacked & { tag: EntryTag.TreesPoi }> {\n    const { poi }: { poi: Encoded.Poi } = await call(this, 'channels.get.poi', {\n      accounts,\n      contracts,\n    });\n    return unpackEntry(poi);\n  }\n\n  /**\n   * Get balances\n   *\n   * The accounts param contains a list of addresses to fetch balances of.\n   * Those can be either account balances or a contract ones, encoded as an account addresses.\n   *\n   * If a certain account address had not being found in the state tree - it is simply\n   * skipped in the response.\n   *\n   * @param accounts - List of addresses to fetch balances from\n   * @example\n   * ```js\n   * channel.balances([\n   *   'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH',\n   *   'ak_V6an1xhec1xVaAhLuak7QoEbi6t7w5hEtYWp9bMKaJ19i6A9E'\n   *   'ct_2dCUAWYZdrWfACz3a2faJeKVTVrfDYxCQHCqAt5zM15f3u2UfA'\n   * ]).then(balances =>\n   *   console.log(balances['ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH'])\n   * )\n   * ```\n   */\n  async balances(\n    accounts: Encoded.AccountAddress[],\n  ): Promise<{ [key: Encoded.AccountAddress]: string }> {\n    return Object.fromEntries(\n      (await call(this, 'channels.get.balances', { accounts })).map(\n        (item: { account: Encoded.AccountAddress; balance: string }) => [\n          item.account,\n          item.balance,\n        ],\n      ),\n    );\n  }\n\n  private async awaitingActionTx(\n    action: 'deposit' | 'withdraw',\n    message: ChannelMessage,\n    state: ChannelState,\n  ): Promise<ChannelFsm> {\n    if (message.method !== `channels.sign.${action}_tx`) {\n      return handleUnexpectedMessage(this, message, state);\n    }\n\n    const awaitingActionCompletion = (_: Channel, message2: ChannelMessage): ChannelFsm => {\n      if (message2.method === 'channels.on_chain_tx') {\n        state.onOnChainTx?.(message2.params.data.tx);\n        return { handler: awaitingActionCompletion, state };\n      }\n      if (\n        message2.method === 'channels.info' &&\n        [`own_${action}_locked`, `${action}_locked`].includes(message2.params.data.event)\n      ) {\n        const Action = action === 'deposit' ? 'Deposit' : 'Withdraw';\n        const isOwn: boolean = message2.params.data.event.startsWith('own_');\n        state[`on${isOwn ? 'Own' : ''}${Action}Locked`]?.();\n        return { handler: awaitingActionCompletion, state };\n      }\n      return awaitingCompletion(this, message2, state, () => {\n        changeState(this, message2.params.data.state);\n        state.resolve({ accepted: true, signedTx: message2.params.data.state });\n        return { handler: channelOpen };\n      });\n    };\n\n    const { sign } = state;\n    await signAndNotify(this, `channels.${action}_tx`, message.params.data, async (tx) =>\n      sign(tx, { updates: message.params.data.updates }),\n    );\n    return { handler: awaitingActionCompletion, state };\n  }\n\n  /**\n   * Withdraw coins from the channel\n   *\n   * After the channel had been opened any of the participants can initiate a withdrawal.\n   * The process closely resembles the update. The most notable difference is that the\n   * transaction has been co-signed: it is channel_withdraw_tx and after the procedure\n   * is finished - it is being posted on-chain.\n   *\n   * Any of the participants can initiate a withdrawal. The only requirements are:\n   *\n   *   - Channel is already opened\n   *   - No off-chain update/deposit/withdrawal is currently being performed\n   *   - Channel is not being closed or in a solo closing state\n   *   - The withdrawal amount must be equal to or greater than zero, and cannot exceed\n   *     the available balance on the channel (minus the channel_reserve)\n   *\n   * After the other party had signed the withdraw transaction, the transaction is posted\n   * on-chain and onOnChainTx callback is called with on-chain transaction as first argument.\n   * After computing transaction hash it can be tracked on the chain: entering the mempool,\n   * block inclusion and a number of confirmations.\n   *\n   * After the minimum_depth block confirmations onOwnWithdrawLocked callback is called\n   * (without any arguments).\n   *\n   * When the other party had confirmed that the block height needed is reached\n   * onWithdrawLocked callback is called (without any arguments).\n   *\n   * @param amount - Amount of coins to withdraw\n   * @param sign - Function which verifies and signs withdraw transaction\n   * @param callbacks - Callbacks\n   * @example\n   * ```js\n   * channel.withdraw(\n   *   100,\n   *   async (tx) => await account.signTransaction(tx),\n   *   { onOnChainTx: (tx) => console.log('on_chain_tx', tx) }\n   * ).then(({ accepted, signedTx }) => {\n   *   if (accepted) {\n   *     console.log('Withdrawal has been accepted')\n   *   } else {\n   *     console.log('Withdrawal has been rejected')\n   *   }\n   * })\n   * ```\n   */\n  async withdraw(\n    amount: number | BigNumber,\n    sign: SignTx,\n    {\n      onOnChainTx,\n      onOwnWithdrawLocked,\n      onWithdrawLocked,\n    }: Pick<ChannelState, 'onOnChainTx' | 'onOwnWithdrawLocked' | 'onWithdrawLocked'> = {},\n  ): Promise<{ accepted: boolean; signedTx: Encoded.Transaction }> {\n    return this.enqueueAction(() => {\n      notify(this, 'channels.withdraw', { amount });\n      return {\n        handler: async (\n          _: Channel,\n          message: ChannelMessage,\n          state: ChannelState,\n        ): Promise<ChannelFsm> => this.awaitingActionTx('withdraw', message, state),\n        state: {\n          sign,\n          onOnChainTx,\n          onOwnWithdrawLocked,\n          onWithdrawLocked,\n        },\n      };\n    });\n  }\n\n  /**\n   * Deposit coins into the channel\n   *\n   * After the channel had been opened any of the participants can initiate a deposit.\n   * The process closely resembles the update. The most notable difference is that the\n   * transaction has been co-signed: it is channel_deposit_tx and after the procedure\n   * is finished - it is being posted on-chain.\n   *\n   * Any of the participants can initiate a deposit. The only requirements are:\n   *\n   *   - Channel is already opened\n   *   - No off-chain update/deposit/withdrawal is currently being performed\n   *   - Channel is not being closed or in a solo closing state\n   *   - The deposit amount must be equal to or greater than zero, and cannot exceed\n   *     the available balance on the channel (minus the channel_reserve)\n   *\n   * After the other party had signed the deposit transaction, the transaction is posted\n   * on-chain and onOnChainTx callback is called with on-chain transaction as first argument.\n   * After computing transaction hash it can be tracked on the chain: entering the mempool,\n   * block inclusion and a number of confirmations.\n   *\n   * After the minimum_depth block confirmations onOwnDepositLocked callback is called\n   * (without any arguments).\n   *\n   * When the other party had confirmed that the block height needed is reached\n   * onDepositLocked callback is called (without any arguments).\n   *\n   * @param amount - Amount of coins to deposit\n   * @param sign - Function which verifies and signs deposit transaction\n   * @param callbacks - Callbacks\n   * @example\n   * ```js\n   * channel.deposit(\n   *   100,\n   *   async (tx) => await account.signTransaction(tx),\n   *   { onOnChainTx: (tx) => console.log('on_chain_tx', tx) }\n   * ).then(({ accepted, state }) => {\n   *   if (accepted) {\n   *     console.log('Deposit has been accepted')\n   *     console.log('The new state is:', state)\n   *   } else {\n   *     console.log('Deposit has been rejected')\n   *   }\n   * })\n   * ```\n   */\n  async deposit(\n    amount: number | BigNumber,\n    sign: SignTx,\n    {\n      onOnChainTx,\n      onOwnDepositLocked,\n      onDepositLocked,\n    }: Pick<ChannelState, 'onOnChainTx' | 'onOwnDepositLocked' | 'onDepositLocked'> = {},\n  ): Promise<{ accepted: boolean; state: ChannelState }> {\n    return this.enqueueAction(() => {\n      notify(this, 'channels.deposit', { amount });\n      return {\n        handler: async (\n          _: Channel,\n          message: ChannelMessage,\n          state: ChannelState,\n        ): Promise<ChannelFsm> => this.awaitingActionTx('deposit', message, state),\n        state: {\n          sign,\n          onOnChainTx,\n          onOwnDepositLocked,\n          onDepositLocked,\n        },\n      };\n    });\n  }\n\n  /**\n   * Send generic message\n   *\n   * If message is an object it will be serialized into JSON string\n   * before sending.\n   *\n   * If there is ongoing update that has not yet been finished the message\n   * will be sent after that update is finalized.\n   *\n   * @param message - Message\n   * @param recipient - Address of the recipient\n   * @example\n   * ```js\n   * channel.sendMessage(\n   *   'hello world',\n   *   'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH'\n   * )\n   * ```\n   */\n  async sendMessage(message: string | object, recipient: Encoded.AccountAddress): Promise<void> {\n    const info = typeof message === 'object' ? JSON.stringify(message) : message;\n    if (this.status() === 'connecting') {\n      await new Promise<void>((resolve) => {\n        const onStatusChanged = (status: string): void => {\n          if (status === 'connecting') return;\n          resolve();\n          this.off('statusChanged', onStatusChanged);\n        };\n        this.on('statusChanged', onStatusChanged);\n      });\n      // For some reason we can't immediately send a message when connection is\n      // established. Thus we wait 500ms which seems to work.\n      await pause(500);\n    }\n    notify(this, 'channels.message', { info, to: recipient });\n  }\n}\n"],"mappings":"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uC,MAAM,KAAK,EAAE1B,OAAO,CAACI,MAAM,CAACC,IAAI,EAAE,MAAOC,EAAE,IAC/EZ,IAAI,CAACY,EAAE,EAAE;MAAEC,OAAO,EAAEP,OAAO,CAACI,MAAM,CAACC,IAAI,CAACE;IAAQ,CAAC,CACnD,CAAC;IACD,OAAO;MAAEC,OAAO,EAAEmB,wBAAwB;MAAE1B;IAAM,CAAC;EACrD;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMiC,QAAQA,CACZzC,MAA0B,EAC1BC,IAAY,EACZ;IACEkC,WAAW;IACXO,mBAAmB;IACnBC;EAC8E,CAAC,GAAG,CAAC,CAAC,EACvB;IAC/D,OAAO,IAAI,CAACxC,aAAa,CAAC,MAAM;MAC9BlB,MAAM,CAAC,IAAI,EAAE,mBAAmB,EAAE;QAAEe;MAAO,CAAC,CAAC;MAC7C,OAAO;QACLe,OAAO,EAAE,MAAAA,CACPT,CAAU,EACVC,OAAuB,EACvBC,KAAmB,KACK,IAAI,CAACwB,gBAAgB,CAAC,UAAU,EAAEzB,OAAO,EAAEC,KAAK,CAAC;QAC3EA,KAAK,EAAE;UACLP,IAAI;UACJkC,WAAW;UACXO,mBAAmB;UACnBC;QACF;MACF,CAAC;IACH,CAAC,CAAC;EACJ;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMC,OAAOA,CACX5C,MAA0B,EAC1BC,IAAY,EACZ;IACEkC,WAAW;IACXU,kBAAkB;IAClBC;EAC4E,CAAC,GAAG,CAAC,CAAC,EAC/B;IACrD,OAAO,IAAI,CAAC3C,aAAa,CAAC,MAAM;MAC9BlB,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE;QAAEe;MAAO,CAAC,CAAC;MAC5C,OAAO;QACLe,OAAO,EAAE,MAAAA,CACPT,CAAU,EACVC,OAAuB,EACvBC,KAAmB,KACK,IAAI,CAACwB,gBAAgB,CAAC,SAAS,EAAEzB,OAAO,EAAEC,KAAK,CAAC;QAC1EA,KAAK,EAAE;UACLP,IAAI;UACJkC,WAAW;UACXU,kBAAkB;UAClBC;QACF;MACF,CAAC;IACH,CAAC,CAAC;EACJ;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMC,WAAWA,CAACxC,OAAwB,EAAEyC,SAAiC,EAAiB;IAC5F,MAAMC,IAAI,GAAG,OAAO1C,OAAO,KAAK,QAAQ,GAAG2C,IAAI,CAACC,SAAS,CAAC5C,OAAO,CAAC,GAAGA,OAAO;IAC5E,IAAI,IAAI,CAAC6C,MAAM,CAAC,CAAC,KAAK,YAAY,EAAE;MAClC,MAAM,IAAIC,OAAO,CAAQnC,OAAO,IAAK;QACnC,MAAMoC,eAAe,GAAIF,MAAc,IAAW;UAChD,IAAIA,MAAM,KAAK,YAAY,EAAE;UAC7BlC,OAAO,CAAC,CAAC;UACT,IAAI,CAACqC,GAAG,CAAC,eAAe,EAAED,eAAe,CAAC;QAC5C,CAAC;QACD,IAAI,CAACE,EAAE,CAAC,eAAe,EAAEF,eAAe,CAAC;MAC3C,CAAC,CAAC;MACF;MACA;MACA,MAAMlE,KAAK,CAAC,GAAG,CAAC;IAClB;IACAH,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE;MAAEgE,IAAI;MAAElD,EAAE,EAAEiD;IAAU,CAAC,CAAC;EAC3D;AACF","ignoreList":[]}

package/es/channel/handlers.d.ts

@@ -1,6 +1,6 @@
-import { ChannelState, ChannelMessage, ChannelFsm, SignTx } from './internal';
-import { Encoded } from '../utils/encoder';
-import type Channel from './Base';
+import { ChannelState, ChannelMessage, ChannelFsm, SignTx } from './internal.js';
+import { Encoded } from '../utils/encoder.js';
+import type Channel from './Base.js';
 export declare function appendSignature(tx: Encoded.Transaction, signFn: SignTx): Promise<Encoded.Transaction | number | null>;
 export declare function signAndNotify(channel: Channel, method: string, data: {
     tx?: Encoded.Transaction;
@@ -9,6 +9,7 @@ export declare function signAndNotify(channel: Channel, method: string, data: {
 export declare function handleUnexpectedMessage(_channel: Channel, message: ChannelMessage, state: ChannelState): ChannelFsm;
 export declare function awaitingCompletion(channel: Channel, message: ChannelMessage, state: ChannelState, onSuccess?: typeof handleUnexpectedMessage): ChannelFsm;
 export declare function awaitingConnection(channel: Channel, message: ChannelMessage): ChannelFsm | undefined;
+export declare function awaitingReestablish(channel: Channel, message: ChannelMessage, state: ChannelState): Promise<ChannelFsm>;
 export declare function awaitingReconnection(channel: Channel, message: ChannelMessage, state: ChannelState): Promise<ChannelFsm>;
 export declare function awaitingChannelCreateTx(channel: Channel, message: ChannelMessage): Promise<ChannelFsm | undefined>;
 export declare function awaitingOnChainTx(channel: Channel, message: ChannelMessage): ChannelFsm | undefined;