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

package/src/spend.ts

@@ -1,56 +1,13 @@
-/*
- * 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 { sendTransaction, getBalance, resolveName } from './chain';
-import { _buildTx, BuildTxOptions } from './tx';
-import { buildTxHash, unpackTx } from './tx/builder';
+import {
+  sendTransaction, getBalance, resolveName, SendTransactionOptions,
+} from './chain';
+import { buildTxAsync, BuildTxOptions, unpackTx } from './tx/builder';
 import { ArgumentError } from './utils/errors';
 import { Encoded, Encoding } from './utils/encoder';
 import { Tag, AensName } from './tx/builder/constants';
 import AccountBase from './account/Base';
 
-/**
- * Sign and post a transaction to the chain
- * @category chain
- * @param tx - Transaction
- * @param options - Options
- * @param options.verify - Verify transaction before broadcast, throw error if not
- * valid
- * @returns Transaction
- */
-export async function send(
-  tx: Encoded.Transaction,
-  options: SendOptions,
-): Promise<SendReturnType> {
-  const signed = await options.onAccount.signTransaction(tx, {
-    ...options,
-    networkId: await options.onNode.getNetworkId(),
-  });
-
-  return options.innerTx === true
-    ? { hash: buildTxHash(signed), rawTx: signed }
-    : sendTransaction(signed, options);
-}
-
-type SendOptionsType = Parameters<AccountBase['signTransaction']>[1]
-& Parameters<typeof sendTransaction>[1] & { onAccount: AccountBase };
-export interface SendOptions extends SendOptionsType {}
-interface SendReturnType extends Awaited<ReturnType<typeof sendTransaction>> {}
-
 /**
  * Send coins to another account
  * @category chain
@@ -63,10 +20,11 @@ export async function spend(
   amount: number | string,
   recipientIdOrName: Encoded.AccountAddress | AensName,
   options: SpendOptions,
-): ReturnType<typeof send> {
-  return send(
-    await _buildTx(Tag.SpendTx, {
+): ReturnType<typeof sendTransaction> {
+  return sendTransaction(
+    await buildTxAsync({
       ...options,
+      tag: Tag.SpendTx,
       senderId: options.onAccount.address,
       recipientId: await resolveName<Encoding.AccountAddress>(
         recipientIdOrName,
@@ -80,23 +38,32 @@ export async function spend(
 }
 
 type SpendOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'>
-& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendOptions;
+& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendTransactionOptions;
 interface SpendOptions extends SpendOptionsType {}
 
 // TODO: Rename to spendFraction
 /**
- * Send a fraction of coin balance to another account
+ * Spend a fraction of coin balance to another account. Useful if needed to drain account balance
+ * completely, sending funds to another account (with fraction set to 1).
  * @category chain
  * @param fraction - Fraction of balance to spend (between 0 and 1)
  * @param recipientIdOrName - Address or name of recipient account
  * @param options - Options
- * @returns Transaction
+ * @example
+ * ```js
+ * // `fraction` * 100 = % of AE to be transferred (e.g. `0.42` for 42% or `1` for 100%)
+ * const { blockHeight } = await aeSdk.transferFunds(
+ *   0.42,
+ *   'ak_21A27UVVt3hDkBE5J7rhhqnH5YNb4Y1dqo4PnSybrH85pnWo7E',
+ * );
+ * console.log('Transaction mined at', blockHeight);
+ * ```
  */
 export async function transferFunds(
   fraction: number | string,
   recipientIdOrName: AensName | Encoded.AccountAddress,
   options: TransferFundsOptions,
-): ReturnType<typeof send> {
+): ReturnType<typeof sendTransaction> {
   if (fraction < 0 || fraction > 1) {
     throw new ArgumentError('fraction', 'a number between 0 and 1', fraction);
   }
@@ -111,23 +78,23 @@ export async function transferFunds(
   );
   const desiredAmount = balance.times(fraction).integerValue(BigNumber.ROUND_HALF_UP);
   const { fee } = unpackTx(
-    await _buildTx(Tag.SpendTx, {
-      ...options, senderId, recipientId, amount: desiredAmount,
+    await buildTxAsync({
+      ...options, tag: Tag.SpendTx, senderId, recipientId, amount: desiredAmount,
     }),
     Tag.SpendTx,
   );
   // Reducing of the amount may reduce transaction fee, so this is not completely accurate
   const amount = desiredAmount.plus(fee).gt(balance) ? balance.minus(fee) : desiredAmount;
-  return send(
-    await _buildTx(Tag.SpendTx, {
-      ...options, senderId, recipientId, amount,
+  return sendTransaction(
+    await buildTxAsync({
+      ...options, tag: Tag.SpendTx, senderId, recipientId, amount,
     }),
     options,
   );
 }
 
 type TransferFundsOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'>
-& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendOptions;
+& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendTransactionOptions;
 interface TransferFundsOptions extends TransferFundsOptionsType {}
 
 /**
@@ -140,17 +107,16 @@ interface TransferFundsOptions extends TransferFundsOptionsType {}
 export async function payForTransaction(
   transaction: Encoded.Transaction,
   options: PayForTransactionOptions,
-): ReturnType<typeof send> {
-  return send(
-    await _buildTx(
-      Tag.PayingForTx,
-      { ...options, payerId: options.onAccount.address, tx: transaction },
-    ),
+): ReturnType<typeof sendTransaction> {
+  return sendTransaction(
+    await buildTxAsync({
+      ...options, tag: Tag.PayingForTx, payerId: options.onAccount.address, tx: transaction,
+    }),
     options,
   );
 }
 
 interface PayForTransactionOptions extends
-  BuildTxOptions<Tag.PayingForTx, 'payerId' | 'tx'>, SendOptions {
+  BuildTxOptions<Tag.PayingForTx, 'payerId' | 'tx' | 'onNode'>, SendTransactionOptions {
   onAccount: AccountBase;
 }

package/src/tx/builder/SchemaTypes.ts

@@ -0,0 +1,79 @@
+import { Field as OriginalField } from './field-types';
+import { UnionToIntersection } from '../../utils/other';
+
+// TODO: figure out why this override is necessary
+export interface Field extends OriginalField {
+  serialize: (...args: any[]) => any;
+}
+
+type NullablePartial<
+  T,
+  NK extends keyof T = { [K in keyof T]: undefined extends T[K] ? K : never }[keyof T],
+> = Partial<Pick<T, NK>> & Omit<T, NK>;
+
+type Or<A, B> = A extends undefined ? B : A;
+
+type TxParamsBySchemaInternal<SchemaItem> = {
+  -readonly [key in keyof SchemaItem]: SchemaItem[key] extends Field
+    ? Parameters<SchemaItem[key]['serialize']>[0]
+    : never;
+};
+
+type TxParamsBySchemaInternalParams<
+  SchemaItem,
+  SchemaItemValues = SchemaItem[keyof SchemaItem],
+> = UnionToIntersection<
+SchemaItemValues extends Field
+  ? Or<Parameters<SchemaItemValues['serialize']>[2], {}> : never
+>;
+
+type PickIsRec<SchemaItem, Recursive extends boolean> = {
+  [Key in keyof SchemaItem
+  as SchemaItem[Key] extends Field & { recursiveType: true }
+    ? (Recursive extends true ? Key : never)
+    : (Recursive extends true ? never : Key)]: SchemaItem[Key];
+};
+
+type TxParamsBySchema<SchemaItem> = SchemaItem extends Object
+  ? TxParamsBySchemaInternal<PickIsRec<SchemaItem, true>> &
+  NullablePartial<TxParamsBySchemaInternal<PickIsRec<SchemaItem, false>>> &
+  TxParamsBySchemaInternalParams<PickIsRec<SchemaItem, false>>
+  : never;
+
+type TxParamsAsyncBySchemaInternal<SchemaItem> = {
+  -readonly [key in keyof SchemaItem]: SchemaItem[key] extends Field & { prepare: Function }
+    ? Parameters<SchemaItem[key]['prepare']>[0]
+    : SchemaItem[key] extends Field
+      ? Parameters<SchemaItem[key]['serialize']>[0]
+      : never;
+};
+
+type TxParamsAsyncBySchemaInternalParams<
+  SchemaItem,
+  SchemaItemValues = SchemaItem[keyof SchemaItem],
+> = UnionToIntersection<
+SchemaItemValues extends Field & { prepare: Function }
+  ? Or<Parameters<SchemaItemValues['prepare']>[2], {}> : {}
+>;
+
+type TxParamsAsyncBySchema<SchemaItem> = SchemaItem extends Object
+  ? TxParamsAsyncBySchemaInternal<PickIsRec<SchemaItem, true>>
+  & NullablePartial<TxParamsAsyncBySchemaInternal<PickIsRec<SchemaItem, false>>>
+  & TxParamsAsyncBySchemaInternalParams<PickIsRec<SchemaItem, false>>
+  & TxParamsBySchemaInternalParams<PickIsRec<SchemaItem, false>>
+  : never;
+
+type TxUnpackedBySchema<SchemaItem> = {
+  -readonly [key in keyof SchemaItem]: SchemaItem[key] extends Field
+    ? ReturnType<SchemaItem[key]['deserialize']>
+    : never;
+};
+
+export default interface SchemaTypes<
+  Schema extends readonly any[],
+  SchemaItems = Schema[number],
+> {
+  TxParams: TxParamsBySchema<SchemaItems>;
+  TxParamsAsync: TxParamsAsyncBySchema<SchemaItems>;
+  TxUnpacked: TxUnpackedBySchema<SchemaItems>;
+}

package/src/tx/builder/constants.ts

@@ -60,6 +60,7 @@ export const NAME_BID_RANGES = mapObject({
 
 export enum ConsensusProtocolVersion {
   Iris = 5,
+  Ceres = 6,
 }
 
 /**
@@ -149,6 +150,7 @@ export enum Tag {
   GaAttachTx = 80,
   GaMetaTx = 81,
   PayingForTx = 82,
+  GaMetaTxAuthData = 810,
   // KeyBlock = 100,
   // MicroBlock = 101,
   // LightMicroBlock = 102,

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

@@ -1,20 +1,43 @@
 import { Tag, ConsensusProtocolVersion, AbiVersion } from '../constants';
 import { getProtocolDetails } from './ct-version';
+import Node from '../../../Node';
 
 export default {
+  _getProtocolDetails(c: ConsensusProtocolVersion, tag: Tag): AbiVersion {
+    const kind = Tag.ContractCallTx === tag || Tag.GaMetaTx === tag
+      ? 'contract-call' : 'oracle-call';
+    return getProtocolDetails(c, kind).abiVersion;
+  },
+
   serialize(
     value: AbiVersion | undefined,
-    { tag, consensusProtocolVersion = ConsensusProtocolVersion.Iris }:
-    { tag: Tag; consensusProtocolVersion: ConsensusProtocolVersion },
+    { tag }: { tag: Tag },
+    { consensusProtocolVersion = ConsensusProtocolVersion.Iris }:
+    { consensusProtocolVersion?: ConsensusProtocolVersion },
   ): Buffer {
-    const result = value ?? getProtocolDetails(
-      consensusProtocolVersion,
-      Tag.ContractCallTx === tag || Tag.GaMetaTx === tag ? 'contract-call' : 'oracle-call',
-    ).abiVersion;
+    const result = value ?? this._getProtocolDetails(consensusProtocolVersion, tag);
 
     return Buffer.from([result]);
   },
 
+  async prepare(
+    value: AbiVersion | undefined,
+    { tag }: { tag: Tag },
+    // TODO: { consensusProtocolVersion: ConsensusProtocolVersion } | { onNode: Node } | {}
+    options: { consensusProtocolVersion?: ConsensusProtocolVersion; onNode?: Node },
+  ): Promise<AbiVersion | undefined> {
+    if (value != null) return value;
+    if (options.consensusProtocolVersion != null) return undefined;
+    if (Object.keys(ConsensusProtocolVersion).length === 2) return undefined;
+    if (options.onNode != null) {
+      return this._getProtocolDetails(
+        (await options.onNode.getNodeInfo()).consensusProtocolVersion,
+        tag,
+      );
+    }
+    return undefined;
+  },
+
   deserialize(buffer: Buffer): AbiVersion {
     return buffer[0];
   },

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

@@ -4,7 +4,7 @@ export default function genArrayField<Input, Output, Binary>(
     deserialize: (value: Binary, params: unknown) => Output;
   },
 ): {
-    serialize: (value: Input[], params: unknown) => Binary[];
+    serialize: (value: readonly Input[], params: unknown) => Binary[];
     deserialize: (value: Binary[], params: unknown) => Output[];
   } {
   return {

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

@@ -2,8 +2,6 @@ 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 }
-
 export default {
   ...uInt,
 
@@ -11,11 +9,15 @@ export default {
     return value ?? '0';
   },
 
-  serialize(value: Int | undefined, { denomination, ...options }: Options): Buffer {
+  serialize(
+    value: Int | undefined,
+    params: {},
+    { denomination = AE_AMOUNT_FORMATS.AETTOS }: { denomination?: AE_AMOUNT_FORMATS },
+  ): Buffer {
     return uInt.serialize(
       this.serializeAettos(
         value != null ? formatAmount(value, { denomination }) : value,
-        options,
+        params,
       ),
     );
   },

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

@@ -1,17 +1,31 @@
 import { ConsensusProtocolVersion, VmVersion, AbiVersion } from '../constants';
+import Node from '../../../Node';
 
-// First abi/vm by default
+/*
+ * First abi/vm by default
+ * @see {@link https://github.com/aeternity/protocol/blob/71cf111/contracts/contract_vms.md#virtual-machines-on-the-æternity-blockchain}
+ */
 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],
+      vmVersion: [], abiVersion: [AbiVersion.NoAbi, AbiVersion.Fate],
+    },
+  },
+  [ConsensusProtocolVersion.Ceres]: {
+    'contract-create': {
+      vmVersion: [VmVersion.Fate2], abiVersion: [AbiVersion.Fate],
+    },
+    'contract-call': {
+      vmVersion: [], abiVersion: [AbiVersion.Fate],
+    },
+    'oracle-call': {
+      vmVersion: [], abiVersion: [AbiVersion.NoAbi, AbiVersion.Fate],
     },
   },
 } as const;
@@ -35,14 +49,33 @@ export function getProtocolDetails(
 export default {
   serialize(
     value: CtVersion | undefined,
+    params: {},
     { consensusProtocolVersion = ConsensusProtocolVersion.Iris }:
-    { consensusProtocolVersion: ConsensusProtocolVersion },
+    { consensusProtocolVersion?: ConsensusProtocolVersion },
   ): Buffer {
     value ??= getProtocolDetails(consensusProtocolVersion, 'contract-create');
 
     return Buffer.from([value.vmVersion, 0, value.abiVersion]);
   },
 
+  async prepare(
+    value: CtVersion | undefined,
+    params: {},
+    // TODO: { consensusProtocolVersion: ConsensusProtocolVersion } | { onNode: Node } | {}
+    options: { consensusProtocolVersion?: ConsensusProtocolVersion; onNode?: Node },
+  ): Promise<CtVersion | undefined> {
+    if (value != null) return value;
+    if (options.consensusProtocolVersion != null) return undefined;
+    if (Object.keys(ConsensusProtocolVersion).length === 2) return undefined;
+    if (options.onNode != null) {
+      return getProtocolDetails(
+        (await options.onNode.getNodeInfo()).consensusProtocolVersion,
+        'contract-create',
+      );
+    }
+    return undefined;
+  },
+
   deserialize(buffer: Buffer): CtVersion {
     const [vm, , abi] = buffer;
     return { vmVersion: +vm, abiVersion: +abi };

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

@@ -8,14 +8,16 @@ export default {
   /**
    * @param value - Deposit value in string format. Should be equal to '0'.
    * @param options - Options
+   * @param parameters - Parameters
    * @returns Deposit value Buffer.
    */
   serialize(
     value: Int | undefined,
     options: Parameters<typeof coinAmount['serialize']>[1],
+    parameters: Parameters<typeof coinAmount['serialize']>[2],
   ): Buffer {
     value ??= 0;
     if (+value !== 0) throw new IllegalArgumentError(`Contract deposit is not refundable, so it should be equal 0, got ${value.toString()} instead`);
-    return coinAmount.serialize(value, options);
+    return coinAmount.serialize(value, options, parameters);
   },
 };

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

@@ -9,7 +9,7 @@ export default function genEncodedField<E extends Encoding, Optional extends boo
 ): {
     serialize: Optional extends true
       ? (value?: Encoded.Generic<E>) => Buffer : (value: Encoded.Generic<E>) => Buffer;
-    deserialize: (value: Buffer) => Encoded.Generic<Encoding>;
+    deserialize: (value: Buffer) => Encoded.Generic<E>;
   } {
   return {
     serialize(encodedData?: Encoded.Generic<E>) {

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

@@ -1,24 +1,29 @@
-import { decode, encode, Encoding } from '../../../utils/encoder';
+import {
+  decode, encode, Encoded, 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]`,
+    // TODO: replace with `TxParams & { tag: T }`,
     //  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>>`,
+    // TODO: replace with `TxUnpacked & { tag: T }`,
     //  TS2577 Return type annotation circularly references itself
   ) => any;
 } {
   return {
     serialize(txParams, { buildTx }) {
       if (ArrayBuffer.isView(txParams)) return Buffer.from(txParams as any);
+      if (typeof txParams === 'string' && txParams.startsWith('tx_')) {
+        return decode(txParams as Encoded.Transaction);
+      }
       return decode(buildTx({ ...txParams, ...tag != null && { tag } }));
     },
 

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

@@ -101,12 +101,14 @@ export function buildFee(
   const { length } = decode(builtTx);
   const txObject = unpackTx(builtTx);
 
+  let innerTxSize = 0;
+  if (txObject.tag === Tag.GaMetaTx || txObject.tag === Tag.PayingForTx) {
+    innerTxSize = decode(buildTx(txObject.tx.encodedTx)).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,
+      relativeTtl: getOracleRelativeTtl(txObject), innerTxSize,
     }))
     .times(MIN_GAS_PRICE);
 }

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

@@ -19,15 +19,15 @@ export default {
   serialize(
     _value: number | undefined,
     {
-      tag, rebuildTx, unpackTx, buildTx, gasMax = 6e6, _computingGasLimit,
+      tag, rebuildTx, unpackTx, buildTx, _computingGasLimit,
     }: {
       tag: Tag;
       rebuildTx: (params: any) => any;
       unpackTx: typeof unpackTxType;
       buildTx: typeof buildTxType;
-      gasMax: number;
       _computingGasLimit?: number;
     },
+    { gasMax = 6e6 }: { gasMax?: number },
   ): Buffer {
     if (_computingGasLimit != null) return shortUInt.serialize(_computingGasLimit);
 

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

@@ -12,16 +12,20 @@ import _fee from './fee';
 import _field from './field';
 import _gasLimit from './gas-limit';
 import _gasPrice from './gas-price';
+import _map from './map';
 import _mptree from './mptree';
 import _name from './name';
 import _nameFee from './name-fee';
 import _nameId from './name-id';
+import _nonce from './nonce';
 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 _ttl from './ttl';
 import _uInt from './u-int';
+import _wrapped from './wrapped';
 
 // TODO: remove after fixing https://github.com/Gerrit0/typedoc-plugin-missing-exports/issues/15
 const abiVersion = _abiVersion;
@@ -38,22 +42,28 @@ const fee = _fee;
 const field = _field;
 const gasLimit = _gasLimit;
 const gasPrice = _gasPrice;
+const map = _map;
 const mptree = _mptree;
 const name = _name;
 const nameFee = _nameFee;
 const nameId = _nameId;
+const nonce = _nonce;
 const pointers = _pointers;
 const raw = _raw;
 const shortUInt = _shortUInt;
 const shortUIntConst = _shortUIntConst;
 const string = _string;
+const ttl = _ttl;
 const uInt = _uInt;
+const wrapped = _wrapped;
 
 export type BinaryData = Buffer | Buffer[] | Buffer[][]
 | Array<[Buffer, Array<[Buffer, Buffer[]]>]>;
 export interface Field {
-  serialize: (value: any, options: any) => BinaryData;
+  serialize: (value: any, options: any, parameters: any) => BinaryData;
+  prepare?: (value: any, options: any, parameters: any) => Promise<any>;
   deserialize: (value: BinaryData, options: any) => any;
+  recursiveType?: boolean;
 }
 
 export {
@@ -71,14 +81,18 @@ export {
   field,
   gasLimit,
   gasPrice,
+  map,
   mptree,
   name,
   nameFee,
   nameId,
+  nonce,
   pointers,
   raw,
   shortUInt,
   shortUIntConst,
   string,
+  ttl,
   uInt,
+  wrapped,
 };

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

@@ -13,6 +13,7 @@ import {
   decode, encode, Encoded, Encoding,
 } from '../../../utils/encoder';
 import type { unpackTx } from '..';
+import type { TxUnpacked } from '../schema.generated';
 
 enum NodeType {
   Branch,
@@ -176,7 +177,7 @@ class MPTree<E extends Encoding, T extends Tag> {
    * @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 {
+  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);
@@ -215,14 +216,14 @@ class MPTree<E extends Encoding, T extends Tag> {
     return entries;
   }
 
-  toObject(): Record<Encoded.Any, ReturnType<typeof unpackTx<T>>> {
+  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 }>;
   }
 }