@aeternity/aepp-sdk 13.3.3 → 14.1.0

package/types-legacy/ts4.2/channel/Base.d.ts

@@ -1,168 +0,0 @@
-/// <reference types="node" />
-import EventEmitter from 'events';
-import { w3cwebsocket as W3CWebSocket } from 'websocket';
-import { Tag } from '../tx/builder/constants';
-import { SignTx, ChannelOptions, ChannelState, ChannelHandler, ChannelAction, ChannelStatus, ChannelFsm, ChannelMessage, ChannelEvents } from './internal';
-import { Encoded } from '../utils/encoder';
-import { TxUnpacked } from '../tx/builder/schema.generated';
-/**
- * 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 {
-    #private;
-    _eventEmitter: EventEmitter;
-    _pingTimeoutId: NodeJS.Timeout;
-    _nextRpcMessageId: number;
-    _rpcCallbacks: Map<number, (message: object) => void>;
-    _fsmId?: Encoded.Bytearray;
-    _messageQueue: ChannelMessage[];
-    _isMessageQueueLocked: boolean;
-    _actionQueue: ChannelAction[];
-    _isActionQueueLocked: boolean;
-    _status: ChannelStatus;
-    _fsm: ChannelFsm;
-    _websocket: W3CWebSocket;
-    _state: Encoded.Transaction | '';
-    _options: ChannelOptions;
-    _channelId?: Encoded.Channel;
-    protected constructor();
-    _debug(...args: any[]): void;
-    /**
-     * @param options - Channel params
-     */
-    static initialize(options: ChannelOptions): Promise<Channel>;
-    static _initialize<T extends Channel>(channel: T, options: ChannelOptions): Promise<T>;
-    /**
-     * Register event listener function
-     *
-     * Possible events:
-     *
-     *   - "error"
-     *   - "stateChanged"
-     *   - "statusChanged"
-     *   - "message"
-     *   - "peerDisconnected"
-     *   - "onChainTx"
-     *   - "ownWithdrawLocked"
-     *   - "withdrawLocked"
-     *   - "ownDepositLocked"
-     *   - "depositLocked"
-     *   - "channelReestablished"
-     *   - "newContract"
-     *
-     *
-     * @param eventName - Event name
-     * @param callback - Callback function
-     */
-    on<E extends keyof ChannelEvents>(eventName: E, callback: ChannelEvents[E]): void;
-    /**
-     * Remove event listener function
-     * @param eventName - Event name
-     * @param callback - Callback function
-     */
-    off<E extends keyof ChannelEvents>(eventName: E, callback: ChannelEvents[E]): void;
-    /**
-     * Close the connection
-     */
-    disconnect(): void;
-    /**
-     * Get current status
-     */
-    status(): ChannelStatus;
-    /**
-     * Get current state
-     */
-    state(): Promise<{
-        calls: TxUnpacked & {
-            tag: Tag.CallsMtree;
-        };
-        halfSignedTx?: TxUnpacked & {
-            tag: Tag.SignedTx;
-        };
-        signedTx?: TxUnpacked & {
-            tag: Tag.SignedTx;
-        };
-        trees: TxUnpacked & {
-            tag: Tag.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.Channel;
-        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>;
-}

package/types-legacy/ts4.2/channel/Contract.d.ts

@@ -1,239 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { AbiVersion, VmVersion } from '../tx/builder/constants';
-import { SignTx, ChannelState, ChannelOptions } from './internal';
-import { Encoded } from '../utils/encoder';
-import { ContractCallReturnType } from '../apis/node';
-import { ContractCallObject } from '../contract/Contract';
-import ChannelSpend from './Spend';
-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;
-    height?: number;
-    callerNonce?: number;
-    log?: any;
-    returnType?: ContractCallReturnType;
-}
-interface Contract {
-    abiVersion: AbiVersion;
-    active: boolean;
-    deposit: number | BigNumber;
-    id: string;
-    ownerId: string;
-    referrerIds: string[];
-    vmVersion: VmVersion;
-}
-export default class ChannelContract extends ChannelSpend {
-    static initialize(options: ChannelOptions): Promise<ChannelContract>;
-    /**
-     * Trigger create contract update
-     *
-     * The create contract update is creating a contract inside the channel's internal state tree.
-     * The update is a change to be applied on top of the latest state.
-     *
-     * That would create a contract with the poster being the owner of it. Poster commits initially
-     * a deposit amount of coins to the new contract.
-     *
-     * @param options - Options
-     * @param options.code - Api encoded compiled AEVM byte code
-     * @param options.callData - Api encoded compiled AEVM call data for the code
-     * @param options.deposit - Initial amount the owner of the contract commits to it
-     * @param options.vmVersion - Version of the Virtual Machine
-     * @param options.abiVersion - Version of the Application Binary Interface
-     * @param sign - Function which verifies and signs create contract transaction
-     * @example
-     * ```js
-     * channel.createContract({
-     *   code: 'cb_HKtpipK4aCgYb17wZ...',
-     *   callData: 'cb_1111111111111111...',
-     *   deposit: 10,
-     *   vmVersion: 3,
-     *   abiVersion: 1
-     * }).then(({ accepted, signedTx, address }) => {
-     *   if (accepted) {
-     *     console.log('New contract has been created')
-     *     console.log('Contract address:', address)
-     *   } else {
-     *     console.log('New contract has been rejected')
-     *   }
-     * })
-     * ```
-     */
-    createContract({ code, callData, deposit, vmVersion, abiVersion, }: {
-        code: Encoded.ContractBytearray;
-        callData: Encoded.ContractBytearray;
-        deposit: number | BigNumber;
-        vmVersion: VmVersion;
-        abiVersion: AbiVersion;
-    }, sign: SignTx): Promise<{
-        accepted: boolean;
-        signedTx: Encoded.Transaction;
-        address: Encoded.ContractAddress;
-    }>;
-    /**
-     * Trigger call a contract update
-     *
-     * The call contract update is calling a preexisting contract inside the channel's
-     * internal state tree. The update is a change to be applied on top of the latest state.
-     *
-     * That would call a contract with the poster being the caller of it. Poster commits
-     * an amount of coins to the contract.
-     *
-     * The call would also create a call object inside the channel state tree. It contains
-     * the result of the contract call.
-     *
-     * It is worth mentioning that the gas is not consumed, because this is an off-chain
-     * contract call. It would be consumed if it were an on-chain one. This could happen
-     * if a call with a similar computation amount is to be forced on-chain.
-     *
-     * @param options - Options
-     * @param sign - Function which verifies and signs contract call transaction
-     * @example
-     * ```js
-     * channel.callContract({
-     *   contract: 'ct_9sRA9AVE4BYTAkh5RNfJYmwQe1NZ4MErasQLXZkFWG43TPBqa',
-     *   callData: 'cb_1111111111111111...',
-     *   amount: 0,
-     *   abiVersion: 1
-     * }).then(({ accepted, signedTx }) => {
-     *   if (accepted) {
-     *     console.log('Contract called succesfully')
-     *   } else {
-     *     console.log('Contract call has been rejected')
-     *   }
-     * })
-     * ```
-     */
-    callContract({ amount, callData, contract, abiVersion, }: CallContractOptions, sign: SignTx): Promise<{
-        accepted: boolean;
-        signedTx: Encoded.Transaction;
-    }>;
-    /**
-     * Trigger a force progress contract call
-     * This call is going on-chain
-     * @param options - Options
-     * @param sign - Function which verifies and signs contract force progress transaction
-     * @param callbacks - Callbacks
-     * @example
-     * ```js
-     * channel.forceProgress({
-     *   contract: 'ct_9sRA9AVE4BYTAkh5RNfJYmwQe1NZ4MErasQLXZkFWG43TPBqa',
-     *   callData: 'cb_1111111111111111...',
-     *   amount: 0,
-     *   abiVersion: 1,
-     *   gasPrice: 1000005554
-     * }).then(({ accepted, signedTx }) => {
-     *   if (accepted) {
-     *     console.log('Contract force progress call successful')
-     *   } else {
-     *     console.log('Contract force progress call has been rejected')
-     *   }
-     * })
-     * ```
-     */
-    forceProgress({ amount, callData, contract, abiVersion, gasLimit, gasPrice, }: CallContractOptions & {
-        gasLimit?: number;
-        gasPrice?: number;
-    }, sign: SignTx, { onOnChainTx }?: Pick<ChannelState, 'onOnChainTx'>): Promise<{
-        accepted: boolean;
-        signedTx: Encoded.Transaction;
-        tx: Encoded.Transaction | Uint8Array;
-    }>;
-    /**
-     * Call contract using dry-run
-     *
-     * In order to get the result of a potential contract call, one might need to
-     * dry-run a contract call. It takes the exact same arguments as a call would
-     * and returns the call object.
-     *
-     * The call is executed in the channel's state, but it does not impact the state
-     * whatsoever. It uses as an environment the latest channel's state and the current
-     * top of the blockchain as seen by the node.
-     *
-     * @param options - Options
-     * @example
-     * ```js
-     * channel.callContractStatic({
-     *   contract: 'ct_9sRA9AVE4BYTAkh5RNfJYmwQe1NZ4MErasQLXZkFWG43TPBqa',
-     *   callData: 'cb_1111111111111111...',
-     *   amount: 0,
-     *   abiVersion: 1
-     * }).then(({ returnValue, gasUsed }) => {
-     *   console.log('Returned value:', returnValue)
-     *   console.log('Gas used:', gasUsed)
-     * })
-     * ```
-     */
-    callContractStatic({ amount, callData, contract, abiVersion, }: CallContractOptions): Promise<CallContractResult>;
-    /**
-     * Get contract call result
-     *
-     * The combination of a caller, contract and a round of execution determines the
-     * contract call. Providing an incorrect set of those results in an error response.
-     *
-     * @param options - Options
-     * @param options.caller - Address of contract caller
-     * @param options.contract - Address of the contract
-     * @param options.round - Round when contract was called
-     * @example
-     * ```js
-     * channel.getContractCall({
-     *   caller: 'ak_Y1NRjHuoc3CGMYMvCmdHSBpJsMDR6Ra2t5zjhRcbtMeXXLpLH',
-     *   contract: 'ct_9sRA9AVE4BYTAkh5RNfJYmwQe1NZ4MErasQLXZkFWG43TPBqa',
-     *   round: 3
-     * }).then(({ returnType, returnValue }) => {
-     *   if (returnType === 'ok') console.log(returnValue)
-     * })
-     * ```
-     */
-    getContractCall({ caller, contract, round }: {
-        caller: Encoded.AccountAddress;
-        contract: Encoded.ContractAddress;
-        round: number;
-    }): Promise<ContractCallObject>;
-    /**
-     * Get the latest contract state
-     *
-     * @param contract - Address of the contract
-     * @example
-     * ```js
-     * channel.getContractState(
-     *   'ct_9sRA9AVE4BYTAkh5RNfJYmwQe1NZ4MErasQLXZkFWG43TPBqa'
-     * ).then(({ contract }) => {
-     *   console.log('deposit:', contract.deposit)
-     * })
-     * ```
-     */
-    getContractState(contract: Encoded.ContractAddress): Promise<{
-        contract: Contract;
-        contractState: object;
-    }>;
-    /**
-     * Clean up all locally stored contract calls
-     *
-     * Contract calls are kept locally in order for the participant to be able to look them up.
-     * They consume memory and in order for the participant to free it - one can prune all messages.
-     * This cleans up all locally stored contract calls and those will no longer be available for
-     * fetching and inspection.
-     */
-    cleanContractCalls(): Promise<void>;
-}
-export {};

package/types-legacy/ts4.2/channel/Spend.d.ts

@@ -1,213 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { SignTx, ChannelState } from './internal';
-import { Encoded } from '../utils/encoder';
-import Channel from './Base';
-import { Tag } from '../tx/builder/constants';
-import { TxUnpacked } from '../tx/builder/schema.generated';
-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<TxUnpacked & {
-        tag: 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: string]: 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
-     * @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
-     * @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/types-legacy/ts4.2/channel/handlers.d.ts

@@ -1,21 +0,0 @@
-import { ChannelState, ChannelMessage, ChannelFsm, SignTx } from './internal';
-import { Encoded } from '../utils/encoder';
-import type Channel from './Base';
-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;
-    signed_tx?: Encoded.Transaction;
-}, signFn: SignTx): Promise<boolean>;
-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 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;
-export declare function channelOpen(channel: Channel, message: ChannelMessage, state: ChannelState): Promise<ChannelFsm | undefined>;
-export declare namespace channelOpen {
-    var enter: (channel: Channel) => void;
-}
-export declare function awaitingShutdownTx(channel: Channel, message: ChannelMessage, state: ChannelState): Promise<ChannelFsm>;
-export declare function awaitingLeave(channel: Channel, message: ChannelMessage, state: ChannelState): ChannelFsm;
-export declare function channelClosed(_channel: Channel, message: ChannelMessage, state: ChannelState): ChannelFsm;