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

package/src/tx/builder/schema.ts

@@ -4,26 +4,22 @@
 // # RLP version number
 // # https://github.com/aeternity/protocol/blob/master/serializations.md#binary-serialization
 
-import BigNumber from 'bignumber.js';
 import { Tag } from './constants';
+import SchemaTypes from './SchemaTypes';
 import {
-  Field, uInt, shortUInt, coinAmount, name, nameId, nameFee, deposit, gasLimit, gasPrice, fee,
-  address, addresses, pointers, enumeration,
+  uInt, shortUInt, coinAmount, name, nameId, nameFee, deposit, gasLimit, gasPrice, fee,
+  address, pointers, entry, enumeration, mptree, shortUIntConst, string, encoded, raw,
+  array, boolean, ctVersion, abiVersion, ttl, nonce, map, wrapped,
 } from './field-types';
 import { Encoded, Encoding } from '../../utils/encoder';
-import MPTree from '../../utils/mptree';
-import { UnionToIntersection } from '../../utils/other';
-import { AddressEncodings } from './field-types/address';
+import { idTagToEncoding } from './field-types/address';
 
 export enum ORACLE_TTL_TYPES {
   delta = 0,
   block = 1,
 }
 
-// # TRANSACTION DEFAULT TTL
-export const TX_TTL = 0;
 // # ORACLE
-export const QUERY_FEE = 30000;
 export const ORACLE_TTL = { type: ORACLE_TTL_TYPES.delta, value: 500 };
 export const QUERY_TTL = { type: ORACLE_TTL_TYPES.delta, value: 10 };
 export const RESPONSE_TTL = { type: ORACLE_TTL_TYPES.delta, value: 10 };
@@ -33,684 +29,558 @@ export const DRY_RUN_ACCOUNT = {
   amount: 100000000000000000000000000000000000n,
 } as const;
 
-export type TxField = [
-  name: string,
-  type: FIELD_TYPES | Field,
-  prefix?: Encoding | Encoding[],
-];
-
-/**
- * @category transaction builder
- * @see {@link https://github.com/aeternity/protocol/blob/0f6dee3d9d1e8e2469816798f5c7587a6c918f94/contracts/contract_vms.md#virtual-machines-on-the-%C3%A6ternity-blockchain}
- */
-export enum VM_VERSIONS {
-  NO_VM = 0,
-  SOPHIA = 1,
-  SOPHIA_IMPROVEMENTS_MINERVA = 3,
-  SOPHIA_IMPROVEMENTS_FORTUNA = 4,
-  FATE = 5,
-  SOPHIA_IMPROVEMENTS_LIMA = 6,
-  FATE_2 = 7,
-}
-
-/**
- * @category transaction builder
- * @see {@link https://github.com/aeternity/protocol/blob/0f6dee3d9d1e8e2469816798f5c7587a6c918f94/contracts/contract_vms.md#virtual-machines-on-the-%C3%A6ternity-blockchain}
- */
-export enum ABI_VERSIONS {
-  NO_ABI = 0,
-  SOPHIA = 1,
-  FATE = 3,
-}
-
 export enum CallReturnType {
   Ok = 0,
   Error = 1,
   Revert = 2,
 }
 
-/**
- * @category transaction builder
- */
-export enum PROTOCOL_VERSIONS {
-  IRIS = 5,
+// TODO: figure out how to omit overriding types of recursive fields
+interface EntryAny {
+  serialize: (value: TxParams | Uint8Array | Encoded.Transaction) => Buffer;
+  deserialize: (value: Buffer) => TxUnpacked;
+  recursiveType: true;
 }
 
-// First abi/vm by default
-export const PROTOCOL_VM_ABI = {
-  [PROTOCOL_VERSIONS.IRIS]: {
-    [Tag.ContractCreateTx]: {
-      vmVersion: [VM_VERSIONS.FATE_2], abiVersion: [ABI_VERSIONS.FATE],
-    },
-    // TODO: Ensure that AEVM (SOPHIA?) is still available here
-    [Tag.ContractCallTx]: {
-      vmVersion: [], abiVersion: [ABI_VERSIONS.FATE, ABI_VERSIONS.SOPHIA],
-    },
-    [Tag.OracleRegisterTx]: {
-      vmVersion: [], abiVersion: [ABI_VERSIONS.NO_ABI, ABI_VERSIONS.SOPHIA],
-    },
-  },
-} as const;
+const entryAny = entry() as unknown as EntryAny;
 
-type PrefixType<Prefix> = Prefix extends Encoding
-  ? Encoded.Generic<Prefix>
-  : Prefix extends readonly Encoding[]
-    ? Encoded.Generic<Prefix[number]>
-    : Encoded.Generic<any>;
+interface EntrySignedTx {
+  serialize: (value: TxParams & { tag: Tag.SignedTx } | Uint8Array | Encoded.Transaction) => Buffer;
+  deserialize: (value: Buffer) => TxUnpacked & { tag: Tag.SignedTx };
+  recursiveType: true;
+}
 
-/**
- * @category transaction builder
- */
-export interface CtVersion {
-  vmVersion: VM_VERSIONS;
-  abiVersion: ABI_VERSIONS;
+const entrySignedTx = entry(Tag.SignedTx) as unknown as EntrySignedTx;
+
+interface EntryMtreeValueArray {
+  serialize: (
+    value: Array<TxParams & { tag: Tag.MtreeValue } | Uint8Array | Encoded.Transaction>,
+  ) => Buffer[];
+  deserialize: (value: Buffer[]) => Array<TxUnpacked & { tag: Tag.MtreeValue }>;
+  recursiveType: true;
 }
 
-/**
- * @category transaction builder
- */
-export enum FIELD_TYPES {
-  string,
-  binary,
-  bool,
-  hex,
-  rlpBinary,
-  rlpBinaries,
-  rawBinary,
-  signatures,
-  offChainUpdates,
-  callStack,
-  proofOfInclusion,
-  mptrees,
-  ctVersion,
-  sophiaCodeTypeInfo,
-  payload,
-  stateTree,
+const entryMtreeValueArray = array(entry(Tag.MtreeValue)) as unknown as EntryMtreeValueArray;
+
+interface EntryTreesPoi {
+  serialize: (value: TxParams & { tag: Tag.TreesPoi } | Uint8Array | Encoded.Transaction) => Buffer;
+  deserialize: (value: Buffer) => TxUnpacked & { tag: Tag.TreesPoi };
+  recursiveType: true;
 }
 
-interface BuildFieldTypes<Prefix extends undefined | Encoding | readonly Encoding[]> {
-  [FIELD_TYPES.string]: string;
-  [FIELD_TYPES.binary]: PrefixType<Prefix>;
-  [FIELD_TYPES.bool]: Boolean;
-  [FIELD_TYPES.hex]: string;
-  [FIELD_TYPES.rlpBinary]: any;
-  [FIELD_TYPES.rlpBinaries]: any[];
-  [FIELD_TYPES.rawBinary]: Uint8Array;
-  [FIELD_TYPES.signatures]: Uint8Array[];
-  [FIELD_TYPES.offChainUpdates]: any;
-  [FIELD_TYPES.callStack]: any;
-  [FIELD_TYPES.proofOfInclusion]: any;
-  [FIELD_TYPES.mptrees]: MPTree[];
-  [FIELD_TYPES.ctVersion]: CtVersion;
-  [FIELD_TYPES.sophiaCodeTypeInfo]: any;
-  [FIELD_TYPES.payload]: string | undefined;
-  [FIELD_TYPES.stateTree]: any;
+const entryTreesPoi = entry(Tag.TreesPoi) as unknown as EntryTreesPoi;
+
+interface MapContracts {
+  serialize: (
+    value: Record<Encoded.ContractAddress, TxParams & { tag: Tag.Contract }>,
+  ) => Buffer;
+  deserialize: (
+    value: Buffer,
+  ) => Record<Encoded.ContractAddress, TxUnpacked & { tag: Tag.Contract }>;
+  recursiveType: true;
 }
 
-type TxElem = readonly [string, FIELD_TYPES | Field]
-| readonly [string, FIELD_TYPES, Encoding | readonly Encoding[]];
+const mapContracts = map(Encoding.ContractAddress, Tag.Contract) as unknown as MapContracts;
 
-type BuildTxArgBySchemaType<
-  Type extends FIELD_TYPES | Field,
-  Prefix extends undefined | Encoding | readonly Encoding[],
-> =
-  Type extends Field
-    ? Parameters<Type['serialize']>[0]
-    : Type extends FIELD_TYPES
-      ? BuildFieldTypes<Prefix>[Type]
-      : never;
+interface MapAccounts {
+  serialize: (
+    value: Record<Encoded.AccountAddress, TxParams & { tag: Tag.Account }>,
+  ) => Buffer;
+  deserialize: (value: Buffer) => Record<Encoded.AccountAddress, TxUnpacked & { tag: Tag.Account }>;
+  recursiveType: true;
+}
 
-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>;
+const mapAccounts = map(Encoding.AccountAddress, Tag.Account) as unknown as MapAccounts;
 
-type BuildTxArgBySchema<SchemaLine> =
-  UnionToIntersection<
-  SchemaLine extends ReadonlyArray<infer Elem>
-    ? Elem extends TxElem
-      ? NullablePartial<{ [k in Elem[0]]: BuildTxArgBySchemaType<Elem[1], Elem[2]> }>
-      : never
-    : never
-  >;
+interface MapCalls {
+  serialize: (
+    value: Record<Encoded.Bytearray, TxParams & { tag: Tag.ContractCall }>,
+  ) => Buffer;
+  deserialize: (value: Buffer) => Record<Encoded.Bytearray, TxUnpacked & { tag: Tag.ContractCall }>;
+  recursiveType: true;
+}
 
-export type RawTxObject<Tx extends TxSchema> = {
-  [k in keyof Tx]-?: Tx[k] extends BigNumber ? string : Tx[k]
-};
+const mapCalls = map(Encoding.Bytearray, Tag.ContractCall) as unknown as MapCalls;
 
-const BASE_TX = [
-  ['tag', shortUInt],
-  ['VSN', shortUInt],
-] as const;
+interface MapChannels {
+  serialize: (
+    value: Record<Encoded.Channel, TxParams & { tag: Tag.Channel }>,
+  ) => Buffer;
+  deserialize: (value: Buffer) => Record<Encoded.Channel, TxUnpacked & { tag: Tag.Channel }>;
+  recursiveType: true;
+}
 
-export const TX_SCHEMA = {
-  [Tag.Account]: {
-    1: [
-      ...BASE_TX,
-      ['nonce', shortUInt],
-      ['balance', uInt],
-    ],
-    2: [
-      ...BASE_TX,
-      ['flags', uInt],
-      ['nonce', shortUInt],
-      ['balance', uInt],
-      ['gaContract', address<Encoding.ContractAddress | Encoding.Name>()],
-      ['gaAuthFun', FIELD_TYPES.binary, Encoding.ContractBytearray],
-    ],
-  },
-  [Tag.SignedTx]: {
-    1: [
-      ...BASE_TX,
-      ['signatures', FIELD_TYPES.signatures],
-      ['encodedTx', FIELD_TYPES.rlpBinary],
-    ],
-  },
-  [Tag.SpendTx]: {
-    1: [
-      ...BASE_TX,
-      ['senderId', address<Encoding.AccountAddress>()],
-      ['recipientId', address<Encoding.AccountAddress | Encoding.Name>()],
-      ['amount', coinAmount],
-      ['fee', fee],
-      ['ttl', shortUInt],
-      ['nonce', shortUInt],
-      ['payload', FIELD_TYPES.payload],
-    ],
-  },
-  [Tag.NamePreclaimTx]: {
-    1: [
-      ...BASE_TX,
-      ['accountId', address<Encoding.AccountAddress>()],
-      ['nonce', shortUInt],
-      ['commitmentId', address<Encoding.Commitment>()],
-      ['fee', fee],
-      ['ttl', shortUInt],
-    ],
-  },
-  [Tag.NameClaimTx]: {
-    2: [
-      ...BASE_TX,
-      ['accountId', address<Encoding.AccountAddress>()],
-      ['nonce', shortUInt],
-      ['name', name],
-      ['nameSalt', uInt],
-      ['nameFee', nameFee],
-      ['fee', fee],
-      ['ttl', shortUInt],
-    ],
-  },
-  [Tag.NameUpdateTx]: {
-    1: [
-      ...BASE_TX,
-      ['accountId', address<Encoding.AccountAddress>()],
-      ['nonce', shortUInt],
-      ['nameId', nameId],
-      ['nameTtl', shortUInt],
-      ['pointers', pointers],
-      ['clientTtl', shortUInt],
-      ['fee', fee],
-      ['ttl', shortUInt],
-    ],
-  },
-  [Tag.NameTransferTx]: {
-    1: [
-      ...BASE_TX,
-      ['accountId', address<Encoding.AccountAddress>()],
-      ['nonce', shortUInt],
-      ['nameId', nameId],
-      ['recipientId', address<Encoding.AccountAddress | Encoding.Name>()],
-      ['fee', fee],
-      ['ttl', shortUInt],
-    ],
-  },
-  [Tag.NameRevokeTx]: {
-    1: [
-      ...BASE_TX,
-      ['accountId', address<Encoding.AccountAddress>()],
-      ['nonce', shortUInt],
-      ['nameId', nameId],
-      ['fee', fee],
-      ['ttl', shortUInt],
-    ],
-  },
-  [Tag.Contract]: {
-    1: [
-      ...BASE_TX,
-      ['owner', address<Encoding.AccountAddress>()],
-      ['ctVersion', FIELD_TYPES.ctVersion],
-      ['code', FIELD_TYPES.binary, Encoding.ContractBytearray],
-      ['log', FIELD_TYPES.binary, Encoding.ContractBytearray],
-      ['active', FIELD_TYPES.bool],
-      ['referers', addresses<Encoding.AccountAddress>()],
-      ['deposit', deposit],
-    ],
-  },
-  [Tag.ContractCreateTx]: {
-    1: [
-      ...BASE_TX,
-      ['ownerId', address<Encoding.AccountAddress>()],
-      ['nonce', shortUInt],
-      ['code', FIELD_TYPES.binary, Encoding.ContractBytearray],
-      ['ctVersion', FIELD_TYPES.ctVersion],
-      ['fee', fee],
-      ['ttl', shortUInt],
-      ['deposit', deposit],
-      ['amount', coinAmount],
-      ['gasLimit', gasLimit],
-      ['gasPrice', gasPrice],
-      ['callData', FIELD_TYPES.binary, Encoding.ContractBytearray],
-    ],
-  },
-  [Tag.ContractCallTx]: {
-    1: [
-      ...BASE_TX,
-      ['callerId', address<Encoding.AccountAddress>()],
-      ['nonce', shortUInt],
-      ['contractId', address<Encoding.ContractAddress | Encoding.Name>()],
-      ['abiVersion', enumeration<ABI_VERSIONS>()],
-      ['fee', fee],
-      ['ttl', shortUInt],
-      ['amount', coinAmount],
-      ['gasLimit', gasLimit],
-      ['gasPrice', gasPrice],
-      ['callData', FIELD_TYPES.binary, Encoding.ContractBytearray],
-    ],
-  },
-  [Tag.ContractCall]: {
-    1: [
-      ...BASE_TX,
-      ['callerId', address<Encoding.AccountAddress>()],
-      ['callerNonce', shortUInt],
-      ['height', shortUInt],
-      ['contractId', address<Encoding.ContractAddress>()],
-      ['gasPrice', gasPrice],
-      ['gasUsed', shortUInt],
-      ['returnValue', FIELD_TYPES.binary, Encoding.ContractBytearray],
-      ['returnType', enumeration<CallReturnType>()],
-      // TODO: add serialization for
-      //  <log> :: [ { <address> :: id, [ <topics> :: binary() ], <data> :: binary() } ]
-      ['log', FIELD_TYPES.rawBinary],
-    ],
-  },
-  [Tag.OracleRegisterTx]: {
-    1: [
-      ...BASE_TX,
-      ['accountId', address<Encoding.AccountAddress>()],
-      ['nonce', shortUInt],
-      ['queryFormat', FIELD_TYPES.string],
-      ['responseFormat', FIELD_TYPES.string],
-      ['queryFee', coinAmount],
-      ['oracleTtlType', enumeration<ORACLE_TTL_TYPES>()],
-      ['oracleTtlValue', shortUInt],
-      ['fee', fee],
-      ['ttl', shortUInt],
-      ['abiVersion', enumeration<ABI_VERSIONS>()],
-    ],
-  },
-  [Tag.OracleExtendTx]: {
-    1: [
-      ...BASE_TX,
-      ['oracleId', address<Encoding.OracleAddress | Encoding.Name>()],
-      ['nonce', shortUInt],
-      ['oracleTtlType', enumeration<ORACLE_TTL_TYPES>()],
-      ['oracleTtlValue', shortUInt],
-      ['fee', fee],
-      ['ttl', shortUInt],
-    ],
-  },
-  [Tag.OracleQueryTx]: {
-    1: [
-      ...BASE_TX,
-      ['senderId', address<Encoding.AccountAddress>()],
-      ['nonce', shortUInt],
-      ['oracleId', address<Encoding.OracleAddress | Encoding.Name>()],
-      ['query', FIELD_TYPES.string],
-      ['queryFee', coinAmount],
-      ['queryTtlType', enumeration<ORACLE_TTL_TYPES>()],
-      ['queryTtlValue', shortUInt],
-      ['responseTtlType', enumeration<ORACLE_TTL_TYPES>()],
-      ['responseTtlValue', shortUInt],
-      ['fee', fee],
-      ['ttl', shortUInt],
-    ],
-  },
-  [Tag.OracleResponseTx]: {
-    1: [
-      ...BASE_TX,
-      ['oracleId', address<Encoding.OracleAddress>()],
-      ['nonce', shortUInt],
-      ['queryId', FIELD_TYPES.binary, Encoding.OracleQueryId],
-      ['response', FIELD_TYPES.string],
-      ['responseTtlType', enumeration<ORACLE_TTL_TYPES>()],
-      ['responseTtlValue', shortUInt],
-      ['fee', fee],
-      ['ttl', shortUInt],
-    ],
-  },
-  [Tag.ChannelCreateTx]: {
-    2: [
-      ...BASE_TX,
-      ['initiator', address<Encoding.AccountAddress>()],
-      ['initiatorAmount', uInt],
-      ['responder', address<Encoding.AccountAddress>()],
-      ['responderAmount', uInt],
-      ['channelReserve', uInt],
-      ['lockPeriod', uInt],
-      ['ttl', shortUInt],
-      ['fee', fee],
-      ['initiatorDelegateIds', FIELD_TYPES.string],
-      ['responderDelegateIds', FIELD_TYPES.string],
-      ['stateHash', FIELD_TYPES.binary, Encoding.State],
-      ['nonce', shortUInt],
-    ],
-  },
-  [Tag.ChannelCloseMutualTx]: {
-    1: [
-      ...BASE_TX,
-      ['channelId', address<Encoding.Channel>()],
-      ['fromId', address<Encoding.AccountAddress>()],
-      ['initiatorAmountFinal', uInt],
-      ['responderAmountFinal', uInt],
-      ['ttl', shortUInt],
-      ['fee', fee],
-      ['nonce', shortUInt],
-    ],
-  },
-  [Tag.ChannelCloseSoloTx]: {
-    1: [
-      ...BASE_TX,
-      ['channelId', address<Encoding.Channel>()],
-      ['fromId', address<Encoding.AccountAddress>()],
-      ['payload', FIELD_TYPES.binary, Encoding.Transaction],
-      ['poi', FIELD_TYPES.binary, Encoding.Poi],
-      ['ttl', shortUInt],
-      ['fee', fee],
-      ['nonce', shortUInt],
-    ],
-  },
-  [Tag.ChannelSlashTx]: {
-    1: [
-      ...BASE_TX,
-      ['channelId', address<Encoding.Channel>()],
-      ['fromId', address<Encoding.AccountAddress>()],
-      ['payload', FIELD_TYPES.binary, Encoding.Transaction],
-      ['poi', FIELD_TYPES.binary, Encoding.Poi],
-      ['ttl', shortUInt],
-      ['fee', fee],
-      ['nonce', shortUInt],
-    ],
-  },
-  [Tag.ChannelDepositTx]: {
-    1: [
-      ...BASE_TX,
-      ['channelId', address<Encoding.Channel>()],
-      ['fromId', address<Encoding.AccountAddress>()],
-      ['amount', uInt],
-      ['ttl', shortUInt],
-      ['fee', fee],
-      ['stateHash', FIELD_TYPES.binary, Encoding.State],
-      ['round', shortUInt],
-      ['nonce', shortUInt],
-    ],
-  },
-  [Tag.ChannelWithdrawTx]: {
-    1: [
-      ...BASE_TX,
-      ['channelId', address<Encoding.Channel>()],
-      ['toId', address<Encoding.AccountAddress>()],
-      ['amount', uInt],
-      ['ttl', shortUInt],
-      ['fee', fee],
-      ['stateHash', FIELD_TYPES.binary, Encoding.State],
-      ['round', shortUInt],
-      ['nonce', shortUInt],
-    ],
-  },
-  [Tag.ChannelSettleTx]: {
-    1: [
-      ...BASE_TX,
-      ['channelId', address<Encoding.Channel>()],
-      ['fromId', address<Encoding.AccountAddress>()],
-      ['initiatorAmountFinal', uInt],
-      ['responderAmountFinal', uInt],
-      ['ttl', shortUInt],
-      ['fee', fee],
-      ['nonce', shortUInt],
-    ],
-  },
-  [Tag.ChannelForceProgressTx]: {
-    1: [
-      ...BASE_TX,
-      ['channelId', address<Encoding.Channel>()],
-      ['fromId', address<Encoding.AccountAddress>()],
-      ['payload', FIELD_TYPES.binary, Encoding.Transaction],
-      ['round', shortUInt],
-      ['update', FIELD_TYPES.binary, Encoding.ContractBytearray],
-      ['stateHash', FIELD_TYPES.binary, Encoding.State],
-      ['offChainTrees', FIELD_TYPES.stateTree],
-      ['ttl', shortUInt],
-      ['fee', fee],
-      ['nonce', shortUInt],
-    ],
-  },
-  [Tag.ChannelOffChainTx]: {
-    2: [
-      ...BASE_TX,
-      ['channelId', address<Encoding.Channel>()],
-      ['round', shortUInt],
-      ['stateHash', FIELD_TYPES.binary, Encoding.State],
-    ],
-  },
-  [Tag.Channel]: {
-    3: [
-      ...BASE_TX,
-      ['initiator', address<Encoding.AccountAddress>()],
-      ['responder', address<Encoding.AccountAddress>()],
-      ['channelAmount', uInt],
-      ['initiatorAmount', uInt],
-      ['responderAmount', uInt],
-      ['channelReserve', uInt],
-      ['initiatorDelegateIds', addresses<AddressEncodings>()],
-      ['responderDelegateIds', addresses<AddressEncodings>()],
-      ['stateHash', FIELD_TYPES.hex],
-      ['round', shortUInt],
-      ['soloRound', uInt],
-      ['lockPeriod', uInt],
-      ['lockedUntil', uInt],
-      ['initiatorAuth', FIELD_TYPES.binary, Encoding.ContractBytearray],
-      ['responderAuth', FIELD_TYPES.binary, Encoding.ContractBytearray],
-    ],
-  },
-  [Tag.ChannelSnapshotSoloTx]: {
-    1: [
-      ...BASE_TX,
-      ['channelId', address<Encoding.Channel>()],
-      ['fromId', address<Encoding.AccountAddress>()],
-      ['payload', FIELD_TYPES.binary, Encoding.Transaction],
-      ['ttl', shortUInt],
-      ['fee', fee],
-      ['nonce', shortUInt],
-    ],
-  },
-  [Tag.ChannelOffChainUpdateTransfer]: {
-    1: [
-      ...BASE_TX,
-      ['from', address<Encoding.AccountAddress>()],
-      ['to', address<Encoding.AccountAddress>()],
-      ['amount', uInt],
-    ],
-  },
-  [Tag.ChannelOffChainUpdateDeposit]: {
-    1: [
-      ...BASE_TX,
-      ['from', address<Encoding.AccountAddress>()],
-      ['amount', uInt],
-    ],
-  },
-  [Tag.ChannelOffChainUpdateWithdraw]: {
-    1: [
-      ...BASE_TX,
-      ['from', address<Encoding.AccountAddress>()],
-      ['amount', uInt],
-    ],
-  },
-  [Tag.ChannelOffChainUpdateCreateContract]: {
-    1: [
-      ...BASE_TX,
-      ['owner', address<Encoding.AccountAddress>()],
-      ['ctVersion', FIELD_TYPES.ctVersion],
-      ['code', FIELD_TYPES.binary, Encoding.ContractBytearray],
-      ['deposit', uInt],
-      ['callData', FIELD_TYPES.binary, Encoding.ContractBytearray],
-    ],
-  },
-  [Tag.ChannelOffChainUpdateCallContract]: {
-    1: [
-      ...BASE_TX,
-      ['caller', address<Encoding.AccountAddress>()],
-      ['contract', address<Encoding.ContractAddress>()],
-      ['abiVersion', enumeration<ABI_VERSIONS>()],
-      ['amount', uInt],
-      ['callData', FIELD_TYPES.binary, Encoding.ContractBytearray],
-      ['callStack', FIELD_TYPES.callStack],
-      ['gasPrice', gasPrice],
-      ['gasLimit', gasLimit],
-    ],
-  },
-  [Tag.ChannelClientReconnectTx]: {
-    1: [
-      ...BASE_TX,
-      ['channelId', address<Encoding.Channel>()],
-      ['round', shortUInt],
-      ['role', FIELD_TYPES.string],
-      ['pubkey', address<Encoding.AccountAddress>()],
-    ],
-  },
-  [Tag.TreesPoi]: {
-    1: [
-      ...BASE_TX,
-      ['accounts', FIELD_TYPES.mptrees],
-      ['calls', FIELD_TYPES.mptrees],
-      ['channels', FIELD_TYPES.mptrees],
-      ['contracts', FIELD_TYPES.mptrees],
-      ['ns', FIELD_TYPES.mptrees],
-      ['oracles', FIELD_TYPES.mptrees],
-    ],
-  },
-  [Tag.StateTrees]: {
-    1: [
-      ...BASE_TX,
-      ['contracts', FIELD_TYPES.rlpBinary],
-      ['calls', FIELD_TYPES.rlpBinary],
-      ['channels', FIELD_TYPES.rlpBinary],
-      ['ns', FIELD_TYPES.rlpBinary],
-      ['oracles', FIELD_TYPES.rlpBinary],
-      ['accounts', FIELD_TYPES.rlpBinary],
-    ],
-  },
-  [Tag.Mtree]: {
-    1: [
-      ...BASE_TX,
-      ['values', FIELD_TYPES.rlpBinaries],
-    ],
-  },
-  [Tag.MtreeValue]: {
-    1: [
-      ...BASE_TX,
-      ['key', FIELD_TYPES.hex],
-      ['value', FIELD_TYPES.rawBinary],
-    ],
-  },
-  [Tag.ContractsMtree]: {
-    1: [
-      ...BASE_TX,
-      ['contracts', FIELD_TYPES.rlpBinary],
-    ],
-  },
-  [Tag.CallsMtree]: {
-    1: [
-      ...BASE_TX,
-      ['calls', FIELD_TYPES.rlpBinary],
-    ],
-  },
-  [Tag.ChannelsMtree]: {
-    1: [
-      ...BASE_TX,
-      ['channels', FIELD_TYPES.rlpBinary],
-    ],
-  },
-  [Tag.NameserviceMtree]: {
-    1: [
-      ...BASE_TX,
-      ['mtree', FIELD_TYPES.rlpBinary],
-    ],
-  },
-  [Tag.OraclesMtree]: {
-    1: [
-      ...BASE_TX,
-      ['otree', FIELD_TYPES.rlpBinary],
-    ],
-  },
-  [Tag.AccountsMtree]: {
-    1: [
-      ...BASE_TX,
-      ['accounts', FIELD_TYPES.rlpBinary],
-    ],
-  },
-  [Tag.GaAttachTx]: {
-    1: [
-      ...BASE_TX,
-      ['ownerId', address<Encoding.AccountAddress>()],
-      ['nonce', shortUInt],
-      ['code', FIELD_TYPES.binary, Encoding.ContractBytearray],
-      ['authFun', FIELD_TYPES.rawBinary],
-      ['ctVersion', FIELD_TYPES.ctVersion],
-      ['fee', fee],
-      ['ttl', shortUInt],
-      ['gasLimit', gasLimit],
-      ['gasPrice', gasPrice],
-      ['callData', FIELD_TYPES.binary, Encoding.ContractBytearray],
-    ],
-  },
-  [Tag.GaMetaTx]: {
-    2: [
-      ...BASE_TX,
-      ['gaId', address<Encoding.AccountAddress>()],
-      ['authData', FIELD_TYPES.binary, Encoding.ContractBytearray],
-      ['abiVersion', enumeration<ABI_VERSIONS>()],
-      ['fee', fee],
-      ['gasLimit', gasLimit],
-      ['gasPrice', gasPrice],
-      ['tx', FIELD_TYPES.rlpBinary],
-    ],
-  },
-  [Tag.PayingForTx]: {
-    1: [
-      ...BASE_TX,
-      ['payerId', address<Encoding.AccountAddress>()],
-      ['nonce', shortUInt],
-      ['fee', fee],
-      ['tx', FIELD_TYPES.rlpBinary],
-    ],
-  },
-  [Tag.CompilerSophia]: {
-    3: [
-      ...BASE_TX,
-      ['sourceCodeHash', FIELD_TYPES.rawBinary],
-      ['typeInfo', FIELD_TYPES.sophiaCodeTypeInfo],
-      ['byteCode', FIELD_TYPES.rawBinary],
-      ['compilerVersion', FIELD_TYPES.string],
-      ['payable', FIELD_TYPES.bool],
-    ],
-  },
-} as const;
+const mapChannels = map(Encoding.Channel, Tag.Channel) as unknown as MapChannels;
+
+interface MapNames {
+  serialize: (
+    value: Record<Encoded.Name, TxParams & { tag: Tag.Name }>,
+  ) => Buffer;
+  deserialize: (value: Buffer) => Record<Encoded.Name, TxUnpacked & { tag: Tag.Name }>;
+  recursiveType: true;
+}
+
+const mapNames = map(Encoding.Name, Tag.Name) as unknown as MapNames;
 
-export type TxTypeSchemas = {
-  [key in Tag]: BuildTxArgBySchema<
-    typeof TX_SCHEMA[key][keyof typeof TX_SCHEMA[key]]
-  >
-};
+interface MapOracles {
+  serialize: (
+    value: Record<Encoded.OracleAddress, TxParams & { tag: Tag.Oracle }>,
+  ) => Buffer;
+  deserialize: (value: Buffer) => Record<Encoded.OracleAddress, TxUnpacked & { tag: Tag.Oracle }>;
+  recursiveType: true;
+}
+
+const mapOracles = map(Encoding.OracleAddress, Tag.Oracle) as unknown as MapOracles;
+
+/**
+ * @see {@link https://github.com/aeternity/protocol/blob/c007deeac4a01e401238412801ac7084ac72d60e/serializations.md#accounts-version-1-basic-accounts}
+ */
+export const txSchema = [{
+  tag: shortUIntConst(Tag.Account),
+  version: shortUIntConst(1),
+  nonce: shortUInt,
+  balance: uInt,
+}, {
+  tag: shortUIntConst(Tag.Account),
+  version: shortUIntConst(2, true),
+  flags: uInt,
+  nonce: shortUInt,
+  balance: uInt,
+  gaContract: address(Encoding.ContractAddress, Encoding.Name),
+  gaAuthFun: encoded(Encoding.ContractBytearray),
+}, {
+  tag: shortUIntConst(Tag.SignedTx),
+  version: shortUIntConst(1, true),
+  signatures: array(raw),
+  encodedTx: entryAny,
+}, {
+  tag: shortUIntConst(Tag.SpendTx),
+  version: shortUIntConst(1, true),
+  senderId: address(Encoding.AccountAddress),
+  recipientId: address(Encoding.AccountAddress, Encoding.Name),
+  amount: coinAmount,
+  fee,
+  ttl,
+  nonce: nonce('senderId'),
+  payload: encoded(Encoding.Bytearray, true),
+}, {
+  tag: shortUIntConst(Tag.Name),
+  version: shortUIntConst(1, true),
+  accountId: address(Encoding.AccountAddress),
+  nameTtl: shortUInt,
+  status: raw,
+  clientTtl: shortUInt,
+  pointers,
+}, {
+  tag: shortUIntConst(Tag.NamePreclaimTx),
+  version: shortUIntConst(1, true),
+  accountId: address(Encoding.AccountAddress),
+  nonce: nonce('accountId'),
+  commitmentId: address(Encoding.Commitment),
+  fee,
+  ttl,
+}, {
+  tag: shortUIntConst(Tag.NameClaimTx),
+  version: shortUIntConst(2, true),
+  accountId: address(Encoding.AccountAddress),
+  nonce: nonce('accountId'),
+  name,
+  nameSalt: uInt,
+  nameFee,
+  fee,
+  ttl,
+}, {
+  tag: shortUIntConst(Tag.NameUpdateTx),
+  version: shortUIntConst(1, true),
+  accountId: address(Encoding.AccountAddress),
+  nonce: nonce('accountId'),
+  nameId,
+  nameTtl: shortUInt,
+  pointers,
+  clientTtl: shortUInt,
+  fee,
+  ttl,
+}, {
+  tag: shortUIntConst(Tag.NameTransferTx),
+  version: shortUIntConst(1, true),
+  accountId: address(Encoding.AccountAddress),
+  nonce: nonce('accountId'),
+  nameId,
+  recipientId: address(Encoding.AccountAddress, Encoding.Name),
+  fee,
+  ttl,
+}, {
+  tag: shortUIntConst(Tag.NameRevokeTx),
+  version: shortUIntConst(1, true),
+  accountId: address(Encoding.AccountAddress),
+  nonce: nonce('accountId'),
+  nameId,
+  fee,
+  ttl,
+}, {
+  tag: shortUIntConst(Tag.Contract),
+  version: shortUIntConst(1, true),
+  owner: address(Encoding.AccountAddress),
+  ctVersion,
+  code: encoded(Encoding.ContractBytearray),
+  log: encoded(Encoding.ContractBytearray),
+  active: boolean,
+  referers: array(address(Encoding.AccountAddress)),
+  deposit,
+}, {
+  tag: shortUIntConst(Tag.ContractCreateTx),
+  version: shortUIntConst(1, true),
+  ownerId: address(Encoding.AccountAddress),
+  nonce: nonce('ownerId'),
+  code: encoded(Encoding.ContractBytearray),
+  ctVersion,
+  fee,
+  ttl,
+  deposit,
+  amount: coinAmount,
+  gasLimit,
+  gasPrice,
+  callData: encoded(Encoding.ContractBytearray),
+}, {
+  tag: shortUIntConst(Tag.ContractCallTx),
+  version: shortUIntConst(1, true),
+  callerId: address(Encoding.AccountAddress),
+  nonce: nonce('callerId'),
+  contractId: address(Encoding.ContractAddress, Encoding.Name),
+  abiVersion,
+  fee,
+  ttl,
+  amount: coinAmount,
+  gasLimit,
+  gasPrice,
+  callData: encoded(Encoding.ContractBytearray),
+}, {
+  tag: shortUIntConst(Tag.ContractCall),
+  version: shortUIntConst(2, true),
+  callerId: address(Encoding.AccountAddress),
+  callerNonce: shortUInt,
+  height: shortUInt,
+  contractId: address(Encoding.ContractAddress),
+  // TODO: rename after resolving https://github.com/aeternity/protocol/issues/506
+  gasPrice: uInt,
+  gasUsed: shortUInt,
+  returnValue: encoded(Encoding.ContractBytearray),
+  returnType: enumeration(CallReturnType),
+  // TODO: add serialization for
+  //  <log> :: [ { <address> :: id, [ <topics> :: binary() }, <data> :: binary() } ]
+  log: array(raw),
+}, {
+  tag: shortUIntConst(Tag.Oracle),
+  version: shortUIntConst(1, true),
+  accountId: address(Encoding.AccountAddress),
+  queryFormat: string,
+  responseFormat: string,
+  queryFee: coinAmount,
+  oracleTtlValue: shortUInt,
+  abiVersion,
+}, {
+  tag: shortUIntConst(Tag.OracleRegisterTx),
+  version: shortUIntConst(1, true),
+  accountId: address(Encoding.AccountAddress),
+  nonce: nonce('accountId'),
+  queryFormat: string,
+  responseFormat: string,
+  queryFee: coinAmount,
+  oracleTtlType: enumeration(ORACLE_TTL_TYPES),
+  oracleTtlValue: shortUInt,
+  fee,
+  ttl,
+  abiVersion,
+}, {
+  tag: shortUIntConst(Tag.OracleExtendTx),
+  version: shortUIntConst(1, true),
+  oracleId: address(Encoding.OracleAddress, Encoding.Name),
+  nonce: nonce('oracleId'),
+  oracleTtlType: enumeration(ORACLE_TTL_TYPES),
+  oracleTtlValue: shortUInt,
+  fee,
+  ttl,
+}, {
+  tag: shortUIntConst(Tag.OracleQueryTx),
+  version: shortUIntConst(1, true),
+  senderId: address(Encoding.AccountAddress),
+  nonce: nonce('senderId'),
+  oracleId: address(Encoding.OracleAddress, Encoding.Name),
+  query: string,
+  queryFee: coinAmount,
+  queryTtlType: enumeration(ORACLE_TTL_TYPES),
+  queryTtlValue: shortUInt,
+  responseTtlType: enumeration(ORACLE_TTL_TYPES),
+  responseTtlValue: shortUInt,
+  fee,
+  ttl,
+}, {
+  tag: shortUIntConst(Tag.OracleResponseTx),
+  version: shortUIntConst(1, true),
+  oracleId: address(Encoding.OracleAddress),
+  nonce: nonce('oracleId'),
+  queryId: encoded(Encoding.OracleQueryId),
+  response: string,
+  responseTtlType: enumeration(ORACLE_TTL_TYPES),
+  responseTtlValue: shortUInt,
+  fee,
+  ttl,
+}, {
+  tag: shortUIntConst(Tag.ChannelCreateTx),
+  version: shortUIntConst(2, true),
+  initiator: address(Encoding.AccountAddress),
+  initiatorAmount: uInt,
+  responder: address(Encoding.AccountAddress),
+  responderAmount: uInt,
+  channelReserve: uInt,
+  lockPeriod: uInt,
+  ttl,
+  fee,
+  initiatorDelegateIds: array(address(...idTagToEncoding)),
+  responderDelegateIds: array(address(...idTagToEncoding)),
+  stateHash: encoded(Encoding.State),
+  nonce: nonce('initiator'),
+}, {
+  tag: shortUIntConst(Tag.ChannelCloseMutualTx),
+  version: shortUIntConst(1, true),
+  channelId: address(Encoding.Channel),
+  fromId: address(Encoding.AccountAddress),
+  initiatorAmountFinal: uInt,
+  responderAmountFinal: uInt,
+  ttl,
+  fee,
+  nonce: nonce('fromId'),
+}, {
+  tag: shortUIntConst(Tag.ChannelCloseSoloTx),
+  version: shortUIntConst(1, true),
+  channelId: address(Encoding.Channel),
+  fromId: address(Encoding.AccountAddress),
+  payload: encoded(Encoding.Transaction),
+  poi: entryTreesPoi,
+  ttl,
+  fee,
+  nonce: nonce('fromId'),
+}, {
+  tag: shortUIntConst(Tag.ChannelSlashTx),
+  version: shortUIntConst(1, true),
+  channelId: address(Encoding.Channel),
+  fromId: address(Encoding.AccountAddress),
+  payload: encoded(Encoding.Transaction),
+  poi: entryTreesPoi,
+  ttl,
+  fee,
+  nonce: nonce('fromId'),
+}, {
+  tag: shortUIntConst(Tag.ChannelDepositTx),
+  version: shortUIntConst(1, true),
+  channelId: address(Encoding.Channel),
+  fromId: address(Encoding.AccountAddress),
+  amount: uInt,
+  ttl,
+  fee,
+  stateHash: encoded(Encoding.State),
+  round: shortUInt,
+  nonce: nonce('fromId'),
+}, {
+  tag: shortUIntConst(Tag.ChannelWithdrawTx),
+  version: shortUIntConst(1, true),
+  channelId: address(Encoding.Channel),
+  toId: address(Encoding.AccountAddress),
+  amount: uInt,
+  ttl,
+  fee,
+  stateHash: encoded(Encoding.State),
+  round: shortUInt,
+  nonce: nonce('fromId'),
+}, {
+  tag: shortUIntConst(Tag.ChannelSettleTx),
+  version: shortUIntConst(1, true),
+  channelId: address(Encoding.Channel),
+  fromId: address(Encoding.AccountAddress),
+  initiatorAmountFinal: uInt,
+  responderAmountFinal: uInt,
+  ttl,
+  fee,
+  nonce: nonce('fromId'),
+}, {
+  tag: shortUIntConst(Tag.ChannelForceProgressTx),
+  version: shortUIntConst(1, true),
+  channelId: address(Encoding.Channel),
+  fromId: address(Encoding.AccountAddress),
+  payload: encoded(Encoding.Transaction),
+  round: shortUInt,
+  update: encoded(Encoding.ContractBytearray),
+  stateHash: encoded(Encoding.State),
+  offChainTrees: encoded(Encoding.StateTrees),
+  ttl,
+  fee,
+  nonce: nonce('fromId'),
+}, {
+  tag: shortUIntConst(Tag.ChannelOffChainTx),
+  version: shortUIntConst(2, true),
+  channelId: address(Encoding.Channel),
+  round: shortUInt,
+  stateHash: encoded(Encoding.State),
+}, {
+  tag: shortUIntConst(Tag.Channel),
+  version: shortUIntConst(3, true),
+  initiator: address(Encoding.AccountAddress),
+  responder: address(Encoding.AccountAddress),
+  channelAmount: uInt,
+  initiatorAmount: uInt,
+  responderAmount: uInt,
+  channelReserve: uInt,
+  initiatorDelegateIds: array(address(...idTagToEncoding)),
+  responderDelegateIds: array(address(...idTagToEncoding)),
+  stateHash: encoded(Encoding.State),
+  round: shortUInt,
+  soloRound: uInt,
+  lockPeriod: uInt,
+  lockedUntil: uInt,
+  initiatorAuth: encoded(Encoding.ContractBytearray),
+  responderAuth: encoded(Encoding.ContractBytearray),
+}, {
+  tag: shortUIntConst(Tag.ChannelSnapshotSoloTx),
+  version: shortUIntConst(1, true),
+  channelId: address(Encoding.Channel),
+  fromId: address(Encoding.AccountAddress),
+  payload: encoded(Encoding.Transaction),
+  ttl,
+  fee,
+  nonce: nonce('fromId'),
+}, {
+  tag: shortUIntConst(Tag.ChannelOffChainUpdateTransfer),
+  version: shortUIntConst(1, true),
+  from: address(Encoding.AccountAddress),
+  to: address(Encoding.AccountAddress),
+  amount: uInt,
+}, {
+  tag: shortUIntConst(Tag.ChannelOffChainUpdateDeposit),
+  version: shortUIntConst(1, true),
+  from: address(Encoding.AccountAddress),
+  amount: uInt,
+}, {
+  tag: shortUIntConst(Tag.ChannelOffChainUpdateWithdraw),
+  version: shortUIntConst(1, true),
+  from: address(Encoding.AccountAddress),
+  amount: uInt,
+}, {
+  tag: shortUIntConst(Tag.ChannelOffChainUpdateCreateContract),
+  version: shortUIntConst(1, true),
+  owner: address(Encoding.AccountAddress),
+  ctVersion,
+  code: encoded(Encoding.ContractBytearray),
+  deposit: uInt,
+  callData: encoded(Encoding.ContractBytearray),
+}, {
+  tag: shortUIntConst(Tag.ChannelOffChainUpdateCallContract),
+  version: shortUIntConst(1, true),
+  caller: address(Encoding.AccountAddress),
+  contract: address(Encoding.ContractAddress),
+  abiVersion,
+  amount: uInt,
+  callData: encoded(Encoding.ContractBytearray),
+  callStack: raw,
+  gasPrice,
+  gasLimit,
+}, {
+  tag: shortUIntConst(Tag.ChannelClientReconnectTx),
+  version: shortUIntConst(1, true),
+  channelId: address(Encoding.Channel),
+  round: shortUInt,
+  role: string,
+  pubkey: address(Encoding.AccountAddress),
+}, {
+  tag: shortUIntConst(Tag.TreesPoi),
+  version: shortUIntConst(1, true),
+  // TODO: inline an extra wrapping array after resolving https://github.com/aeternity/protocol/issues/505
+  accounts: array(mptree(Encoding.AccountAddress, Tag.Account)),
+  calls: array(mptree(Encoding.Bytearray, Tag.ContractCall)),
+  channels: array(mptree(Encoding.Channel, Tag.Channel)),
+  contracts: array(mptree(Encoding.ContractAddress, Tag.Contract)),
+  ns: array(mptree(Encoding.Name, Tag.Name)),
+  oracles: array(mptree(Encoding.OracleAddress, Tag.Oracle)),
+}, {
+  tag: shortUIntConst(Tag.StateTrees),
+  version: shortUIntConst(0, true),
+  contracts: wrapped(Tag.ContractsMtree) as unknown as MapContracts,
+  calls: wrapped(Tag.CallsMtree) as unknown as MapCalls,
+  channels: wrapped(Tag.ChannelsMtree) as unknown as MapChannels,
+  ns: wrapped(Tag.NameserviceMtree) as unknown as MapNames,
+  oracles: wrapped(Tag.OraclesMtree) as unknown as MapOracles,
+  accounts: wrapped(Tag.AccountsMtree) as unknown as MapAccounts,
+}, {
+  tag: shortUIntConst(Tag.Mtree),
+  version: shortUIntConst(1, true),
+  values: entryMtreeValueArray,
+}, {
+  tag: shortUIntConst(Tag.MtreeValue),
+  version: shortUIntConst(1, true),
+  key: raw,
+  value: raw,
+}, {
+  tag: shortUIntConst(Tag.ContractsMtree),
+  version: shortUIntConst(1, true),
+  payload: mapContracts,
+}, {
+  tag: shortUIntConst(Tag.CallsMtree),
+  version: shortUIntConst(1, true),
+  payload: mapCalls,
+}, {
+  tag: shortUIntConst(Tag.ChannelsMtree),
+  version: shortUIntConst(1, true),
+  payload: mapChannels,
+}, {
+  tag: shortUIntConst(Tag.NameserviceMtree),
+  version: shortUIntConst(1, true),
+  payload: mapNames,
+}, {
+  tag: shortUIntConst(Tag.OraclesMtree),
+  version: shortUIntConst(1, true),
+  payload: mapOracles,
+}, {
+  tag: shortUIntConst(Tag.AccountsMtree),
+  version: shortUIntConst(1, true),
+  payload: mapAccounts,
+}, {
+  tag: shortUIntConst(Tag.GaAttachTx),
+  version: shortUIntConst(1, true),
+  ownerId: address(Encoding.AccountAddress),
+  nonce: nonce('ownerId'),
+  code: encoded(Encoding.ContractBytearray),
+  authFun: raw,
+  ctVersion,
+  fee,
+  ttl,
+  gasLimit,
+  gasPrice,
+  callData: encoded(Encoding.ContractBytearray),
+}, {
+  tag: shortUIntConst(Tag.GaMetaTx),
+  version: shortUIntConst(2, true),
+  gaId: address(Encoding.AccountAddress),
+  authData: encoded(Encoding.ContractBytearray),
+  abiVersion,
+  fee,
+  gasLimit,
+  gasPrice,
+  tx: entrySignedTx,
+}, {
+  tag: shortUIntConst(Tag.PayingForTx),
+  version: shortUIntConst(1, true),
+  payerId: address(Encoding.AccountAddress),
+  nonce: nonce('payerId'),
+  fee,
+  tx: entrySignedTx,
+}, {
+  tag: shortUIntConst(Tag.GaMetaTxAuthData),
+  version: shortUIntConst(1, true),
+  fee: coinAmount,
+  gasPrice,
+  txHash: encoded(Encoding.TxHash),
+}] as const;
 
-export type TxSchema = TxTypeSchemas[Tag];
-export type TxParamsCommon = Partial<UnionToIntersection<TxSchema>>;
+type TxSchema = SchemaTypes<typeof txSchema>;
+export type TxParams = TxSchema['TxParams'];
+export type TxParamsAsync = TxSchema['TxParamsAsync'];
+export type TxUnpacked = TxSchema['TxUnpacked'];