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

package/es/channel/Base.d.ts

@@ -0,0 +1,200 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { w3cwebsocket as W3CWebSocket } from 'websocket';
+import { SignTx, ChannelOptions, ChannelState, ChannelHandler, ChannelAction, ChannelStatus, ChannelFsm } from './internal';
+import { Encoded } from '../utils/encoder';
+type EventCallback = (...args: any[]) => void;
+/**
+ * Channel
+ * @example
+ * ```js
+ * await Channel.initialize({
+ *   url: 'ws://localhost:3001',
+ *   role: 'initiator'
+ *   initiatorId: 'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH',
+ *   responderId: 'ak_V6an1xhec1xVaAhLuak7QoEbi6t7w5hEtYWp9bMKaJ19i6A9E',
+ *   initiatorAmount: 1e18,
+ *   responderAmount: 1e18,
+ *   pushAmount: 0,
+ *   channelReserve: 0,
+ *   ttl: 1000,
+ *   host: 'localhost',
+ *   port: 3002,
+ *   lockPeriod: 10,
+ *   async sign (tag, tx) => await account.signTransaction(tx)
+ * })
+ * ```
+ */
+export default class Channel {
+    _eventEmitter: EventEmitter;
+    _pingTimeoutId: NodeJS.Timeout;
+    _nextRpcMessageId: number;
+    _rpcCallbacks: Map<number, (message: object) => void>;
+    _fsmId?: Encoded.Bytearray;
+    _messageQueue: object[];
+    _isMessageQueueLocked: boolean;
+    _actionQueue: ChannelAction[];
+    _isActionQueueLocked: boolean;
+    _status: ChannelStatus;
+    _fsm: ChannelFsm;
+    _websocket: W3CWebSocket;
+    _state?: Encoded.Transaction;
+    _options: ChannelOptions;
+    _channelId?: Encoded.Channel;
+    /**
+     * @param options - Channel params
+     * @param options.url - Channel url (for example: "ws://localhost:3001")
+     * @param options.role - Participant role ("initiator" or "responder")
+     * @param options.initiatorId - Initiator's public key
+     * @param options.responderId - Responder's public key
+     * @param options.pushAmount - Initial deposit in favour of the responder by the initiator
+     * @param options.initiatorAmount - Amount of coins the initiator has committed to
+     * the channel
+     * @param options.responderAmount - Amount of coins the responder has committed to
+     * the channel
+     * @param options.channelReserve - The minimum amount both peers need to maintain
+     * @param options.ttl - Minimum block height to include the channel_create_tx
+     * @param options.host - Host of the responder's node
+     * @param options.port - The port of the responders node
+     * @param options.lockPeriod - Amount of blocks for disputing a solo close
+     * @param options.minimumDepthStrategy - How to calculate minimum depth (default: txfee)
+     * @param options.minimumDepth - The minimum amount of blocks to be mined
+     * @param options.fee - The fee to be used for the channel open transaction
+     * @param options.gasPrice - Used for the fee computation of the channel open transaction
+     * @param options.existingChannelId - Existing channel id (required if reestablishing a
+     * channel)
+     * @param options.offchainTx - Offchain transaction (required if reestablishing
+     * a channel)
+     * @param options.timeoutIdle - The time waiting for a new event to be initiated
+     * (default: 600000)
+     * @param options.timeoutFundingCreate - The time waiting for the initiator to produce
+     * the create channel transaction after the noise session had been established (default: 120000)
+     * @param options.timeoutFundingSign - The time frame the other client has to sign an
+     * off-chain update after our client had initiated and signed it. This applies only for double
+     * signed on-chain intended updates: channel create transaction, deposit, withdrawal and etc.
+     * (default: 120000)
+     * @param options.timeoutFundingLock - The time frame the other client has to confirm an
+     * on-chain transaction reaching maturity (passing minimum depth) after the local node has
+     * detected this. This applies only for double signed on-chain intended updates: channel create
+     * transaction, deposit, withdrawal and etc. (default: 360000)
+     * @param options.timeoutSign - The time frame the client has to return a signed
+     * off-chain update or to decline it. This applies for all off-chain updates (default: 500000)
+     * @param options.timeoutAccept - The time frame the other client has to react to an
+     * event. This applies for all off-chain updates that are not meant to land on-chain, as well as
+     * some special cases: opening a noise connection, mutual closing acknowledgement and
+     * reestablishing an existing channel (default: 120000)
+     * @param options.timeoutInitialized - the time frame the responder has to accept an
+     * incoming noise session. Applicable only for initiator (default: timeout_accept's value)
+     * @param options.timeoutAwaitingOpen - The time frame the initiator has to start an
+     * outgoing noise session to the responder's node. Applicable only for responder (default:
+     * timeout_idle's value)
+     * @param options.debug=false - Log websocket communication
+     * @param options.sign - Function which verifies and signs transactions
+     */
+    static initialize(options: ChannelOptions): Promise<Channel>;
+    static _initialize<T extends Channel>(channel: T, options: ChannelOptions): Promise<T>;
+    /**
+     * Register event listener function
+     *
+     * Possible events:
+     *
+     *   - "error"
+     *   - "onChainTx"
+     *   - "ownWithdrawLocked"
+     *   - "withdrawLocked"
+     *   - "ownDepositLocked"
+     *   - "depositLocked"
+     *
+     * TODO: the event list looks outdated
+     *
+     * @param eventName - Event name
+     * @param callback - Callback function
+     */
+    on(eventName: string, callback: EventCallback): void;
+    /**
+     * Remove event listener function
+     * @param eventName - Event name
+     * @param callback - Callback function
+     */
+    off(eventName: string, callback: EventCallback): void;
+    /**
+     * Close the connection
+     */
+    disconnect(): void;
+    /**
+     * Get current status
+     */
+    status(): ChannelStatus;
+    /**
+     * Get current state
+     */
+    state(): Promise<{
+        calls: Encoded.CallStateTree;
+        halfSignedTx: Encoded.Transaction | '';
+        signedTx: Encoded.Transaction;
+        trees: Encoded.StateTrees;
+    }>;
+    /**
+     * Get current round
+     *
+     * If round cannot be determined (for example when channel has not been opened)
+     * it will return `null`.
+     */
+    round(): number | null;
+    /**
+     * Get channel id
+     *
+     */
+    id(): Encoded.Channel;
+    /**
+     * Get channel's fsm id
+     *
+     */
+    fsmId(): Encoded.Bytearray;
+    protected enqueueAction(action: () => {
+        handler: ChannelHandler;
+        state?: Partial<ChannelState>;
+    }): Promise<any>;
+    /**
+     * Leave channel
+     *
+     * It is possible to leave a channel and then later reestablish the channel
+     * off-chain state and continue operation. When a leave method is called,
+     * the channel fsm passes it on to the peer fsm, reports the current mutually
+     * signed state and then terminates.
+     *
+     * The channel can be reestablished by instantiating another Channel instance
+     * with two extra params: existingChannelId and offchainTx (returned from leave
+     * method as channelId and signedTx respectively).
+     *
+     * @example
+     * ```js
+     * channel.leave().then(({ channelId, signedTx }) => {
+     *   console.log(channelId)
+     *   console.log(signedTx)
+     * })
+     * ```
+     */
+    leave(): Promise<{
+        channelId: Encoded.Bytearray;
+        signedTx: Encoded.Transaction;
+    }>;
+    /**
+     * Trigger mutual close
+     *
+     * At any moment after the channel is opened, a closing procedure can be triggered.
+     * This can be done by either of the parties. The process is similar to the off-chain updates.
+     *
+     * @param sign - Function which verifies and signs mutual close transaction
+     * @example
+     * ```js
+     * channel.shutdown(
+     *   async (tx) => await account.signTransaction(tx)
+     * ).then(tx => console.log('on_chain_tx', tx))
+     * ```
+     */
+    shutdown(sign: SignTx): Promise<Encoded.Transaction>;
+    static reconnect(options: ChannelOptions, txParams: any): Promise<Channel>;
+}
+export {};

package/es/channel/Base.mjs

@@ -0,0 +1,293 @@
+import _defineProperty from "@babel/runtime-corejs3/helpers/defineProperty";
+/*
+ * 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 _events from 'events';
+const {
+  EventEmitter
+} = _events;
+import { snakeToPascal } from "../utils/string.mjs";
+import { buildTx, unpackTx } from "../tx/builder/index.mjs";
+import { Tag } from "../tx/builder/constants.mjs";
+import * as handlers from "./handlers.mjs";
+import { initialize, enqueueAction, notify, call, disconnect as channelDisconnect } from "./internal.mjs";
+import { ChannelError } from "../utils/errors.mjs";
+function snakeToPascalObjKeys(obj) {
+  return Object.entries(obj).reduce((result, _ref) => {
+    let [key, val] = _ref;
+    return {
+      ...result,
+      [snakeToPascal(key)]: val
+    };
+  }, {});
+}
+/**
+ * Channel
+ * @example
+ * ```js
+ * await Channel.initialize({
+ *   url: 'ws://localhost:3001',
+ *   role: 'initiator'
+ *   initiatorId: 'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH',
+ *   responderId: 'ak_V6an1xhec1xVaAhLuak7QoEbi6t7w5hEtYWp9bMKaJ19i6A9E',
+ *   initiatorAmount: 1e18,
+ *   responderAmount: 1e18,
+ *   pushAmount: 0,
+ *   channelReserve: 0,
+ *   ttl: 1000,
+ *   host: 'localhost',
+ *   port: 3002,
+ *   lockPeriod: 10,
+ *   async sign (tag, tx) => await account.signTransaction(tx)
+ * })
+ * ```
+ */
+export default class Channel {
+  constructor() {
+    _defineProperty(this, "_eventEmitter", new EventEmitter());
+    _defineProperty(this, "_nextRpcMessageId", 0);
+    _defineProperty(this, "_rpcCallbacks", new Map());
+    _defineProperty(this, "_messageQueue", []);
+    _defineProperty(this, "_isMessageQueueLocked", false);
+    _defineProperty(this, "_actionQueue", []);
+    _defineProperty(this, "_isActionQueueLocked", false);
+    _defineProperty(this, "_status", 'disconnected');
+  }
+  /**
+   * @param options - Channel params
+   * @param options.url - Channel url (for example: "ws://localhost:3001")
+   * @param options.role - Participant role ("initiator" or "responder")
+   * @param options.initiatorId - Initiator's public key
+   * @param options.responderId - Responder's public key
+   * @param options.pushAmount - Initial deposit in favour of the responder by the initiator
+   * @param options.initiatorAmount - Amount of coins the initiator has committed to
+   * the channel
+   * @param options.responderAmount - Amount of coins the responder has committed to
+   * the channel
+   * @param options.channelReserve - The minimum amount both peers need to maintain
+   * @param options.ttl - Minimum block height to include the channel_create_tx
+   * @param options.host - Host of the responder's node
+   * @param options.port - The port of the responders node
+   * @param options.lockPeriod - Amount of blocks for disputing a solo close
+   * @param options.minimumDepthStrategy - How to calculate minimum depth (default: txfee)
+   * @param options.minimumDepth - The minimum amount of blocks to be mined
+   * @param options.fee - The fee to be used for the channel open transaction
+   * @param options.gasPrice - Used for the fee computation of the channel open transaction
+   * @param options.existingChannelId - Existing channel id (required if reestablishing a
+   * channel)
+   * @param options.offchainTx - Offchain transaction (required if reestablishing
+   * a channel)
+   * @param options.timeoutIdle - The time waiting for a new event to be initiated
+   * (default: 600000)
+   * @param options.timeoutFundingCreate - The time waiting for the initiator to produce
+   * the create channel transaction after the noise session had been established (default: 120000)
+   * @param options.timeoutFundingSign - The time frame the other client has to sign an
+   * off-chain update after our client had initiated and signed it. This applies only for double
+   * signed on-chain intended updates: channel create transaction, deposit, withdrawal and etc.
+   * (default: 120000)
+   * @param options.timeoutFundingLock - The time frame the other client has to confirm an
+   * on-chain transaction reaching maturity (passing minimum depth) after the local node has
+   * detected this. This applies only for double signed on-chain intended updates: channel create
+   * transaction, deposit, withdrawal and etc. (default: 360000)
+   * @param options.timeoutSign - The time frame the client has to return a signed
+   * off-chain update or to decline it. This applies for all off-chain updates (default: 500000)
+   * @param options.timeoutAccept - The time frame the other client has to react to an
+   * event. This applies for all off-chain updates that are not meant to land on-chain, as well as
+   * some special cases: opening a noise connection, mutual closing acknowledgement and
+   * reestablishing an existing channel (default: 120000)
+   * @param options.timeoutInitialized - the time frame the responder has to accept an
+   * incoming noise session. Applicable only for initiator (default: timeout_accept's value)
+   * @param options.timeoutAwaitingOpen - The time frame the initiator has to start an
+   * outgoing noise session to the responder's node. Applicable only for responder (default:
+   * timeout_idle's value)
+   * @param options.debug=false - Log websocket communication
+   * @param options.sign - Function which verifies and signs transactions
+   */
+  static async initialize(options) {
+    return Channel._initialize(new Channel(), options);
+  }
+  static async _initialize(channel, options) {
+    await initialize(channel, options.existingFsmId != null ? handlers.awaitingReconnection : handlers.awaitingConnection, handlers.channelOpen, options);
+    return channel;
+  }
+
+  /**
+   * Register event listener function
+   *
+   * Possible events:
+   *
+   *   - "error"
+   *   - "onChainTx"
+   *   - "ownWithdrawLocked"
+   *   - "withdrawLocked"
+   *   - "ownDepositLocked"
+   *   - "depositLocked"
+   *
+   * TODO: the event list looks outdated
+   *
+   * @param eventName - Event name
+   * @param callback - Callback function
+   */
+  // TODO define specific callback type depending on the event name
+  on(eventName, callback) {
+    this._eventEmitter.on(eventName, callback);
+  }
+
+  /**
+   * Remove event listener function
+   * @param eventName - Event name
+   * @param callback - Callback function
+   */
+  off(eventName, callback) {
+    this._eventEmitter.removeListener(eventName, callback);
+  }
+
+  /**
+   * Close the connection
+   */
+  disconnect() {
+    return channelDisconnect(this);
+  }
+
+  /**
+   * Get current status
+   */
+  status() {
+    return this._status;
+  }
+
+  /**
+   * Get current state
+   */
+  async state() {
+    return snakeToPascalObjKeys(await call(this, 'channels.get.offchain_state', {}));
+  }
+
+  /**
+   * Get current round
+   *
+   * If round cannot be determined (for example when channel has not been opened)
+   * it will return `null`.
+   */
+  round() {
+    if (this._state == null) {
+      return null;
+    }
+    const {
+      tag,
+      round
+    } = unpackTx(this._state, Tag.SignedTx).encodedTx;
+    switch (tag) {
+      case Tag.ChannelCreateTx:
+        return 1;
+      case Tag.ChannelOffChainTx:
+      case Tag.ChannelWithdrawTx:
+      case Tag.ChannelDepositTx:
+        return round;
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * Get channel id
+   *
+   */
+  id() {
+    if (this._channelId == null) throw new ChannelError('Channel is not initialized');
+    return this._channelId;
+  }
+
+  /**
+   * Get channel's fsm id
+   *
+   */
+  fsmId() {
+    if (this._fsmId == null) throw new ChannelError('Channel is not initialized');
+    return this._fsmId;
+  }
+  async enqueueAction(action) {
+    return enqueueAction(this, (channel, state) => (state === null || state === void 0 ? void 0 : state.handler) === handlers.channelOpen, action);
+  }
+
+  /**
+   * Leave channel
+   *
+   * It is possible to leave a channel and then later reestablish the channel
+   * off-chain state and continue operation. When a leave method is called,
+   * the channel fsm passes it on to the peer fsm, reports the current mutually
+   * signed state and then terminates.
+   *
+   * The channel can be reestablished by instantiating another Channel instance
+   * with two extra params: existingChannelId and offchainTx (returned from leave
+   * method as channelId and signedTx respectively).
+   *
+   * @example
+   * ```js
+   * channel.leave().then(({ channelId, signedTx }) => {
+   *   console.log(channelId)
+   *   console.log(signedTx)
+   * })
+   * ```
+   */
+  async leave() {
+    return this.enqueueAction(() => {
+      notify(this, 'channels.leave');
+      return {
+        handler: handlers.awaitingLeave
+      };
+    });
+  }
+
+  /**
+   * Trigger mutual close
+   *
+   * At any moment after the channel is opened, a closing procedure can be triggered.
+   * This can be done by either of the parties. The process is similar to the off-chain updates.
+   *
+   * @param sign - Function which verifies and signs mutual close transaction
+   * @example
+   * ```js
+   * channel.shutdown(
+   *   async (tx) => await account.signTransaction(tx)
+   * ).then(tx => console.log('on_chain_tx', tx))
+   * ```
+   */
+  async shutdown(sign) {
+    return this.enqueueAction(() => {
+      notify(this, 'channels.shutdown');
+      return {
+        handler: handlers.awaitingShutdownTx,
+        state: {
+          sign
+        }
+      };
+    });
+  }
+  static async reconnect(options, txParams) {
+    const {
+      sign
+    } = options;
+    return Channel.initialize({
+      ...options,
+      reconnectTx: await sign('reconnect', buildTx({
+        ...txParams,
+        tag: Tag.ChannelClientReconnectTx
+      }))
+    });
+  }
+}
+//# sourceMappingURL=Base.mjs.map

package/es/channel/Base.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Base.mjs","names":["snakeToPascal","buildTx","unpackTx","Tag","handlers","initialize","enqueueAction","notify","call","disconnect","channelDisconnect","ChannelError","snakeToPascalObjKeys","obj","Object","entries","reduce","result","key","val","Channel","EventEmitter","Map","options","_initialize","channel","existingFsmId","awaitingReconnection","awaitingConnection","channelOpen","on","eventName","callback","_eventEmitter","off","removeListener","status","_status","state","round","_state","tag","SignedTx","encodedTx","ChannelCreateTx","ChannelOffChainTx","ChannelWithdrawTx","ChannelDepositTx","id","_channelId","fsmId","_fsmId","action","handler","leave","awaitingLeave","shutdown","sign","awaitingShutdownTx","reconnect","txParams","reconnectTx","ChannelClientReconnectTx"],"sources":["../../src/channel/Base.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 { EventEmitter } from 'events';\nimport { w3cwebsocket as W3CWebSocket } from 'websocket';\nimport { snakeToPascal } from '../utils/string';\nimport { buildTx, unpackTx } from '../tx/builder';\nimport { Tag } from '../tx/builder/constants';\nimport * as handlers from './handlers';\nimport {\n  initialize,\n  enqueueAction,\n  notify,\n  call,\n  disconnect as channelDisconnect,\n  SignTx,\n  ChannelOptions,\n  ChannelState,\n  ChannelHandler,\n  ChannelAction,\n  ChannelStatus,\n  ChannelFsm,\n} from './internal';\nimport { ChannelError } from '../utils/errors';\nimport { Encoded } from '../utils/encoder';\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\ntype EventCallback = (...args: any[]) => void;\n\n/**\n * Channel\n * @example\n * ```js\n * await Channel.initialize({\n *   url: 'ws://localhost:3001',\n *   role: 'initiator'\n *   initiatorId: 'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH',\n *   responderId: 'ak_V6an1xhec1xVaAhLuak7QoEbi6t7w5hEtYWp9bMKaJ19i6A9E',\n *   initiatorAmount: 1e18,\n *   responderAmount: 1e18,\n *   pushAmount: 0,\n *   channelReserve: 0,\n *   ttl: 1000,\n *   host: 'localhost',\n *   port: 3002,\n *   lockPeriod: 10,\n *   async sign (tag, tx) => await account.signTransaction(tx)\n * })\n * ```\n */\nexport default class Channel {\n  _eventEmitter = new EventEmitter();\n\n  _pingTimeoutId: NodeJS.Timeout;\n\n  _nextRpcMessageId = 0;\n\n  _rpcCallbacks = new Map<number, (message: object) => void>();\n\n  _fsmId?: Encoded.Bytearray;\n\n  _messageQueue: object[] = [];\n\n  _isMessageQueueLocked = false;\n\n  _actionQueue: ChannelAction[] = [];\n\n  _isActionQueueLocked = false;\n\n  _status: ChannelStatus = 'disconnected';\n\n  _fsm: ChannelFsm;\n\n  _websocket: W3CWebSocket;\n\n  _state?: Encoded.Transaction;\n\n  _options: ChannelOptions;\n\n  _channelId?: Encoded.Channel;\n\n  /**\n   * @param options - Channel params\n   * @param options.url - Channel url (for example: \"ws://localhost:3001\")\n   * @param options.role - Participant role (\"initiator\" or \"responder\")\n   * @param options.initiatorId - Initiator's public key\n   * @param options.responderId - Responder's public key\n   * @param options.pushAmount - Initial deposit in favour of the responder by the initiator\n   * @param options.initiatorAmount - Amount of coins the initiator has committed to\n   * the channel\n   * @param options.responderAmount - Amount of coins the responder has committed to\n   * the channel\n   * @param options.channelReserve - The minimum amount both peers need to maintain\n   * @param options.ttl - Minimum block height to include the channel_create_tx\n   * @param options.host - Host of the responder's node\n   * @param options.port - The port of the responders node\n   * @param options.lockPeriod - Amount of blocks for disputing a solo close\n   * @param options.minimumDepthStrategy - How to calculate minimum depth (default: txfee)\n   * @param options.minimumDepth - The minimum amount of blocks to be mined\n   * @param options.fee - The fee to be used for the channel open transaction\n   * @param options.gasPrice - Used for the fee computation of the channel open transaction\n   * @param options.existingChannelId - Existing channel id (required if reestablishing a\n   * channel)\n   * @param options.offchainTx - Offchain transaction (required if reestablishing\n   * a channel)\n   * @param options.timeoutIdle - The time waiting for a new event to be initiated\n   * (default: 600000)\n   * @param options.timeoutFundingCreate - The time waiting for the initiator to produce\n   * the create channel transaction after the noise session had been established (default: 120000)\n   * @param options.timeoutFundingSign - The time frame the other client has to sign an\n   * off-chain update after our client had initiated and signed it. This applies only for double\n   * signed on-chain intended updates: channel create transaction, deposit, withdrawal and etc.\n   * (default: 120000)\n   * @param options.timeoutFundingLock - The time frame the other client has to confirm an\n   * on-chain transaction reaching maturity (passing minimum depth) after the local node has\n   * detected this. This applies only for double signed on-chain intended updates: channel create\n   * transaction, deposit, withdrawal and etc. (default: 360000)\n   * @param options.timeoutSign - The time frame the client has to return a signed\n   * off-chain update or to decline it. This applies for all off-chain updates (default: 500000)\n   * @param options.timeoutAccept - The time frame the other client has to react to an\n   * event. This applies for all off-chain updates that are not meant to land on-chain, as well as\n   * some special cases: opening a noise connection, mutual closing acknowledgement and\n   * reestablishing an existing channel (default: 120000)\n   * @param options.timeoutInitialized - the time frame the responder has to accept an\n   * incoming noise session. Applicable only for initiator (default: timeout_accept's value)\n   * @param options.timeoutAwaitingOpen - The time frame the initiator has to start an\n   * outgoing noise session to the responder's node. Applicable only for responder (default:\n   * timeout_idle's value)\n   * @param options.debug=false - Log websocket communication\n   * @param options.sign - Function which verifies and signs transactions\n   */\n  static async initialize(options: ChannelOptions): Promise<Channel> {\n    return Channel._initialize(new Channel(), options);\n  }\n\n  static async _initialize<T extends Channel>(channel: T, options: ChannelOptions): Promise<T> {\n    await initialize(\n      channel,\n      options.existingFsmId != null ? handlers.awaitingReconnection : handlers.awaitingConnection,\n      handlers.channelOpen,\n      options,\n    );\n    return channel;\n  }\n\n  /**\n   * Register event listener function\n   *\n   * Possible events:\n   *\n   *   - \"error\"\n   *   - \"onChainTx\"\n   *   - \"ownWithdrawLocked\"\n   *   - \"withdrawLocked\"\n   *   - \"ownDepositLocked\"\n   *   - \"depositLocked\"\n   *\n   * TODO: the event list looks outdated\n   *\n   * @param eventName - Event name\n   * @param callback - Callback function\n   */\n  // TODO define specific callback type depending on the event name\n  on(eventName: string, callback: EventCallback): void {\n    this._eventEmitter.on(eventName, callback);\n  }\n\n  /**\n   * Remove event listener function\n   * @param eventName - Event name\n   * @param callback - Callback function\n   */\n  off(eventName: string, callback: EventCallback): void {\n    this._eventEmitter.removeListener(eventName, callback);\n  }\n\n  /**\n   * Close the connection\n   */\n  disconnect(): void {\n    return channelDisconnect(this);\n  }\n\n  /**\n   * Get current status\n   */\n  status(): ChannelStatus {\n    return this._status;\n  }\n\n  /**\n   * Get current state\n   */\n  async state(): Promise<{\n    calls: Encoded.CallStateTree;\n    halfSignedTx: Encoded.Transaction | '';\n    signedTx: Encoded.Transaction;\n    trees: Encoded.StateTrees;\n  }> {\n    return snakeToPascalObjKeys(await call(this, 'channels.get.offchain_state', {}));\n  }\n\n  /**\n   * Get current round\n   *\n   * If round cannot be determined (for example when channel has not been opened)\n   * it will return `null`.\n   */\n  round(): number | null {\n    if (this._state == null) {\n      return null;\n    }\n    const { tag, round } = unpackTx(this._state, Tag.SignedTx).encodedTx;\n    switch (tag) {\n      case Tag.ChannelCreateTx:\n        return 1;\n      case Tag.ChannelOffChainTx:\n      case Tag.ChannelWithdrawTx:\n      case Tag.ChannelDepositTx:\n        return round;\n      default:\n        return null;\n    }\n  }\n\n  /**\n   * Get channel id\n   *\n   */\n  id(): Encoded.Channel {\n    if (this._channelId == null) throw new ChannelError('Channel is not initialized');\n    return this._channelId;\n  }\n\n  /**\n   * Get channel's fsm id\n   *\n   */\n  fsmId(): Encoded.Bytearray {\n    if (this._fsmId == null) throw new ChannelError('Channel is not initialized');\n    return this._fsmId;\n  }\n\n  protected async enqueueAction(\n    action: () => { handler: ChannelHandler; state?: Partial<ChannelState> },\n  ): Promise<any> {\n    return enqueueAction(\n      this,\n      (channel, state) => state?.handler === handlers.channelOpen,\n      action,\n    );\n  }\n\n  /**\n   * Leave channel\n   *\n   * It is possible to leave a channel and then later reestablish the channel\n   * off-chain state and continue operation. When a leave method is called,\n   * the channel fsm passes it on to the peer fsm, reports the current mutually\n   * signed state and then terminates.\n   *\n   * The channel can be reestablished by instantiating another Channel instance\n   * with two extra params: existingChannelId and offchainTx (returned from leave\n   * method as channelId and signedTx respectively).\n   *\n   * @example\n   * ```js\n   * channel.leave().then(({ channelId, signedTx }) => {\n   *   console.log(channelId)\n   *   console.log(signedTx)\n   * })\n   * ```\n   */\n  async leave(): Promise<{ channelId: Encoded.Bytearray; signedTx: Encoded.Transaction }> {\n    return this.enqueueAction(() => {\n      notify(this, 'channels.leave');\n      return { handler: handlers.awaitingLeave };\n    });\n  }\n\n  /**\n   * Trigger mutual close\n   *\n   * At any moment after the channel is opened, a closing procedure can be triggered.\n   * This can be done by either of the parties. The process is similar to the off-chain updates.\n   *\n   * @param sign - Function which verifies and signs mutual close transaction\n   * @example\n   * ```js\n   * channel.shutdown(\n   *   async (tx) => await account.signTransaction(tx)\n   * ).then(tx => console.log('on_chain_tx', tx))\n   * ```\n   */\n  async shutdown(sign: SignTx): Promise<Encoded.Transaction> {\n    return this.enqueueAction(() => {\n      notify(this, 'channels.shutdown');\n      return {\n        handler: handlers.awaitingShutdownTx,\n        state: { sign },\n      };\n    });\n  }\n\n  static async reconnect(options: ChannelOptions, txParams: any): Promise<Channel> {\n    const { sign } = options;\n\n    return Channel.initialize({\n      ...options,\n      reconnectTx: await sign(\n        'reconnect',\n        buildTx({ ...txParams, tag: Tag.ChannelClientReconnectTx }),\n      ),\n    });\n  }\n}\n"],"mappings":";AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAA6B,QAAQ;AAAC;EAAA;AAAA;AAAA,SAE7BA,aAAa;AAAA,SACbC,OAAO,EAAEC,QAAQ;AAAA,SACjBC,GAAG;AAAA,OACL,KAAKC,QAAQ;AAAA,SAElBC,UAAU,EACVC,aAAa,EACbC,MAAM,EACNC,IAAI,EACJC,UAAU,IAAIC,iBAAiB;AAAA,SASxBC,YAAY;AAGrB,SAASC,oBAAoB,CAAOC,GAAW,EAAQ;EACrD,OAAOC,MAAM,CAACC,OAAO,CAACF,GAAG,CAAC,CAACG,MAAM,CAAC,CAACC,MAAM;IAAA,IAAE,CAACC,GAAG,EAAEC,GAAG,CAAC;IAAA,OAAM;MACzD,GAAGF,MAAM;MACT,CAACjB,aAAa,CAACkB,GAAG,CAAC,GAAGC;IACxB,CAAC;EAAA,CAAC,EAAE,CAAC,CAAC,CAAC;AACT;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,MAAMC,OAAO,CAAC;EAAA;IAAA,uCACX,IAAIC,YAAY,EAAE;IAAA,2CAId,CAAC;IAAA,uCAEL,IAAIC,GAAG,EAAqC;IAAA,uCAIlC,EAAE;IAAA,+CAEJ,KAAK;IAAA,sCAEG,EAAE;IAAA,8CAEX,KAAK;IAAA,iCAEH,cAAc;EAAA;EAYvC;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;AACA;AACA;AACA;AACA;EACE,aAAajB,UAAU,CAACkB,OAAuB,EAAoB;IACjE,OAAOH,OAAO,CAACI,WAAW,CAAC,IAAIJ,OAAO,EAAE,EAAEG,OAAO,CAAC;EACpD;EAEA,aA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"}