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

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

@@ -0,0 +1,19 @@
+export default function genArrayField<Input, Output, Binary>(
+  itemHandler: {
+    serialize: (value: Input, params: unknown) => Binary;
+    deserialize: (value: Binary, params: unknown) => Output;
+  },
+): {
+    serialize: (value: Input[], params: unknown) => Binary[];
+    deserialize: (value: Binary[], params: unknown) => Output[];
+  } {
+  return {
+    serialize(items, params) {
+      return items.map((item) => itemHandler.serialize(item, params));
+    },
+
+    deserialize(buffers, params) {
+      return buffers.map((buffer) => itemHandler.deserialize(buffer, params));
+    },
+  };
+}

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

@@ -0,0 +1,9 @@
+export default {
+  serialize(value: boolean): Buffer {
+    return Buffer.from([value ? 1 : 0]);
+  },
+
+  deserialize(buffer: Buffer): boolean {
+    return buffer[0] === 1;
+  },
+};

package/src/tx/builder/field-types/coin-amount.ts

@@ -1,4 +1,5 @@
-import uInt, { Int } from './u-int';
+import uInt from './u-int';
+import { Int } from '../constants';
 import { AE_AMOUNT_FORMATS, formatAmount } from '../../../utils/amount-formatter';
 
 export interface Options { denomination?: AE_AMOUNT_FORMATS }

package/src/tx/builder/field-types/ct-version.ts

@@ -0,0 +1,50 @@
+import { ConsensusProtocolVersion, VmVersion, AbiVersion } from '../constants';
+
+// First abi/vm by default
+export const ProtocolToVmAbi = {
+  [ConsensusProtocolVersion.Iris]: {
+    'contract-create': {
+      vmVersion: [VmVersion.Fate2], abiVersion: [AbiVersion.Fate],
+    },
+    // TODO: Ensure that AEVM (Sophia?) is still available here
+    'contract-call': {
+      vmVersion: [], abiVersion: [AbiVersion.Fate, AbiVersion.Sophia],
+    },
+    'oracle-call': {
+      vmVersion: [], abiVersion: [AbiVersion.NoAbi, AbiVersion.Sophia],
+    },
+  },
+} as const;
+
+export interface CtVersion {
+  vmVersion: VmVersion;
+  abiVersion: AbiVersion;
+}
+
+export function getProtocolDetails(
+  protocolVersion: ConsensusProtocolVersion,
+  type: 'contract-create' | 'contract-call' | 'oracle-call',
+): CtVersion {
+  const protocol = ProtocolToVmAbi[protocolVersion][type];
+  return {
+    vmVersion: protocol.vmVersion[0] ?? VmVersion.Fate2,
+    abiVersion: protocol.abiVersion[0],
+  };
+}
+
+export default {
+  serialize(
+    value: CtVersion | undefined,
+    { consensusProtocolVersion = ConsensusProtocolVersion.Iris }:
+    { consensusProtocolVersion: ConsensusProtocolVersion },
+  ): Buffer {
+    value ??= getProtocolDetails(consensusProtocolVersion, 'contract-create');
+
+    return Buffer.from([value.vmVersion, 0, value.abiVersion]);
+  },
+
+  deserialize(buffer: Buffer): CtVersion {
+    const [vm, , abi] = buffer;
+    return { vmVersion: +vm, abiVersion: +abi };
+  },
+};

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

@@ -1,5 +1,5 @@
 import coinAmount from './coin-amount';
-import { Int } from './u-int';
+import { Int } from '../constants';
 import { IllegalArgumentError } from '../../../utils/errors';
 
 export default {

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

@@ -0,0 +1,27 @@
+import {
+  decode, encode, Encoded, Encoding,
+} from '../../../utils/encoder';
+import { ArgumentError } from '../../../utils/errors';
+
+export default function genEncodedField<E extends Encoding, Optional extends boolean = false>(
+  encoding: E,
+  optional?: Optional,
+): {
+    serialize: Optional extends true
+      ? (value?: Encoded.Generic<E>) => Buffer : (value: Encoded.Generic<E>) => Buffer;
+    deserialize: (value: Buffer) => Encoded.Generic<Encoding>;
+  } {
+  return {
+    serialize(encodedData?: Encoded.Generic<E>) {
+      if (encodedData == null) {
+        if (optional === true) return Buffer.from([]);
+        throw new ArgumentError('Encoded data', 'provided', encodedData);
+      }
+      return decode(encodedData);
+    },
+
+    deserialize(buffer) {
+      return encode(buffer, encoding);
+    },
+  };
+}

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

@@ -0,0 +1,31 @@
+import { decode, encode, Encoding } from '../../../utils/encoder';
+import { Tag } from '../constants';
+import { ArgumentError } from '../../../utils/errors';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
+
+export default function genEntryField<T extends Tag = Tag>(tag?: T): {
+  serialize: (
+    // TODO: replace with `Parameters<typeof buildTxType<T>>[0]`,
+    //  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 `ReturnType<typeof unpackTxType<T>>`,
+    //  TS2577 Return type annotation circularly references itself
+  ) => any;
+} {
+  return {
+    serialize(txParams, { buildTx }) {
+      if (ArrayBuffer.isView(txParams)) return Buffer.from(txParams as any);
+      return decode(buildTx({ ...txParams, ...tag != null && { tag } }));
+    },
+
+    deserialize(buf, { unpackTx }) {
+      const tx = unpackTx(encode(buf, Encoding.Transaction));
+      if (tag != null && tx.tag !== tag) throw new ArgumentError('Tag', tag, tx.tag);
+      return tx;
+    },
+  };
+}

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

@@ -1,13 +1,20 @@
 import { ArgumentError } from '../../../utils/errors';
+import { isItemOfArray } from '../../../utils/other';
 
-export default function genEnumerationField<Enum extends number>(): {
-  serialize: (value: Enum) => Buffer;
-  deserialize: (value: Buffer) => Enum;
+export default function genEnumerationField<
+  Enum extends { [key: string]: number | string },
+>(enm: Enum): {
+  serialize: (value: Enum[keyof Enum]) => Buffer;
+  deserialize: (value: Buffer) => Enum[keyof Enum];
 } {
+  const values = Object.values(enm).filter((v) => typeof v === 'number');
   return {
     serialize(value) {
       if (typeof value !== 'number') throw new ArgumentError('value', 'to be a number', value);
       if (value > 0xff) throw new ArgumentError('value', 'to be less than 256', value);
+      if (!isItemOfArray(value, values)) {
+        throw new ArgumentError('value', 'to be a value of Enum', value);
+      }
       return Buffer.from([value]);
     },
 
@@ -15,7 +22,11 @@ export default function genEnumerationField<Enum extends number>(): {
       if (buffer.length !== 1) {
         throw new ArgumentError('buffer', 'to have single element', buffer.length);
       }
-      return buffer[0] as Enum;
+      const value = buffer[0];
+      if (!isItemOfArray(value, values)) {
+        throw new ArgumentError('value', 'to be a value of Enum', value);
+      }
+      return value as Enum[keyof Enum];
     },
   };
 }

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

@@ -3,6 +3,8 @@ import { IllegalArgumentError } from '../../../utils/errors';
 import { MIN_GAS_PRICE, Tag } from '../constants';
 import coinAmount from './coin-amount';
 import { isKeyOfObject } from '../../../utils/other';
+import { decode, Encoded } from '../../../utils/encoder';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
 
 const BASE_GAS = 15000;
 const GAS_PER_BYTE = 20;
@@ -75,7 +77,7 @@ const TX_FEE_OTHER_GAS = (
   }
 };
 
-function getOracleRelativeTtl(params: any, txType: Tag): number {
+function getOracleRelativeTtl(params: any): number {
   const ttlKeys = {
     [Tag.OracleRegisterTx]: 'oracleTtlValue',
     [Tag.OracleExtendTx]: 'oracleTtlValue',
@@ -83,21 +85,27 @@ function getOracleRelativeTtl(params: any, txType: Tag): number {
     [Tag.OracleResponseTx]: 'responseTtlValue',
   } as const;
 
-  if (!isKeyOfObject(txType, ttlKeys)) return 1;
-  return params[ttlKeys[txType]];
+  const { tag } = params;
+  if (!isKeyOfObject(tag, ttlKeys)) return 1;
+  return params[ttlKeys[tag]];
 }
 
 /**
  * Calculate fee based on tx type and params
  */
-export function buildFee(txType: Tag, buildTx: any): BigNumber {
-  const { rlpEncoded: { length }, txObject } = buildTx;
+export function buildFee(
+  builtTx: Encoded.Transaction,
+  unpackTx: typeof unpackTxType,
+  buildTx: typeof buildTxType,
+): BigNumber {
+  const { length } = decode(builtTx);
+  const txObject = unpackTx(builtTx);
 
-  return TX_FEE_BASE_GAS(txType)
-    .plus(TX_FEE_OTHER_GAS(txType, length, {
-      relativeTtl: getOracleRelativeTtl(txObject, txType),
-      innerTxSize: [Tag.GaMetaTx, Tag.PayingForTx].includes(txType)
-        ? txObject.tx.tx.encodedTx.rlpEncoded.length
+  return TX_FEE_BASE_GAS(txObject.tag)
+    .plus(TX_FEE_OTHER_GAS(txObject.tag, length, {
+      relativeTtl: getOracleRelativeTtl(txObject),
+      innerTxSize: txObject.tag === Tag.GaMetaTx || txObject.tag === Tag.PayingForTx
+        ? decode(buildTx(txObject.tx.encodedTx)).length
         : 0,
     }))
     .times(MIN_GAS_PRICE);
@@ -106,18 +114,18 @@ export function buildFee(txType: Tag, buildTx: any): BigNumber {
 /**
  * Calculate min fee
  * @category transaction builder
- * @param txType - Transaction type
  * @param rebuildTx - Callback to get built transaction with specific fee
  */
 function calculateMinFee(
-  txType: Tag,
-  rebuildTx: (value: BigNumber) => any,
+  rebuildTx: (value: BigNumber) => Encoded.Transaction,
+  unpackTx: typeof unpackTxType,
+  buildTx: typeof buildTxType,
 ): BigNumber {
   let fee = new BigNumber(0);
   let previousFee;
   do {
     previousFee = fee;
-    fee = buildFee(txType, rebuildTx(fee));
+    fee = buildFee(rebuildTx(fee), unpackTx, buildTx);
   } while (!fee.eq(previousFee));
   return fee;
 }
@@ -127,13 +135,25 @@ export default {
 
   serializeAettos(
     _value: string | undefined,
-    { txType, rebuildTx, _computingMinFee }:
-    { txType: Tag; rebuildTx: (params: any) => any; _computingMinFee?: string },
+    {
+      rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee,
+    }: {
+      rebuildTx: (params: any) => Encoded.Transaction;
+      unpackTx: typeof unpackTxType;
+      buildTx: typeof buildTxType;
+      _computingMinFee?: BigNumber;
+      _pickBiggerFee?: boolean;
+    },
   ): string {
-    if (_computingMinFee != null) return _computingMinFee;
-    const minFee = calculateMinFee(txType, (fee) => rebuildTx({ _computingMinFee: fee }));
+    if (_computingMinFee != null) return _computingMinFee.toFixed();
+    const minFee = calculateMinFee(
+      (fee) => rebuildTx({ _computingMinFee: fee }),
+      unpackTx,
+      buildTx,
+    );
     const value = new BigNumber(_value ?? minFee);
     if (minFee.gt(value)) {
+      if (_pickBiggerFee === true) return minFee.toFixed();
       throw new IllegalArgumentError(`Fee ${value.toString()} must be bigger then ${minFee}`);
     }
     return value.toFixed();

package/src/tx/builder/field-types/gas-limit.ts

@@ -2,13 +2,15 @@ import { IllegalArgumentError } from '../../../utils/errors';
 import { MIN_GAS_PRICE, Tag, MAX_AUTH_FUN_GAS } from '../constants';
 import shortUInt from './short-u-int';
 import { buildFee } from './fee';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
 
 function calculateGasLimitMax(
-  txType: Tag,
   gasMax: number,
   rebuildTx: (value: number) => any,
+  unpackTx: typeof unpackTxType,
+  buildTx: typeof buildTxType,
 ): number {
-  return gasMax - +buildFee(txType, rebuildTx(gasMax)).dividedBy(MIN_GAS_PRICE);
+  return gasMax - +buildFee(rebuildTx(gasMax), unpackTx, buildTx).dividedBy(MIN_GAS_PRICE);
 }
 
 export default {
@@ -17,20 +19,23 @@ export default {
   serialize(
     _value: number | undefined,
     {
-      txType, rebuildTx, gasMax = 6e6, _computingGasLimit,
+      tag, rebuildTx, unpackTx, buildTx, gasMax = 6e6, _computingGasLimit,
     }: {
-      txType: Tag;
+      tag: Tag;
       rebuildTx: (params: any) => any;
+      unpackTx: typeof unpackTxType;
+      buildTx: typeof buildTxType;
       gasMax: number;
       _computingGasLimit?: number;
     },
   ): Buffer {
     if (_computingGasLimit != null) return shortUInt.serialize(_computingGasLimit);
 
-    const gasLimitMax = txType === Tag.GaMetaTx ? MAX_AUTH_FUN_GAS : calculateGasLimitMax(
-      txType,
+    const gasLimitMax = tag === Tag.GaMetaTx ? MAX_AUTH_FUN_GAS : calculateGasLimitMax(
       gasMax,
-      (gasLimit) => rebuildTx({ _computingGasLimit: gasLimit }),
+      (gasLimit) => rebuildTx({ _computingGasLimit: gasLimit, _pickBiggerFee: true }),
+      unpackTx,
+      buildTx,
     );
     const value = _value ?? gasLimitMax;
     if (value > gasLimitMax) {

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

@@ -1,55 +1,84 @@
-import _field from './field';
-import _uInt from './u-int';
-import _shortUInt from './short-u-int';
-import _coinAmount from './coin-amount';
+import _abiVersion from './abi-version';
 import _address from './address';
-import _addresses from './addresses';
+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 coinAmount = _coinAmount;
+const abiVersion = _abiVersion;
 const address = _address;
-const addresses = _addresses;
+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 BinaryData = Buffer | Buffer[] | Buffer[][]
+| Array<[Buffer, Array<[Buffer, Buffer[]]>]>;
 export interface Field {
-  serialize: (value: any, options: any) => Buffer | Buffer[] | Buffer[][];
-  deserialize: (value: Buffer | Buffer[] | Buffer[][]) => any;
+  serialize: (value: any, options: any) => BinaryData;
+  deserialize: (value: BinaryData, options: any) => any;
 }
 
 export {
-  field,
-  uInt,
-  shortUInt,
-  coinAmount,
+  abiVersion,
   address,
-  addresses,
+  array,
+  boolean,
+  coinAmount,
+  ctVersion,
   deposit,
+  encoded,
+  entry,
   enumeration,
   fee,
+  field,
   gasLimit,
   gasPrice,
+  mptree,
   name,
   nameFee,
   nameId,
   pointers,
+  raw,
+  shortUInt,
+  shortUIntConst,
+  string,
+  uInt,
 };