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

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 }>;
   }
 }
 

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

@@ -25,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/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/short-u-int-const.ts

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