@aeternity/aepp-sdk 13.0.0-alpha.0 → 13.0.0-beta.0

package/src/tx/builder/field-types/map.ts

@@ -0,0 +1,45 @@
+import { Tag } from '../constants';
+import {
+  encode, Encoding, Encoded, decode,
+} from '../../../utils/encoder';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
+
+export default function genMapField<E extends Encoding, T extends Tag>(encoding: E, tag: T): {
+  serialize: (
+    // TODO: replace with `TxParams & { tag: T }`,
+    //  but fix TS2502 value is referenced directly or indirectly in its own type annotation
+    value: Record<Encoded.Generic<E>, any>, options: { buildTx: typeof buildTxType }
+  ) => Buffer;
+  deserialize: (
+    value: Buffer, options: { unpackTx: typeof unpackTxType },
+    // TODO: replace with `TxUnpacked & { tag: T }`,
+    //  TS2577 Return type annotation circularly references itself
+  ) => Record<Encoded.Generic<E>, any>;
+  recursiveType: true;
+} {
+  return {
+    serialize(object, { buildTx }) {
+      return decode(buildTx({
+        tag: Tag.Mtree,
+        values: Object.entries(object).map(([key, value]) => ({
+          tag: Tag.MtreeValue,
+          key: decode(key as Encoded.Generic<E>),
+          value: decode(buildTx({ ...value as any, tag })),
+        })),
+      }));
+    },
+
+    deserialize(buffer, { unpackTx }) {
+      const { values } = unpackTx(encode(buffer, Encoding.Transaction), Tag.Mtree);
+      return Object.fromEntries(values
+        // TODO: remove after resolving https://github.com/aeternity/aeternity/issues/4066
+        .filter(({ key }) => encoding !== Encoding.ContractAddress || key.length === 32)
+        .map(({ key, value }) => [
+          encode(key, encoding),
+          unpackTx(encode(value, Encoding.Transaction), tag),
+        ])) as Record<Encoded.Generic<E>, any>;
+    },
+
+    recursiveType: true,
+  };
+}

package/src/tx/builder/field-types/mptree.ts

@@ -0,0 +1,243 @@
+import { encode as rlpEncode, Input } from 'rlp';
+import { Tag } from '../constants';
+import { hash } from '../../../utils/crypto';
+import {
+  MerkleTreeHashMismatchError,
+  MissingNodeInTreeError,
+  UnknownPathNibbleError,
+  UnexpectedTsError,
+  UnknownNodeLengthError,
+  InternalError,
+} from '../../../utils/errors';
+import {
+  decode, encode, Encoded, Encoding,
+} from '../../../utils/encoder';
+import type { unpackTx } from '..';
+import type { TxUnpacked } from '../schema.generated';
+
+enum NodeType {
+  Branch,
+  Extension,
+  Leaf,
+}
+
+type MPTreeBinary = [Buffer, Array<[Buffer, Buffer[]]>];
+
+class MPTree<E extends Encoding, T extends Tag> {
+  readonly #rootHash: string;
+
+  #isComplete = true;
+
+  get isComplete(): boolean {
+    return this.#isComplete;
+  }
+
+  readonly #nodes: { [key: string]: Buffer[] };
+
+  readonly #encoding: E;
+
+  readonly #tag: T;
+
+  readonly #unpackTx: typeof unpackTx;
+
+  static #nodeHash(node: Input): string {
+    return Buffer.from(hash(rlpEncode(node))).toString('hex');
+  }
+
+  /**
+   * Deserialize Merkle Patricia Tree
+   * @param binary - Binary
+   * @param tag - Tag to use to decode value
+   * @param unpTx - Implementation of unpackTx use to decode values
+   * @returns Merkle Patricia Tree
+   */
+  constructor(binary: MPTreeBinary, encoding: E, tag: T, unpTx: typeof unpackTx) {
+    this.#encoding = encoding;
+    this.#tag = tag;
+    this.#unpackTx = unpTx;
+    this.#rootHash = binary[0].toString('hex');
+    this.#nodes = Object.fromEntries(
+      binary[1].map((node) => [node[0].toString('hex'), node[1]]),
+    );
+
+    if (this.#nodes[this.#rootHash] == null) {
+      if (Object.keys(this.#nodes).length !== 0) {
+        throw new MissingNodeInTreeError('Can\'t find a node by root hash');
+      }
+      this.#isComplete = false;
+      return;
+    }
+    Object.entries(this.#nodes).forEach(([key, node]) => {
+      if (MPTree.#nodeHash(node) !== key) throw new MerkleTreeHashMismatchError();
+      const { type } = MPTree.#parseNode(node);
+      switch (type) {
+        case NodeType.Branch:
+          node
+            .slice(0, 16)
+            .filter((n) => n.length)
+            .forEach((n) => {
+              // TODO: enable after resolving https://github.com/aeternity/aeternity/issues/4066
+              // if (n.length !== 32) {
+              //   throw new ArgumentError('MPTree branch item length', 32, n.length);
+              // }
+              if (this.#nodes[n.toString('hex')] == null) this.#isComplete = false;
+            });
+          break;
+        case NodeType.Extension:
+          if (this.#nodes[node[1].toString('hex')] == null) {
+            throw new MissingNodeInTreeError('Can\'t find a node by hash in extension node');
+          }
+          break;
+        case NodeType.Leaf:
+          break;
+        default:
+          throw new InternalError(`Unknown MPTree node type: ${type}`);
+      }
+    });
+  }
+
+  isEqual(tree: MPTree<E, T>): boolean {
+    return this.#rootHash === tree.#rootHash;
+  }
+
+  static #parseNode(node: Buffer[]): { type: NodeType; value?: Buffer; path?: string } {
+    switch (node.length) {
+      case 17:
+        return {
+          type: NodeType.Branch,
+          ...node[16].length !== 0 && { value: node[16] },
+        };
+      case 2: {
+        const nibble = node[0][0] >> 4; // eslint-disable-line no-bitwise
+        if (nibble > 3) throw new UnknownPathNibbleError(nibble);
+        const type = nibble <= 1 ? NodeType.Extension : NodeType.Leaf;
+        const slice = [0, 2].includes(nibble) ? 2 : 1;
+        return {
+          type,
+          ...type === NodeType.Leaf && { value: node[1] },
+          path: node[0].toString('hex').slice(slice),
+        };
+      }
+      default:
+        throw new UnknownNodeLengthError(node.length);
+    }
+  }
+
+  /**
+   * Serialize Merkle Patricia Tree
+   * @returns Binary
+   */
+  serialize(): MPTreeBinary {
+    return [
+      Buffer.from(this.#rootHash, 'hex'),
+      Object.entries(this.#nodes).map(([mptHash, value]) => ([
+        Buffer.from(mptHash, 'hex'),
+        value,
+      ])),
+    ];
+  }
+
+  /**
+   * Retrieve value from Merkle Patricia Tree
+   * @param _key - The key of the element to retrieve
+   * @returns Value associated to the specified key
+   */
+  #getRaw(_key: string): Buffer | undefined {
+    let searchFrom = this.#rootHash;
+    let key = _key;
+    while (true) { // eslint-disable-line no-constant-condition
+      const node = this.#nodes[searchFrom];
+      if (node == null) {
+        if (!this.isComplete) return undefined;
+        throw new InternalError('Can\'t find node in complete tree');
+      }
+      const { type, value, path } = MPTree.#parseNode(node);
+      switch (type) {
+        case NodeType.Branch:
+          if (key.length === 0) return value;
+          searchFrom = node[+`0x${key[0]}`].toString('hex');
+          key = key.substring(1);
+          break;
+        case NodeType.Extension:
+          if (key.substring(0, path?.length) !== path) return undefined;
+          searchFrom = node[1].toString('hex');
+          key = key.substring(path.length);
+          break;
+        case NodeType.Leaf:
+          if (path !== key) return undefined;
+          return value;
+        default:
+          throw new InternalError(`Unknown MPTree node type: ${type}`);
+      }
+    }
+  }
+
+  /**
+   * Retrieve value from Merkle Patricia Tree
+   * @param key - The key of the element to retrieve
+   * @returns Value associated to the specified key
+   */
+  get(key: Encoded.Generic<E>): TxUnpacked & { tag: T } | undefined {
+    const d = this.#getRaw(decode(key).toString('hex'));
+    if (d == null) return d;
+    return this.#unpackTx(encode(d, Encoding.Transaction), this.#tag);
+  }
+
+  #entriesRaw(): Array<[string, Buffer]> {
+    const entries: Array<[string, Buffer]> = [];
+    const rec = (searchFrom: string, key: string): void => {
+      const node = this.#nodes[searchFrom];
+      if (node == null) {
+        if (!this.isComplete) return;
+        throw new InternalError('Can\'t find node in complete tree');
+      }
+      const { type, value, path } = MPTree.#parseNode(node);
+      switch (type) {
+        case NodeType.Branch:
+          node
+            .slice(0, 16)
+            .map((t, idx): [typeof t, number] => [t, idx])
+            .filter(([t]) => t.length)
+            .forEach(([t, idx]) => rec(t.toString('hex'), key + idx.toString(16)));
+          if (value != null) entries.push([key, value]);
+          break;
+        case NodeType.Extension:
+          rec(node[1].toString('hex'), key + path);
+          break;
+        case NodeType.Leaf:
+          if (value == null) throw new UnexpectedTsError();
+          entries.push([key + path, value]);
+          break;
+        default:
+          throw new InternalError(`Unknown MPTree node type: ${type}`);
+      }
+    };
+    rec(this.#rootHash, '');
+    return entries;
+  }
+
+  toObject(): Record<Encoded.Generic<E>, TxUnpacked & { tag: T }> {
+    return Object.fromEntries(this.#entriesRaw()
+      // TODO: remove after resolving https://github.com/aeternity/aeternity/issues/4066
+      .filter(([k]) => this.#encoding !== Encoding.ContractAddress || k.length !== 66)
+      .map(([k, v]) => [
+        encode(Buffer.from(k, 'hex'), this.#encoding),
+        this.#unpackTx(encode(v, Encoding.Transaction), this.#tag),
+      ])) as Record<Encoded.Generic<E>, TxUnpacked & { tag: T }>;
+  }
+}
+
+export default function genMPTreeField<E extends Encoding, T extends Tag>(encoding: E, tag: T): {
+  serialize: (value: MPTree<E, T>) => MPTreeBinary;
+  deserialize: (value: MPTreeBinary, o: { unpackTx: typeof unpackTx }) => MPTree<E, T>;
+} {
+  return {
+    serialize(value) {
+      return value.serialize();
+    },
+
+    deserialize(value, { unpackTx }) {
+      return new MPTree(value, encoding, tag, unpackTx);
+    },
+  };
+}

package/src/tx/builder/field-types/name-fee.ts

@@ -1,9 +1,8 @@
 import BigNumber from 'bignumber.js';
 import { getMinimumNameFee } from '../helpers';
 import { InsufficientNameFeeError } from '../../../utils/errors';
-import { Int } from './u-int';
 import coinAmount from './coin-amount';
-import { AensName } from '../constants';
+import { AensName, Int } from '../constants';
 
 export default {
   ...coinAmount,
@@ -26,7 +25,8 @@ export default {
   serialize(
     value: Int | undefined,
     txFields: { name: AensName } & Parameters<typeof coinAmount['serialize']>[1],
+    parameters: Parameters<typeof coinAmount['serialize']>[2],
   ): Buffer {
-    return coinAmount.serialize.call(this, value, txFields);
+    return coinAmount.serialize.call(this, value, txFields, parameters);
   },
 };

package/src/tx/builder/field-types/name-id.ts

@@ -3,7 +3,7 @@ import { produceNameId, isNameValid } from '../helpers';
 import address from './address';
 import { Encoded, Encoding } from '../../../utils/encoder';
 
-const addressName = address<Encoding.Name>();
+const addressName = address(Encoding.Name);
 
 export default {
   ...addressName,

package/src/tx/builder/field-types/nonce.ts

@@ -0,0 +1,40 @@
+import { isAccountNotFoundError } from '../../../utils/other';
+import shortUInt from './short-u-int';
+import Node from '../../../Node';
+import { ArgumentError } from '../../../utils/errors';
+import { NextNonceStrategy } from '../../../apis/node';
+
+export default function genNonceField<SenderKey extends string>(senderKey: SenderKey): {
+  serialize: (value: number) => Buffer;
+  // TODO: (value: number) => Promise<number> | (value: undefined, ...) => Promise<number>
+  prepare: (
+    value: number | undefined,
+    params: {},
+    // TODO: replace `string` with AddressEncodings
+    options: { [key in SenderKey]: string } & { strategy?: NextNonceStrategy; onNode?: Node },
+  ) => Promise<number>;
+  deserialize: (value: Buffer) => number;
+  senderKey: string;
+} {
+  return {
+    ...shortUInt,
+
+    async prepare(value, params, options) {
+      if (value != null) return value;
+      const { onNode, strategy } = options;
+      const senderId = options[senderKey];
+      const requirement = 'provided (or provide `nonce` instead)';
+      if (onNode == null) throw new ArgumentError('onNode', requirement, onNode);
+      if (senderId == null) throw new ArgumentError('senderId', requirement, senderId);
+      return (
+        await onNode.getAccountNextNonce(senderId.replace(/^ok_/, 'ak_'), { strategy })
+          .catch((error) => {
+            if (!isAccountNotFoundError(error)) throw error;
+            return { nextNonce: 1 };
+          })
+      ).nextNonce;
+    },
+
+    senderKey,
+  };
+}

package/src/tx/builder/field-types/pointers.ts

@@ -2,9 +2,9 @@ import { NamePointer as NamePointerString } from '../../../apis/node';
 import { toBytes } from '../../../utils/bytes';
 import { Encoded } from '../../../utils/encoder';
 import { IllegalArgumentError } from '../../../utils/errors';
-import address, { AddressEncodings } from './address';
+import address, { AddressEncodings, idTagToEncoding } from './address';
 
-const addressAny = address<AddressEncodings>();
+const addressAny = address(...idTagToEncoding);
 
 // TODO: remove after fixing node types
 type NamePointer = NamePointerString & {

package/src/tx/builder/field-types/raw.ts

@@ -0,0 +1,9 @@
+export default {
+  serialize(buffer: Uint8Array): Buffer {
+    return Buffer.from(buffer);
+  },
+
+  deserialize(buffer: Buffer): Buffer {
+    return buffer;
+  },
+};

package/src/tx/builder/field-types/short-u-int-const.ts

@@ -0,0 +1,30 @@
+import { ArgumentError } from '../../../utils/errors';
+import shortUInt from './short-u-int';
+
+export default function genShortUIntConstField<
+  Value extends number, Optional extends boolean = false,
+>(constValue: Value, optional?: Optional): {
+  serialize: Optional extends true ? (value?: Value) => Buffer : (value: Value) => Buffer;
+  deserialize: (value: Buffer) => Value;
+  constValue: Value;
+  constValueOptional: boolean;
+} {
+  return {
+    serialize(value?: Value) {
+      if ((optional !== true || value != null) && value !== constValue) {
+        throw new ArgumentError('ShortUIntConst', constValue, value);
+      }
+      return shortUInt.serialize(constValue);
+    },
+
+    deserialize(buf) {
+      const value = shortUInt.deserialize(buf);
+      if (value !== constValue) throw new ArgumentError('ShortUIntConst', constValue, value);
+      return constValue;
+    },
+
+    constValue,
+
+    constValueOptional: optional === true,
+  };
+}

package/src/tx/builder/field-types/string.ts

@@ -0,0 +1,11 @@
+import { toBytes } from '../../../utils/bytes';
+
+export default {
+  serialize(string: string): Buffer {
+    return toBytes(string);
+  },
+
+  deserialize(buffer: Buffer): string {
+    return buffer.toString();
+  },
+};

package/src/tx/builder/field-types/ttl.ts

@@ -0,0 +1,24 @@
+import shortUInt from './short-u-int';
+import Node from '../../../Node';
+import { ArgumentError } from '../../../utils/errors';
+
+export default {
+  ...shortUInt,
+
+  serialize(value: number | undefined): Buffer {
+    return shortUInt.serialize(value ?? 0);
+  },
+
+  async prepare(
+    value: number | undefined,
+    params: {},
+    // TODO: { absoluteTtl: true } | { absoluteTtl: false, onNode: Node }
+    { onNode, absoluteTtl }: { onNode?: Node; absoluteTtl?: boolean },
+  ) {
+    if (absoluteTtl !== true && value !== 0 && value != null) {
+      if (onNode == null) throw new ArgumentError('onNode', 'provided', onNode);
+      value += (await onNode.getCurrentKeyBlock()).height;
+    }
+    return value;
+  },
+};

package/src/tx/builder/field-types/u-int.ts

@@ -1,10 +1,8 @@
-import BigNumber from 'bignumber.js';
 import { readInt } from '../helpers';
+import { Int } from '../constants';
 import { ArgumentError } from '../../../utils/errors';
 import { toBytes } from '../../../utils/bytes';
 
-export type Int = number | string | BigNumber;
-
 export default {
   serialize(value: Int): Buffer {
     if (value < 0) throw new ArgumentError('value', 'greater or equal to 0', value);

package/src/tx/builder/field-types/wrapped.ts

@@ -0,0 +1,32 @@
+import { Tag } from '../constants';
+import { encode, Encoding, decode } from '../../../utils/encoder';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
+
+type TagWrapping = Tag.AccountsMtree | Tag.CallsMtree | Tag.ChannelsMtree | Tag.ContractsMtree
+| Tag.NameserviceMtree | Tag.OraclesMtree;
+
+export default function genWrappedField<T extends TagWrapping>(tag: T): {
+  serialize: (
+    // TODO: replace with `(TxParams & { tag: T })['payload']`,
+    //  but fix TS2502 value is referenced directly or indirectly in its own type annotation
+    value: any, options: { buildTx: typeof buildTxType }
+  ) => Buffer;
+  deserialize: (
+    value: Buffer, options: { unpackTx: typeof unpackTxType },
+    // TODO: replace with `(TxUnpacked & { tag: T })['payload']`,
+    //  TS2577 Return type annotation circularly references itself
+  ) => any;
+  recursiveType: true;
+} {
+  return {
+    serialize(payload, { buildTx }) {
+      return decode(buildTx({ tag, payload }));
+    },
+
+    deserialize(buffer, { unpackTx }) {
+      return unpackTx<TagWrapping>(encode(buffer, Encoding.Transaction), tag).payload;
+    },
+
+    recursiveType: true,
+  };
+}