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

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

@@ -0,0 +1,44 @@
+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 }: { tag: Tag },
+    { consensusProtocolVersion = ConsensusProtocolVersion.Iris }:
+    { consensusProtocolVersion?: ConsensusProtocolVersion },
+  ): Buffer {
+    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/address.ts

@@ -1,6 +1,8 @@
-import { PrefixNotFoundError, TagNotFoundError } from '../../../utils/errors';
+import { ArgumentError, PrefixNotFoundError, TagNotFoundError } from '../../../utils/errors';
 import { toBytes } from '../../../utils/bytes';
-import { decode, encode, Encoding } from '../../../utils/encoder';
+import {
+  decode, encode, Encoded, Encoding,
+} from '../../../utils/encoder';
 import { isItemOfArray } from '../../../utils/other';
 
 /**
@@ -9,7 +11,7 @@ import { isItemOfArray } from '../../../utils/other';
  * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_id.erl#L97-L102}
  * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_api_encoder.erl#L163-L168}
  */
-const idTagToEncoding = [
+export const idTagToEncoding = [
   Encoding.AccountAddress,
   Encoding.Name,
   Encoding.Commitment,
@@ -20,10 +22,12 @@ const idTagToEncoding = [
 
 export type AddressEncodings = typeof idTagToEncoding[number];
 
-export default function genAddressField<Encoding extends AddressEncodings>(): {
-  serialize: (value: `${Encoding}_${string}`) => Buffer;
-  deserialize: (value: Buffer) => `${Encoding}_${string}`;
-} {
+export default function genAddressField<Encoding extends AddressEncodings>(
+  ...encodings: Encoding[]
+): {
+    serialize: (value: Encoded.Generic<Encoding>) => Buffer;
+    deserialize: (value: Buffer) => Encoded.Generic<Encoding>;
+  } {
   return {
     /**
      * Utility function to create and _id type
@@ -31,9 +35,12 @@ export default function genAddressField<Encoding extends AddressEncodings>(): {
      * @returns Buffer Buffer with ID tag and decoded HASh
      */
     serialize(hashId) {
-      const encoding = hashId.slice(0, 2);
-      if (!isItemOfArray(encoding, idTagToEncoding)) throw new TagNotFoundError(encoding);
-      const idTag = idTagToEncoding.indexOf(encoding) + 1;
+      const enc = hashId.slice(0, 2);
+      if (!isItemOfArray(enc, idTagToEncoding)) throw new TagNotFoundError(enc);
+      if (!isItemOfArray(enc, encodings)) {
+        throw new ArgumentError('Address encoding', encodings.join(', '), enc);
+      }
+      const idTag = idTagToEncoding.indexOf(enc) + 1;
       return Buffer.from([...toBytes(idTag), ...decode(hashId)]);
     },
 
@@ -44,9 +51,12 @@ export default function genAddressField<Encoding extends AddressEncodings>(): {
      */
     deserialize(buf) {
       const idTag = Buffer.from(buf).readUIntBE(0, 1);
-      const encoding = idTagToEncoding[idTag - 1];
-      if (encoding == null) throw new PrefixNotFoundError(idTag);
-      return encode(buf.subarray(1), encoding) as `${Encoding}_${string}`;
+      const enc = idTagToEncoding[idTag - 1];
+      if (enc == null) throw new PrefixNotFoundError(idTag);
+      if (!isItemOfArray(enc, encodings)) {
+        throw new ArgumentError('Address encoding', encodings.join(', '), enc);
+      }
+      return encode(buf.subarray(1), enc) as Encoded.Generic<Encoding>;
     },
   };
 }

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: readonly 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,8 +1,7 @@
-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 }
-
 export default {
   ...uInt,
 
@@ -10,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

@@ -0,0 +1,83 @@
+import { ConsensusProtocolVersion, VmVersion, AbiVersion } from '../constants';
+import Node from '../../../Node';
+
+/*
+ * 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],
+    },
+    'contract-call': {
+      vmVersion: [], abiVersion: [AbiVersion.Fate, AbiVersion.Sophia],
+    },
+    'oracle-call': {
+      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;
+
+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,
+    params: {},
+    { consensusProtocolVersion = ConsensusProtocolVersion.Iris }:
+    { 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

@@ -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 {
@@ -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

@@ -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<E>;
+  } {
+  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,36 @@
+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 `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 `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 } }));
+    },
+
+    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,22 +85,30 @@ 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);
+
+  let innerTxSize = 0;
+  if (txObject.tag === Tag.GaMetaTx || txObject.tag === Tag.PayingForTx) {
+    innerTxSize = decode(buildTx(txObject.tx.encodedTx)).length;
+  }
 
-  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
-        : 0,
+  return TX_FEE_BASE_GAS(txObject.tag)
+    .plus(TX_FEE_OTHER_GAS(txObject.tag, length, {
+      relativeTtl: getOracleRelativeTtl(txObject), innerTxSize,
     }))
     .times(MIN_GAS_PRICE);
 }
@@ -106,18 +116,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 +137,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, _computingGasLimit,
     }: {
-      txType: Tag;
+      tag: Tag;
       rebuildTx: (params: any) => any;
-      gasMax: number;
+      unpackTx: typeof unpackTxType;
+      buildTx: typeof buildTxType;
       _computingGasLimit?: number;
     },
+    { gasMax = 6e6 }: { gasMax?: 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,98 @@
-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 _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 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 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) => Buffer | Buffer[] | Buffer[][];
-  deserialize: (value: Buffer | Buffer[] | Buffer[][]) => any;
+  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 {
-  field,
-  uInt,
-  shortUInt,
-  coinAmount,
+  abiVersion,
   address,
-  addresses,
+  array,
+  boolean,
+  coinAmount,
+  ctVersion,
   deposit,
+  encoded,
+  entry,
   enumeration,
   fee,
+  field,
   gasLimit,
   gasPrice,
+  map,
+  mptree,
   name,
   nameFee,
   nameId,
+  nonce,
   pointers,
+  raw,
+  shortUInt,
+  shortUIntConst,
+  string,
+  ttl,
+  uInt,
+  wrapped,
 };