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

package/src/chain.ts

@@ -1,19 +1,3 @@
-/*
- * 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 { AE_AMOUNT_FORMATS, formatAmount } from './utils/amount-formatter';
 import verifyTransaction, { ValidatorResult } from './tx/validator';
 import { isAccountNotFoundError, pause } from './utils/other';
@@ -29,8 +13,11 @@ import {
   Account as AccountNode, ByteCode, ContractObject, DryRunResult, DryRunResults,
   Generation, KeyBlock, MicroBlockHeader, NameEntry, SignedTx,
 } from './apis/node';
-import { decode, Encoded, Encoding } from './utils/encoder';
+import {
+  decode, encode, Encoded, Encoding,
+} from './utils/encoder';
 import AccountBase from './account/Base';
+import { buildTxHash } from './tx/builder';
 
 /**
  * @category chain
@@ -89,7 +76,7 @@ export async function getHeight({ onNode }: { onNode: Node }): Promise<number> {
 export async function poll(
   th: Encoded.TxHash,
   {
-    blocks = 10, interval, onNode, ...options
+    blocks = 5, interval, onNode, ...options
   }:
   { blocks?: number; interval?: number; onNode: Node } & Parameters<typeof _getPollInterval>[1],
 ): Promise<TransformNodeType<SignedTx>> {
@@ -154,24 +141,33 @@ export async function waitForTxConfirm(
 }
 
 /**
- * Submit a signed transaction for mining
+ * Signs and submits transaction for mining
  * @category chain
- * @param tx - Transaction to submit
+ * @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 sending
+ * @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(
-  tx: Encoded.Transaction,
+  txUnsigned: Encoded.Transaction,
   {
-    onNode, onAccount, verify = true, waitMined = true, confirm, ...options
+    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) {
@@ -221,12 +217,13 @@ export async function sendTransaction(
 
 type SendTransactionOptionsType = {
   onNode: Node;
-  onAccount?: AccountBase;
+  onAccount: AccountBase;
   verify?: boolean;
   waitMined?: boolean;
   confirm?: boolean | number;
-} & Parameters<typeof poll>[1] & Omit<Parameters<typeof waitForTxConfirm>[1], 'confirm'>;
-interface SendTransactionOptions extends SendTransactionOptionsType {}
+} & 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;
@@ -263,11 +260,15 @@ export async function getAccount(
  * @param options.hash - The block hash on which to obtain the balance for (default: top of chain)
  */
 export async function getBalance(
-  address: Encoded.AccountAddress | Encoded.ContractAddress,
+  address: Encoded.AccountAddress | Encoded.ContractAddress | Encoded.OracleAddress,
   { format = AE_AMOUNT_FORMATS.AETTOS, ...options }:
   { format?: AE_AMOUNT_FORMATS } & Parameters<typeof getAccount>[1],
 ): Promise<string> {
-  const { balance } = await getAccount(address, options).catch((error) => {
+  const addr = address.startsWith('ok_')
+    ? encode(decode(address), Encoding.AccountAddress)
+    : address as Encoded.AccountAddress | Encoded.ContractAddress;
+
+  const { balance } = await getAccount(addr, options).catch((error) => {
     if (!isAccountNotFoundError(error)) throw error;
     return { balance: 0n };
   });

package/src/channel/Base.ts

@@ -1,19 +1,3 @@
-/*
- * 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 { EventEmitter } from 'events';
 import { w3cwebsocket as W3CWebSocket } from 'websocket';
 import { snakeToPascal } from '../utils/string';
@@ -33,9 +17,12 @@ import {
   ChannelAction,
   ChannelStatus,
   ChannelFsm,
+  ChannelMessage,
+  ChannelEvents,
 } from './internal';
 import { ChannelError } from '../utils/errors';
 import { Encoded } from '../utils/encoder';
+import { TxUnpacked } from '../tx/builder/schema.generated';
 
 function snakeToPascalObjKeys<Type>(obj: object): Type {
   return Object.entries(obj).reduce((result, [key, val]) => ({
@@ -44,8 +31,6 @@ function snakeToPascalObjKeys<Type>(obj: object): Type {
   }), {}) as Type;
 }
 
-type EventCallback = (...args: any[]) => void;
-
 /**
  * Channel
  * @example
@@ -78,7 +63,7 @@ export default class Channel {
 
   _fsmId?: Encoded.Bytearray;
 
-  _messageQueue: object[] = [];
+  _messageQueue: ChannelMessage[] = [];
 
   _isMessageQueueLocked = false;
 
@@ -92,7 +77,7 @@ export default class Channel {
 
   _websocket: W3CWebSocket;
 
-  _state?: Encoded.Transaction;
+  _state: Encoded.Transaction | '' = '';
 
   _options: ChannelOptions;
 
@@ -168,19 +153,23 @@ export default class Channel {
    * Possible events:
    *
    *   - "error"
+   *   - "stateChanged"
+   *   - "statusChanged"
+   *   - "message"
+   *   - "peerDisconnected"
    *   - "onChainTx"
    *   - "ownWithdrawLocked"
    *   - "withdrawLocked"
    *   - "ownDepositLocked"
    *   - "depositLocked"
+   *   - "channelReestablished"
+   *   - "newContract"
    *
-   * 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: string, callback: EventCallback): void {
+  on<E extends keyof ChannelEvents>(eventName: E, callback: ChannelEvents[E]): void {
     this._eventEmitter.on(eventName, callback);
   }
 
@@ -189,7 +178,7 @@ export default class Channel {
    * @param eventName - Event name
    * @param callback - Callback function
    */
-  off(eventName: string, callback: EventCallback): void {
+  off<E extends keyof ChannelEvents>(eventName: E, callback: ChannelEvents[E]): void {
     this._eventEmitter.removeListener(eventName, callback);
   }
 
@@ -211,12 +200,23 @@ export default class Channel {
    * Get current state
    */
   async state(): Promise<{
-    calls: Encoded.CallStateTree;
-    halfSignedTx: Encoded.Transaction | '';
-    signedTx: Encoded.Transaction;
-    trees: Encoded.StateTrees;
+    calls: TxUnpacked & { tag: Tag.CallsMtree };
+    halfSignedTx?: TxUnpacked & { tag: Tag.SignedTx };
+    signedTx?: TxUnpacked & { tag: Tag.SignedTx };
+    trees: TxUnpacked & { tag: Tag.StateTrees };
   }> {
-    return snakeToPascalObjKeys(await call(this, 'channels.get.offchain_state', {}));
+    const res = snakeToPascalObjKeys<{
+      calls: Encoded.CallStateTree;
+      halfSignedTx: Encoded.Transaction | '';
+      signedTx: Encoded.Transaction | '';
+      trees: Encoded.StateTrees;
+    }>(await call(this, 'channels.get.offchain_state', {}));
+    return {
+      calls: unpackTx(res.calls, Tag.CallsMtree),
+      ...res.halfSignedTx !== '' && { halfSignedTx: unpackTx(res.halfSignedTx, Tag.SignedTx) },
+      ...res.signedTx !== '' && { signedTx: unpackTx(res.signedTx, Tag.SignedTx) },
+      trees: unpackTx(res.trees, Tag.StateTrees),
+    };
   }
 
   /**
@@ -226,17 +226,17 @@ export default class Channel {
    * it will return `null`.
    */
   round(): number | null {
-    if (this._state == null) {
+    if (this._state === '') {
       return null;
     }
-    const { tag, round } = unpackTx(this._state, Tag.SignedTx).encodedTx;
-    switch (tag) {
+    const params = unpackTx(this._state, Tag.SignedTx).encodedTx;
+    switch (params.tag) {
       case Tag.ChannelCreateTx:
         return 1;
       case Tag.ChannelOffChainTx:
       case Tag.ChannelWithdrawTx:
       case Tag.ChannelDepositTx:
-        return round;
+        return params.round;
       default:
         return null;
     }

package/src/channel/Contract.ts

@@ -1,19 +1,3 @@
-/*
- * 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 BigNumber from 'bignumber.js';
 import { snakeToPascal } from '../utils/string';
 import {
@@ -34,7 +18,7 @@ import { ContractCallReturnType } from '../apis/node';
 import { ContractCallObject } from '../contract/Contract';
 import Channel from './Base';
 import ChannelSpend from './Spend';
-import { UnexpectedChannelMessageError } from '../utils/errors';
+import { ChannelError, UnexpectedChannelMessageError } from '../utils/errors';
 import { unpackTx } from '../tx/builder';
 import { encodeContractAddress } from '../utils/crypto';
 
@@ -152,16 +136,17 @@ export default class ChannelContract extends ChannelSpend {
               state2: ChannelState,
             ): ChannelFsm => (
               awaitingCompletion(this, message2, state2, () => {
-                const { round } = unpackTx(message2.params.data.state, Tag.SignedTx).encodedTx;
+                const params = unpackTx(message2.params.data.state, Tag.SignedTx).encodedTx;
+                if (params.tag !== Tag.ChannelOffChainTx) {
+                  throw new ChannelError(`Tag should be ${Tag[Tag.ChannelOffChainTx]}, got ${Tag[params.tag]} instead`);
+                }
                 const addressKey = this._options.role === 'initiator'
                   ? 'initiatorId' : 'responderId';
                 const owner = this._options[addressKey];
                 changeState(this, message2.params.data.state);
-                state2.resolve({
-                  accepted: true,
-                  address: encodeContractAddress(owner, round),
-                  signedTx: message2.params.data.state,
-                });
+                const address = encodeContractAddress(owner, params.round);
+                emit(this, 'newContract', address);
+                state2.resolve({ accepted: true, address, signedTx: message2.params.data.state });
                 return { handler: channelOpen };
               })
             ),

package/src/channel/Spend.ts

@@ -1,19 +1,3 @@
-/*
- * 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 BigNumber from 'bignumber.js';
 import {
   notify, call, SignTx, ChannelState, ChannelMessage, ChannelFsm, changeState,
@@ -27,6 +11,7 @@ import {
 } from './handlers';
 import { unpackTx } from '../tx/builder';
 import { Tag } from '../tx/builder/constants';
+import { TxUnpacked } from '../tx/builder/schema.generated';
 
 export default class ChannelSpend extends Channel {
   /**
@@ -135,7 +120,7 @@ export default class ChannelSpend extends Channel {
       accounts: Encoded.AccountAddress[];
       contracts?: Encoded.ContractAddress[];
     },
-  ): Promise<ReturnType<typeof unpackTx<Tag.TreesPoi>>> {
+  ): Promise<TxUnpacked & { tag: Tag.TreesPoi }> {
     return unpackTx(
       (await call(this, 'channels.get.poi', { accounts, contracts })).poi,
       Tag.TreesPoi,

package/src/channel/handlers.ts

@@ -1,19 +1,3 @@
-/*
- * ISC License (ISC)
- * Copyright (c) 2018 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.
- */
 /* eslint-disable consistent-return */
 /* eslint-disable default-case */
 /* eslint-disable @typescript-eslint/no-use-before-define */
@@ -28,6 +12,7 @@ import {
   ChannelFsm,
   SignTx,
   ChannelStatus,
+  ChannelEvents,
 } from './internal';
 import { unpackTx, buildTx } from '../tx/builder';
 import { decode, Encoded } from '../utils/encoder';
@@ -40,6 +25,7 @@ import {
 } from '../utils/errors';
 import type Channel from './Base';
 import { Tag } from '../tx/builder/constants';
+import { snakeToPascal } from '../utils/string';
 
 export async function appendSignature(
   tx: Encoded.Transaction,
@@ -165,7 +151,8 @@ export async function awaitingReconnection(
   if (message.method === 'channels.info') {
     if (message.params.data.event === 'fsm_up') {
       channel._fsmId = message.params.data.fsm_id;
-      changeState(channel, (await channel.state()).signedTx);
+      const { signedTx } = await channel.state();
+      changeState(channel, signedTx == null ? '' : buildTx(signedTx));
       return { handler: channelOpen };
     }
   }
@@ -270,7 +257,7 @@ export async function channelOpen(
           //
           //       We should enter intermediate state where offchain transactions
           //       are blocked until channel is reestablished.
-          emit(channel, message.params.data.event);
+          emit(channel, snakeToPascal(message.params.data.event) as keyof ChannelEvents);
           return { handler: channelOpen };
         case 'fsm_up':
           channel._fsmId = message.params.data.fsm_id;

package/src/channel/internal.ts

@@ -1,20 +1,3 @@
-/*
- * ISC License (ISC)
- * Copyright (c) 2018 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 { w3cwebsocket as W3CWebSocket } from 'websocket';
 import BigNumber from 'bignumber.js';
 import type Channel from './Base';
@@ -30,6 +13,23 @@ import {
   ChannelIncomingMessageError,
   ChannelError,
 } from '../utils/errors';
+import { encodeContractAddress } from '../utils/crypto';
+import { buildTx } from '../tx/builder';
+
+export interface ChannelEvents {
+  statusChanged: (status: ChannelStatus) => void;
+  stateChanged: (tx: Encoded.Transaction | '') => void;
+  depositLocked: () => void;
+  ownDepositLocked: () => void;
+  withdrawLocked: () => void;
+  ownWithdrawLocked: () => void;
+  peerDisconnected: () => void;
+  channelReestablished: () => void;
+  error: (error: Error) => void;
+  onChainTx: (tx: Encoded.Transaction, details: { info: string; type: string }) => void;
+  message: (message: string | Object) => void;
+  newContract: (contractAddress: Encoded.ContractAddress) => void;
+}
 
 export interface ChannelAction {
   guard: (channel: Channel, state?: ChannelFsm) => boolean;
@@ -139,7 +139,10 @@ const PING_TIMEOUT_MS = 10000;
 // Close connection if pong message is not received within 15 seconds
 const PONG_TIMEOUT_MS = 15000;
 
-export function emit(channel: Channel, ...args: any[]): void {
+export function emit<E extends keyof ChannelEvents>(
+  channel: Channel,
+  ...args: [E, ...Parameters<ChannelEvents[E]>]
+): void {
   const [eventName, ...rest] = args;
   channel._eventEmitter.emit(eventName, ...rest);
 }
@@ -166,7 +169,7 @@ export function changeStatus(channel: Channel, newStatus: ChannelStatus): void {
   emit(channel, 'statusChanged', newStatus);
 }
 
-export function changeState(channel: Channel, newState: Encoded.Transaction): void {
+export function changeState(channel: Channel, newState: Encoded.Transaction | ''): void {
   channel._state = newState;
   emit(channel, 'stateChanged', newState);
 }
@@ -211,9 +214,21 @@ export async function enqueueAction(
   return promise;
 }
 
-async function handleMessage(channel: Channel, message: object): Promise<void> {
+async function handleMessage(channel: Channel, message: ChannelMessage): Promise<void> {
   const { handler, state: st } = channel._fsm;
-  enterState(channel, await Promise.resolve(handler(channel, message, st)));
+  const nextState = await Promise.resolve(handler(channel, message, st));
+  enterState(channel, nextState);
+  // TODO: emit message and handler name (?) to move this code to Contract constructor
+  if (
+    message?.params?.data?.updates?.[0]?.op === 'OffChainNewContract'
+    // if name is channelOpen, the contract was created by other participant
+    && nextState?.handler.name === 'channelOpen'
+  ) {
+    const round = channel.round();
+    if (round == null) throw new UnexpectedTsError('Round is null');
+    const owner = message?.params?.data?.updates?.[0]?.owner;
+    emit(channel, 'newContract', encodeContractAddress(owner, round + 1));
+  }
 }
 
 async function dequeueMessage(channel: Channel): Promise<void> {
@@ -318,7 +333,10 @@ export async function initialize(
         if (channelOptions.reconnectTx != null) {
           enterState(channel, { handler: openHandler });
           const { signedTx } = await channel.state();
-          changeState(channel, signedTx);
+          if (signedTx == null) {
+            throw new ChannelError('`signedTx` missed in state while reconnection');
+          }
+          changeState(channel, buildTx(signedTx));
         }
         ping(channel);
       },