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

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

@@ -1,45 +1,84 @@
-import _field from './field';
-import _uInt from './u-int';
-import _shortUInt from './short-u-int';
+import _abiVersion from './abi-version';
+import _address from './address';
+import _array from './array';
+import _boolean from './boolean';
 import _coinAmount from './coin-amount';
-
+import _ctVersion from './ct-version';
 import _deposit from './deposit';
+import _encoded from './encoded';
+import _entry from './entry';
+import _enumeration from './enumeration';
 import _fee from './fee';
+import _field from './field';
 import _gasLimit from './gas-limit';
 import _gasPrice from './gas-price';
+import _mptree from './mptree';
 import _name from './name';
 import _nameFee from './name-fee';
 import _nameId from './name-id';
+import _pointers from './pointers';
+import _raw from './raw';
+import _shortUInt from './short-u-int';
+import _shortUIntConst from './short-u-int-const';
+import _string from './string';
+import _uInt from './u-int';
 
 // TODO: remove after fixing https://github.com/Gerrit0/typedoc-plugin-missing-exports/issues/15
-const field = _field;
-const uInt = _uInt;
-const shortUInt = _shortUInt;
+const abiVersion = _abiVersion;
+const address = _address;
+const array = _array;
+const boolean = _boolean;
 const coinAmount = _coinAmount;
-
+const ctVersion = _ctVersion;
 const deposit = _deposit;
+const encoded = _encoded;
+const entry = _entry;
+const enumeration = _enumeration;
 const fee = _fee;
+const field = _field;
 const gasLimit = _gasLimit;
 const gasPrice = _gasPrice;
+const mptree = _mptree;
 const name = _name;
 const nameFee = _nameFee;
 const nameId = _nameId;
+const pointers = _pointers;
+const raw = _raw;
+const shortUInt = _shortUInt;
+const shortUIntConst = _shortUIntConst;
+const string = _string;
+const uInt = _uInt;
 
-export type Field = typeof field | typeof uInt | typeof shortUInt | typeof coinAmount
-  | typeof deposit | typeof fee | typeof gasLimit | typeof gasPrice | typeof name | typeof nameFee
-  | typeof nameId;
+export type BinaryData = Buffer | Buffer[] | Buffer[][]
+| Array<[Buffer, Array<[Buffer, Buffer[]]>]>;
+export interface Field {
+  serialize: (value: any, options: any) => BinaryData;
+  deserialize: (value: BinaryData, options: any) => any;
+}
 
 export {
-  field,
-  uInt,
-  shortUInt,
+  abiVersion,
+  address,
+  array,
+  boolean,
   coinAmount,
-
+  ctVersion,
   deposit,
+  encoded,
+  entry,
+  enumeration,
   fee,
+  field,
   gasLimit,
   gasPrice,
+  mptree,
   name,
   nameFee,
   nameId,
+  pointers,
+  raw,
+  shortUInt,
+  shortUIntConst,
+  string,
+  uInt,
 };

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

@@ -0,0 +1,242 @@
+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 '..';
+
+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>): ReturnType<typeof unpackTx<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.Any, ReturnType<typeof unpackTx<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),
+      ]));
+  }
+}
+
+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,
@@ -27,6 +26,6 @@ export default {
     value: Int | undefined,
     txFields: { name: AensName } & Parameters<typeof coinAmount['serialize']>[1],
   ): Buffer {
-    return coinAmount.serializeOptional.call(this, value, txFields);
+    return coinAmount.serialize.call(this, value, txFields);
   },
 };

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

@@ -1,20 +1,17 @@
 import { AensName } from '../constants';
 import { produceNameId, isNameValid } from '../helpers';
-import { writeId, readId } from '../address';
-import { Encoded } from '../../../utils/encoder';
+import address from './address';
+import { Encoded, Encoding } from '../../../utils/encoder';
+
+const addressName = address(Encoding.Name);
 
 export default {
+  ...addressName,
+
   /**
    * @param value - AENS name ID
    */
   serialize(value: AensName | Encoded.Name): Buffer {
-    return writeId(isNameValid(value) ? produceNameId(value) : value);
-  },
-
-  /**
-   * @param value - AENS name ID Buffer
-   */
-  deserialize(value: Buffer): Encoded.Name {
-    return readId(value) as Encoded.Name;
+    return addressName.serialize(isNameValid(value) ? produceNameId(value) : value);
   },
 };

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

@@ -0,0 +1,41 @@
+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, idTagToEncoding } from './address';
+
+const addressAny = address(...idTagToEncoding);
+
+// TODO: remove after fixing node types
+type NamePointer = NamePointerString & {
+  id: Encoded.Generic<AddressEncodings>;
+};
+
+export default {
+  /**
+   * Helper function to build pointers for name update TX
+   * @param pointers - Array of pointers
+   * `([ { key: 'account_pubkey', id: 'ak_32klj5j23k23j5423l434l2j3423'} ])`
+   * @returns Serialized pointers array
+   */
+  serialize(pointers: NamePointer[]): Buffer[][] {
+    if (pointers.length > 32) {
+      throw new IllegalArgumentError(`Expected 32 pointers or less, got ${pointers.length} instead`);
+    }
+
+    return pointers.map(
+      (pointer) => [toBytes(pointer.key), addressAny.serialize(pointer.id)],
+    );
+  },
+
+  /**
+   * Helper function to read pointers from name update TX
+   * @param pointers - Array of pointers
+   * @returns Deserialize pointer array
+   */
+  deserialize(pointers: Array<[key: Buffer, id: Buffer]>): NamePointer[] {
+    return pointers.map(
+      ([key, id]) => ({ key: key.toString(), id: addressAny.deserialize(id) }),
+    );
+  },
+};

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,20 @@
+import { ArgumentError } from '../../../utils/errors';
+import shortUInt from './short-u-int';
+
+export default function genShortUIntConstField<Value extends number>(value: Value): {
+  serialize: (value?: Value) => Buffer;
+  deserialize: (value: Buffer) => Value;
+} {
+  return {
+    serialize(val) {
+      if (val != null && val !== value) throw new ArgumentError('ShortUIntConst', value, val);
+      return shortUInt.serialize(value);
+    },
+
+    deserialize(buf) {
+      const val = shortUInt.deserialize(buf);
+      if (val !== value) throw new ArgumentError('ShortUIntConst', value, val);
+      return value;
+    },
+  };
+}

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/u-int.ts

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

package/src/tx/builder/helpers.ts

@@ -14,8 +14,6 @@ import {
 } from './constants';
 import { ceil } from '../../utils/bignumber';
 import { ArgumentError, IllegalBidFeeError } from '../../utils/errors';
-import { NamePointer } from '../../apis/node';
-import { readId, writeId } from './address';
 
 /**
  * JavaScript-based Transaction builder helper function's
@@ -61,16 +59,6 @@ export function oracleQueryId(
   return encode(b2bHash, Encoding.OracleQueryId);
 }
 
-/**
- * Format the salt into a 64-byte hex string
- * @category transaction builder
- * @param salt - Random number
- * @returns Zero-padded hex string of salt
- */
-export function formatSalt(salt: number): Buffer {
-  return Buffer.from(salt.toString(16).padStart(64, '0'), 'hex');
-}
-
 /**
  * Encode an AENS name
  * @category AENS
@@ -82,11 +70,11 @@ export function produceNameId(name: AensName): Encoded.Name {
 }
 
 /**
- * Generate the commitment hash by hashing the formatted salt and
+ * Generate the commitment hash by hashing the salt and
  * name, base 58 encoding the result and prepending 'cm_'
  * @category transaction builder
  * @param name - Name to be registered
- * @param salt - Random salt
+ * @param salt - Random number
  * @returns Commitment hash
  */
 export function commitmentHash(
@@ -94,21 +82,14 @@ export function commitmentHash(
   salt: number = genSalt(),
 ): Encoded.Commitment {
   return encode(
-    hash(concatBuffers([Buffer.from(name.toLowerCase()), formatSalt(salt)])),
+    hash(concatBuffers([
+      Buffer.from(name.toLowerCase()),
+      Buffer.from(salt.toString(16).padStart(64, '0'), 'hex'),
+    ])),
     Encoding.Commitment,
   );
 }
 
-/**
- * Utility function to convert int to bytes
- * @category transaction builder
- * @param val - Value
- * @returns Buffer Buffer from number(BigEndian)
- */
-export function writeInt(val: number | string | BigNumber): Buffer {
-  return toBytes(val, true);
-}
-
 /**
  * Utility function to convert bytes to int
  * @category transaction builder
@@ -119,37 +100,6 @@ export function readInt(buf: Buffer = Buffer.from([])): string {
   return new BigNumber(Buffer.from(buf).toString('hex'), 16).toString(10);
 }
 
-/**
- * Helper function to build pointers for name update TX
- * @category transaction builder
- * @param pointers - Array of pointers
- * `([ { key: 'account_pubkey', id: 'ak_32klj5j23k23j5423l434l2j3423'} ])`
- * @returns Serialized pointers array
- */
-export function buildPointers(pointers: NamePointer[]): Buffer[][] {
-  return pointers.map(
-    (p) => [
-      toBytes(p.key),
-      writeId(p.id as Parameters<typeof writeId>[0]),
-    ],
-  );
-}
-
-/**
- * Helper function to read pointers from name update TX
- * @category transaction builder
- * @param pointers - Array of pointers
- * @returns Deserialize pointer array
- */
-export function readPointers(pointers: Array<[key: string, id: Buffer]>): NamePointer[] {
-  return pointers.map(
-    ([key, id]) => ({
-      key: key.toString(),
-      id: readId(id),
-    }),
-  );
-}
-
 const AENS_SUFFIX = '.chain';
 
 /**
@@ -232,10 +182,10 @@ export function computeBidFee(
  */
 export function computeAuctionEndBlock(name: AensName, claimHeight: number): number {
   const length = name.length - AENS_SUFFIX.length;
-  const h = (length <= 4 && 62 * NAME_BID_TIMEOUT_BLOCKS)
-    || (length <= 8 && 31 * NAME_BID_TIMEOUT_BLOCKS)
-    || (length <= 12 && NAME_BID_TIMEOUT_BLOCKS)
-    || 0;
+  const h = (length <= 4 ? 62 * NAME_BID_TIMEOUT_BLOCKS : null)
+    ?? (length <= 8 ? 31 * NAME_BID_TIMEOUT_BLOCKS : null)
+    ?? (length <= 12 ? NAME_BID_TIMEOUT_BLOCKS : null)
+    ?? 0;
   return h + claimHeight;
 }