@aeternity/aepp-sdk 13.2.2 → 13.3.1

package/src/chain.ts

@@ -1,11 +1,10 @@
 import { AE_AMOUNT_FORMATS, formatAmount } from './utils/amount-formatter';
-import verifyTransaction, { ValidatorResult } from './tx/validator';
-import { ensureError, isAccountNotFoundError, pause } from './utils/other';
+import { isAccountNotFoundError, pause } from './utils/other';
+import { unwrapProxy } from './utils/wrap-proxy';
 import { isNameValid, produceNameId } from './tx/builder/helpers';
-import { DRY_RUN_ACCOUNT } from './tx/builder/schema';
-import { AensName } from './tx/builder/constants';
+import { AensName, DRY_RUN_ACCOUNT } from './tx/builder/constants';
 import {
-  AensPointerContextError, DryRunError, InvalidAensNameError, TransactionError,
+  AensPointerContextError, DryRunError, InvalidAensNameError,
   TxTimedOutError, TxNotInChainError, InternalError,
 } from './utils/errors';
 import Node, { TransformNodeType } from './Node';
@@ -16,60 +15,62 @@ import {
 import {
   decode, encode, Encoded, Encoding,
 } from './utils/encoder';
-import AccountBase from './account/Base';
-import { buildTxHash } from './tx/builder';
 
 /**
  * @category chain
+ * @param type - Type
+ * @param options - Options
  */
 export function _getPollInterval(
   type: 'block' | 'microblock', // TODO: rename to 'key-block' | 'micro-block'
-  { _expectedMineRate = 180000, _microBlockCycle = 3000, _maxPollInterval = 5000 }:
-  { _expectedMineRate?: number; _microBlockCycle?: number; _maxPollInterval?: number },
+  { _expectedMineRate = 180000, _microBlockCycle = 3000 }:
+  { _expectedMineRate?: number; _microBlockCycle?: number },
 ): number {
   const base = {
     block: _expectedMineRate,
     microblock: _microBlockCycle,
   }[type];
-  return Math.min(base / 3, _maxPollInterval);
+  return Math.floor(base / 3);
 }
 
-/**
- * @category exception
- */
-export class InvalidTxError extends TransactionError {
-  validation: ValidatorResult[];
-
-  transaction: Encoded.Transaction;
-
-  constructor(
-    message: string,
-    validation: ValidatorResult[],
-    transaction: Encoded.Transaction,
-  ) {
-    super(message);
-    this.name = 'InvalidTxError';
-    this.validation = validation;
-    this.transaction = transaction;
-  }
-}
+const heightCache: WeakMap<Node, { time: number; height: number }> = new WeakMap();
 
 /**
  * Obtain current height of the chain
  * @category chain
+ * @param options - Options
+ * @param options.cached - Get height from the cache. The lag behind the actual height shouldn't
+ * be more than 1 block. Use if needed to reduce requests count, and approximate value can be used.
+ * For example, for timeout check in transaction status polling.
  * @returns Current chain height
  */
-export async function getHeight({ onNode }: { onNode: Node }): Promise<number> {
-  return (await onNode.getCurrentKeyBlockHeight()).height;
+export async function getHeight(
+  { cached = false, ...options }: {
+    onNode: Node;
+    cached?: boolean;
+  } & Parameters<typeof _getPollInterval>[1],
+): Promise<number> {
+  const onNode = unwrapProxy(options.onNode);
+  if (cached) {
+    const cache = heightCache.get(onNode);
+    if (cache != null && cache.time > Date.now() - _getPollInterval('block', options)) {
+      return cache.height;
+    }
+  }
+  const { height } = await onNode.getCurrentKeyBlockHeight();
+  heightCache.set(onNode, { height, time: Date.now() });
+  return height;
 }
 
 /**
- * Wait for a transaction to be mined
+ * Return transaction details if it is mined, fail otherwise.
+ * If the transaction has ttl specified then would wait till it leaves the mempool.
+ * Otherwise would fail if a specified amount of blocks were mined.
  * @category chain
  * @param th - The hash of transaction to poll
  * @param options - Options
  * @param options.interval - Interval (in ms) at which to poll the chain
- * @param options.blocks - Number of blocks mined after which to fail
+ * @param options.blocks - Number of blocks mined after which to fail if transaction ttl is not set
  * @param options.onNode - Node to use
  * @returns The transaction as it was mined
  */
@@ -81,12 +82,16 @@ export async function poll(
   { blocks?: number; interval?: number; onNode: Node } & Parameters<typeof _getPollInterval>[1],
 ): Promise<TransformNodeType<SignedTx>> {
   interval ??= _getPollInterval('microblock', options);
-  const max = await getHeight({ onNode }) + blocks;
+  let max;
   do {
     const tx = await onNode.getTransactionByHash(th);
     if (tx.blockHeight !== -1) return tx;
+    if (max == null) {
+      max = tx.tx.ttl !== 0 ? -1
+        : await getHeight({ ...options, onNode, cached: true }) + blocks;
+    }
     await pause(interval);
-  } while (await getHeight({ onNode }) < max);
+  } while (max === -1 ? true : await getHeight({ ...options, onNode, cached: true }) < max);
   throw new TxTimedOutError(blocks, th);
 }
 
@@ -104,11 +109,11 @@ export async function awaitHeight(
   { interval, onNode, ...options }:
   { interval?: number; onNode: Node } & Parameters<typeof _getPollInterval>[1],
 ): Promise<number> {
-  interval ??= _getPollInterval('block', options);
+  interval ??= Math.min(_getPollInterval('block', options), 5000);
   let currentHeight;
   do {
     if (currentHeight != null) await pause(interval);
-    currentHeight = (await onNode.getCurrentKeyBlockHeight()).height;
+    currentHeight = await getHeight({ onNode });
   } while (currentHeight < height);
   return currentHeight;
 }
@@ -140,97 +145,6 @@ export async function waitForTxConfirm(
   }
 }
 
-/**
- * Signs and submits transaction for mining
- * @category chain
- * @param txUnsigned - Transaction to sign and submit
- * @param options - Options
- * @param options.onNode - Node to use
- * @param options.onAccount - Account to use
- * @param options.verify - Verify transaction before broadcast, throw error if not
- * @param options.waitMined - Ensure that transaction get into block
- * @param options.confirm - Number of micro blocks that should be mined after tx get included
- * @returns Transaction details
- */
-export async function sendTransaction(
-  txUnsigned: Encoded.Transaction,
-  {
-    onNode, onAccount, verify = true, waitMined = true, confirm, innerTx, ...options
-  }:
-  SendTransactionOptions,
-): Promise<SendTransactionReturnType> {
-  const tx = await onAccount.signTransaction(txUnsigned, {
-    ...options,
-    onNode,
-    innerTx,
-    networkId: await onNode.getNetworkId(),
-  });
-
-  if (innerTx === true) return { hash: buildTxHash(tx), rawTx: tx };
-
-  if (verify) {
-    const validation = await verifyTransaction(tx, onNode);
-    if (validation.length > 0) {
-      const message = `Transaction verification errors: ${
-        validation.map((v: { message: string }) => v.message).join(', ')}`;
-      throw new InvalidTxError(message, validation, tx);
-    }
-  }
-
-  try {
-    let __queue;
-    try {
-      __queue = onAccount != null ? `tx-${onAccount.address}` : null;
-    } catch (error) {
-      __queue = null;
-    }
-    const { txHash } = await onNode.postTransaction(
-      { tx },
-      __queue != null ? { requestOptions: { customHeaders: { __queue } } } : {},
-    );
-
-    if (waitMined) {
-      const pollResult = await poll(txHash, { onNode, ...options });
-      const txData = {
-        ...pollResult,
-        hash: pollResult.hash as Encoded.TxHash,
-        rawTx: tx,
-      };
-      // wait for transaction confirmation
-      if (confirm != null && +confirm > 0) {
-        const c = typeof confirm === 'boolean' ? undefined : confirm;
-        return {
-          ...txData,
-          confirmationHeight: await waitForTxConfirm(txHash, { onNode, confirm: c, ...options }),
-        };
-      }
-      return txData;
-    }
-    return { hash: txHash, rawTx: tx };
-  } catch (error) {
-    ensureError(error);
-    throw Object.assign(error, {
-      rawTx: tx,
-      verifyTx: async () => verifyTransaction(tx, onNode),
-    });
-  }
-}
-
-type SendTransactionOptionsType = {
-  onNode: Node;
-  onAccount: AccountBase;
-  verify?: boolean;
-  waitMined?: boolean;
-  confirm?: boolean | number;
-} & Parameters<typeof poll>[1] & Omit<Parameters<typeof waitForTxConfirm>[1], 'confirm'>
-& Parameters<AccountBase['signTransaction']>[1];
-export interface SendTransactionOptions extends SendTransactionOptionsType {}
-interface SendTransactionReturnType extends Partial<TransformNodeType<SignedTx>> {
-  hash: Encoded.TxHash;
-  rawTx: Encoded.Transaction;
-  confirmationHeight?: number;
-}
-
 /**
  * Get account by account public key
  * @category chain

package/src/channel/Base.ts

@@ -31,6 +31,8 @@ function snakeToPascalObjKeys<Type>(obj: object): Type {
   }), {}) as Type;
 }
 
+let channelCounter = 0;
+
 /**
  * Channel
  * @example
@@ -81,57 +83,22 @@ export default class Channel {
 
   _options!: ChannelOptions;
 
+  readonly #debugId: number;
+
   _channelId?: Encoded.Channel;
 
+  protected constructor() {
+    channelCounter += 1;
+    this.#debugId = channelCounter;
+  }
+
+  _debug(...args: any[]): void {
+    if (this._options.debug !== true) return;
+    console.debug(`Channel #${this.#debugId}`, ...args);
+  }
+
   /**
    * @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: ChannelOptions): Promise<Channel> {
     return Channel._initialize(new Channel(), options);

package/src/channel/Contract.ts

@@ -30,10 +30,25 @@ function snakeToPascalObjKeys<Type>(obj: object): Type {
 }
 
 interface CallContractOptions {
+  /**
+   * Amount the caller of the contract commits to it
+   */
   amount?: number | BigNumber;
+  /**
+   * ABI encoded compiled AEVM call data for the code
+   */
   callData?: Encoded.ContractBytearray;
+  /**
+   * Version of the ABI
+   */
   abiVersion?: AbiVersion;
+  /**
+   * Address of the contract to call
+   */
   contract?: Encoded.ContractAddress;
+}
+
+interface CallContractResult extends CallContractOptions {
   returnValue?: any;
   gasUsed?: number | BigNumber;
   gasPrice?: number | BigNumber;
@@ -175,10 +190,6 @@ export default class ChannelContract extends ChannelSpend {
    * if a call with a similar computation amount is to be forced on-chain.
    *
    * @param options - Options
-   * @param options.amount - Amount the caller of the contract commits to it
-   * @param options.callData - ABI encoded compiled AEVM call data for the code
-   * @param options.contract - Address of the contract to call
-   * @param options.abiVersion - Version of the ABI
    * @param sign - Function which verifies and signs contract call transaction
    * @example
    * ```js
@@ -248,12 +259,6 @@ export default class ChannelContract extends ChannelSpend {
    * Trigger a force progress contract call
    * This call is going on-chain
    * @param options - Options
-   * @param options.amount - Amount the caller of the contract commits to it
-   * @param options.callData - ABI encoded compiled AEVM call data for the code
-   * @param options.contract - Address of the contract to call
-   * @param options.abiVersion - Version of the ABI
-   * @param options.gasPrice=1000000000]
-   * @param options.gasLimit=1000000]
    * @param sign - Function which verifies and signs contract force progress transaction
    * @param callbacks - Callbacks
    * @example
@@ -276,11 +281,7 @@ export default class ChannelContract extends ChannelSpend {
   async forceProgress(
     {
       amount, callData, contract, abiVersion, gasLimit = 1000000, gasPrice = MIN_GAS_PRICE,
-    }: {
-      amount: number;
-      callData: Encoded.ContractBytearray;
-      contract: Encoded.ContractAddress;
-      abiVersion: AbiVersion;
+    }: CallContractOptions & {
       gasLimit?: number;
       gasPrice?: number;
     },
@@ -352,10 +353,6 @@ export default class ChannelContract extends ChannelSpend {
    * top of the blockchain as seen by the node.
    *
    * @param options - Options
-   * @param options.amount - Amount the caller of the contract commits to it
-   * @param options.callData - ABI encoded compiled AEVM call data for the code
-   * @param options.contract - Address of the contract to call
-   * @param options.abiVersion - Version of the ABI
    * @example
    * ```js
    * channel.callContractStatic({
@@ -372,13 +369,8 @@ export default class ChannelContract extends ChannelSpend {
   async callContractStatic(
     {
       amount, callData, contract, abiVersion,
-    }: {
-      amount: number;
-      callData: Encoded.ContractBytearray;
-      contract: Encoded.ContractAddress;
-      abiVersion: AbiVersion;
-    },
-  ): Promise<CallContractOptions> {
+    }: CallContractOptions,
+  ): Promise<CallContractResult> {
     return snakeToPascalObjKeys(await call(this, 'channels.dry_run.call_contract', {
       amount,
       call_data: callData,

package/src/channel/Spend.ts

@@ -230,10 +230,6 @@ export default class ChannelSpend extends Channel {
    * @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(
@@ -305,10 +301,6 @@ export default class ChannelSpend extends Channel {
    * @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(

package/src/channel/internal.ts

@@ -1,4 +1,4 @@
-import { w3cwebsocket as W3CWebSocket } from 'websocket';
+import { w3cwebsocket as W3CWebSocket, ICloseEvent } from 'websocket';
 import BigNumber from 'bignumber.js';
 import type Channel from './Base';
 import JsonBig from '../utils/json-big';
@@ -49,43 +49,139 @@ export type SignTx = (tx: Encoded.Transaction, options?: SignOptions) => (
   Promise<Encoded.Transaction | number | null>
 );
 
+/**
+ * @see {@link https://github.com/aeternity/protocol/blob/6734de2e4c7cce7e5e626caa8305fb535785131d/node/api/channels_api_usage.md#channel-establishing-parameters}
+ */
 export interface ChannelOptions {
   existingFsmId?: Encoded.Bytearray;
+  /**
+   * Channel url (for example: "ws://localhost:3001")
+   */
   url: string;
 
   /**
-   * @see {@link https://github.com/aeternity/protocol/blob/6734de2e4c7cce7e5e626caa8305fb535785131d/node/api/channels_api_usage.md#channel-establishing-parameters}
+   * Initiator's public key
    */
   initiatorId: Encoded.AccountAddress;
+  /**
+   * Responder's public key
+   */
   responderId: Encoded.AccountAddress;
+  /**
+   * Amount of blocks for disputing a solo close
+   */
   lockPeriod: number;
+  /**
+   * Initial deposit in favour of the responder by the initiator
+   */
   pushAmount: number;
-  initiatorAmount: BigNumber;
-  responderAmount: BigNumber;
+  /**
+   * Amount of coins the initiator has committed to the channel
+   */
+  initiatorAmount: BigNumber | number;
+  /**
+   * Amount of coins the responder has committed to the channel
+   */
+  responderAmount: BigNumber | number;
+  /**
+   * The minimum amount both peers need to maintain
+   */
   channelReserve?: BigNumber | number;
+  /**
+   * Minimum block height to include the channel_create_tx
+   */
   ttl?: number;
+  /**
+   * Host of the responder's node
+   */
   host: string;
+  /**
+   * The port of the responders node
+   */
   port: number;
+  /**
+   * Participant role
+   */
   role: 'initiator' | 'responder';
+  /**
+   * How to calculate minimum depth (default: txfee)
+   */
   minimumDepthStrategy?: 'txfee' | 'plain';
+  /**
+   * The minimum amount of blocks to be mined
+   */
   minimumDepth?: number;
+  /**
+   * The fee to be used for the channel open transaction
+   */
   fee?: BigNumber | number;
+  /**
+   * Used for the fee computation of the channel open transaction
+   */
   gasPrice?: BigNumber | number;
 
   signedTx?: string;
+  /**
+   * Existing channel id (required if reestablishing a channel)
+   */
   existingChannelId?: string;
+  /**
+   * Offchain transaction (required if reestablishing a channel)
+   */
   offChainTx?: string;
   reconnectTx?: string;
+  /**
+   * The time waiting for a new event to be initiated (default: 600000)
+   */
   timeoutIdle?: number;
+  /**
+   * The time waiting for the initiator to produce the create channel transaction after the noise
+   * session had been established (default: 120000)
+   */
   timeoutFundingCreate?: number;
+  /**
+   * 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)
+   */
   timeoutFundingSign?: number;
+  /**
+   * 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)
+   */
   timeoutFundingLock?: number;
+  /**
+   * 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)
+   */
   timeoutSign?: number;
+  /**
+   * 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)
+   */
   timeoutAccept?: number;
+  /**
+   * the time frame the responder has to accept an incoming noise session.
+   * Applicable only for initiator (default: timeout_accept's value)
+   */
   timeoutInitialized?: number;
+  /**
+   * 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)
+   */
   timeoutAwaitingOpen?: number;
   statePassword?: string;
-  debug: boolean;
+  /**
+   * Log websocket communication and state changes
+   */
+  debug?: boolean;
+  /**
+   * Function which verifies and signs transactions
+   */
   sign: SignTxWithTag;
   offchainTx?: string;
 }
@@ -100,6 +196,9 @@ export interface ChannelState {
   reject: (e: BaseError) => void;
   sign: SignTx;
   handler?: ChannelHandler;
+  /**
+   * Called when transaction has been posted on chain
+   */
   onOnChainTx?: (tx: Encoded.Transaction) => void;
   onOwnWithdrawLocked?: () => void;
   onWithdrawLocked?: () => void;
@@ -152,6 +251,7 @@ function enterState(channel: Channel, nextState: ChannelFsm): void {
   if (nextState == null) {
     throw new UnknownChannelStateError();
   }
+  channel._debug('enter state', nextState.handler.name);
   channel._fsm = nextState;
   if (nextState?.handler?.enter != null) {
     nextState.handler.enter(channel);
@@ -164,7 +264,8 @@ function enterState(channel: Channel, nextState: ChannelFsm): void {
 export type ChannelStatus = 'connecting' | 'connected' | 'accepted' | 'halfSigned' | 'signed'
 | 'open' | 'closing' | 'closed' | 'died' | 'disconnected';
 
-export function changeStatus(channel: Channel, newStatus: ChannelStatus): void {
+export function changeStatus(channel: Channel, newStatus: ChannelStatus, debug?: unknown): void {
+  channel._debug(newStatus, `(prev. ${channel._status})`, debug ?? '');
   if (newStatus === channel._status) return;
   channel._status = newStatus;
   emit(channel, 'statusChanged', newStatus);
@@ -176,7 +277,7 @@ export function changeState(channel: Channel, newState: Encoded.Transaction | ''
 }
 
 function send(channel: Channel, message: ChannelMessage): void {
-  if (channel._options.debug) console.log('Send message: ', message);
+  channel._debug('send message', message.method, message.params);
   channel._websocket.send(JsonBig.stringify({ jsonrpc: '2.0', ...message }));
 }
 
@@ -266,7 +367,7 @@ function ping(channel: Channel): void {
 
 function onMessage(channel: Channel, data: string): void {
   const message = JsonBig.parse(data);
-  if (channel._options.debug) console.log('Receive message: ', message);
+  channel._debug('received message', message.method, message.params);
   if (message.id != null) {
     const callback = channel._rpcCallbacks.get(message.id);
     if (callback == null) {
@@ -317,7 +418,6 @@ export async function initialize(
   { url, ...channelOptions }: ChannelOptions,
 ): Promise<void> {
   channel._options = { url, ...channelOptions };
-  channel._fsm = { handler: connectionHandler };
 
   const wsUrl = new URL(url);
   Object.entries(channelOptions)
@@ -329,9 +429,9 @@ export async function initialize(
   await new Promise<void>((resolve, reject) => {
     Object.assign(channel._websocket, {
       onerror: reject,
-      onopen: async () => {
+      onopen: async (event: Event) => {
         resolve();
-        changeStatus(channel, 'connected');
+        changeStatus(channel, 'connected', event);
         if (channelOptions.reconnectTx != null) {
           enterState(channel, { handler: openHandler });
           const { signedTx } = await channel.state();
@@ -339,11 +439,13 @@ export async function initialize(
             throw new ChannelError('`signedTx` missed in state while reconnection');
           }
           changeState(channel, buildTx(signedTx));
+        } else {
+          enterState(channel, { handler: connectionHandler });
         }
         ping(channel);
       },
-      onclose: () => {
-        changeStatus(channel, 'disconnected');
+      onclose: (event: ICloseEvent) => {
+        changeStatus(channel, 'disconnected', event);
         clearTimeout(channel._pingTimeoutId);
       },
       onmessage: ({ data }: { data: string }) => onMessage(channel, data),