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

package/src/index.ts

@@ -1,57 +1,5 @@
-/*
- * 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.
- */
+export * from './index-browser';
 
-export * from './chain';
-export * from './utils/crypto';
-export * from './utils/keystore';
-export * from './utils/bytes';
-export * from './tx';
-export * from './tx/builder';
-export * from './tx/builder/helpers';
-export * from './tx/builder/constants';
-export * from './tx/builder/schema';
-export * from './utils/amount-formatter';
-export * from './utils/hd-wallet';
-export { encode, decode, Encoding } from './utils/encoder';
-export * from './aens';
-export { default as Contract } from './contract/Contract';
-export type { ContractMethodsBase } from './contract/Contract';
-export * from './oracle';
-export * from './spend';
-export * from './contract/ga';
-
-export { default as AeSdkMethods } from './AeSdkMethods';
-export { default as AeSdkBase } from './AeSdkBase';
-export { default as AeSdk } from './AeSdk';
-export { default as AeSdkAepp } from './AeSdkAepp';
-export { default as AeSdkWallet } from './AeSdkWallet';
-export { default as Node } from './Node';
-export { default as verifyTransaction } from './tx/validator';
-export { default as AccountBase } from './account/Base';
-export { default as MemoryAccount } from './account/Memory';
-export { default as AccountGeneralized } from './account/Generalized';
-export { default as AccountLedger } from './account/Ledger';
-export { default as AccountLedgerFactory } from './account/LedgerFactory';
-export { default as CompilerHttp } from './contract/CompilerHttp';
-export { default as Channel } from './channel/Contract';
-
-export { default as connectionProxy } from './aepp-wallet-communication/connection-proxy';
-export * from './aepp-wallet-communication/schema';
-export { default as walletDetector } from './aepp-wallet-communication/wallet-detector';
-export { default as BrowserRuntimeConnection } from './aepp-wallet-communication/connection/BrowserRuntime';
-export { default as BrowserWindowMessageConnection } from './aepp-wallet-communication/connection/BrowserWindowMessage';
-export * from './utils/errors';
+export { default as CompilerCli } from './contract/compiler/Cli';
+export { default as getFileSystem } from './contract/compiler/getFileSystem';
+export { default as CompilerHttpNode } from './contract/compiler/HttpNode';

package/src/oracle.ts

@@ -1,20 +1,3 @@
-/*
- * 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.
- */
-
 /**
  * Oracle methods - routines to interact with the æternity oracle system
  *
@@ -23,15 +6,12 @@
  * repository.
  */
 
-import BigNumber from 'bignumber.js';
-import { send, SendOptions } from './spend';
 import { mapObject, pause } from './utils/other';
 import { oracleQueryId } from './tx/builder/helpers';
-import { unpackTx } from './tx/builder';
+import { unpackTx, buildTxAsync, BuildTxOptions } from './tx/builder';
 import {
   ORACLE_TTL,
   ORACLE_TTL_TYPES,
-  QUERY_FEE,
   QUERY_TTL,
   RESPONSE_TTL,
 } from './tx/builder/schema';
@@ -40,8 +20,9 @@ import { RequestTimedOutError } from './utils/errors';
 import {
   decode, encode, Encoded, Encoding,
 } from './utils/encoder';
-import { _getPollInterval, getHeight } from './chain';
-import { _buildTx, BuildTxOptions } from './tx';
+import {
+  _getPollInterval, getHeight, sendTransaction, SendTransactionOptions,
+} from './chain';
 import Node from './Node';
 import AccountBase from './account/Base';
 
@@ -59,7 +40,7 @@ type OracleQueries = Awaited<ReturnType<Node['getOracleQueriesByPubkey']>>['orac
  */
 export function pollForQueries(
   oracleId: Encoded.OracleAddress,
-  onQuery: (queries: OracleQueries) => void,
+  onQuery: (query: OracleQueries[number]) => void,
   { interval, onNode, ...options }: { interval?: number; onNode: Node }
   & Parameters<typeof _getPollInterval>[1],
 ): () => void {
@@ -68,8 +49,10 @@ export function pollForQueries(
   const checkNewQueries = async (): Promise<void> => {
     const queries = ((await onNode.getOracleQueriesByPubkey(oracleId)).oracleQueries ?? [])
       .filter(({ id }) => !knownQueryIds.has(id));
-    queries.forEach(({ id }) => knownQueryIds.add(id));
-    if (queries.length > 0) onQuery(queries);
+    queries.forEach((query) => {
+      knownQueryIds.add(query.id);
+      onQuery(query);
+    });
   };
 
   let stopped = false;
@@ -135,7 +118,7 @@ export async function getQueryObject(
     decodedResponse: decode(record.response as Encoded.OracleResponse).toString(),
     respond: async (response, opt) => (
       // eslint-disable-next-line @typescript-eslint/no-use-before-define
-      respondToQuery(oracleId, queryId, response, { ...options, ...opt })
+      respondToQuery(queryId, response, { ...options, ...opt })
     ),
     pollForResponse: async (opt) => pollForQueryResponse(oracleId, queryId, { ...options, ...opt }),
   };
@@ -144,7 +127,7 @@ export async function getQueryObject(
 interface GetQueryObjectReturnType extends Awaited<ReturnType<Node['getOracleQueryByPubkeyAndQueryId']>> {
   decodedQuery: string;
   decodedResponse: string;
-  respond: (response: string, options?: Parameters<typeof respondToQuery>[3]) =>
+  respond: (response: string, options?: Parameters<typeof respondToQuery>[2]) =>
   ReturnType<typeof respondToQuery>;
   pollForResponse: (options?: Parameters<typeof pollForQueryResponse>[2]) =>
   ReturnType<typeof pollForQueryResponse>;
@@ -167,29 +150,32 @@ export async function postQueryToOracle(
   oracleId: Encoded.OracleAddress,
   query: string,
   options: PostQueryToOracleOptions,
-): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getQueryObject>>> {
+): Promise<
+  Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getQueryObject>>
+  > {
   options.queryFee ??= (await options.onNode.getOracleByPubkey(oracleId)).queryFee.toString();
   const senderId = options.onAccount.address;
 
-  const oracleQueryTx = await _buildTx(Tag.OracleQueryTx, {
+  const oracleQueryTx = await buildTxAsync({
     queryTtlType: QUERY_TTL.type,
     queryTtlValue: QUERY_TTL.value,
     responseTtlType: RESPONSE_TTL.type,
     responseTtlValue: RESPONSE_TTL.value,
     ...options,
+    tag: Tag.OracleQueryTx,
     oracleId,
     senderId,
     query,
   });
-  const { nonce } = unpackTx(oracleQueryTx, Tag.OracleQueryTx).tx;
+  const { nonce } = unpackTx(oracleQueryTx, Tag.OracleQueryTx);
   const queryId = oracleQueryId(senderId, nonce, oracleId);
   return {
-    ...await send(oracleQueryTx, options),
+    ...await sendTransaction(oracleQueryTx, options),
     ...await getQueryObject(oracleId, queryId, options),
   };
 }
 
-type PostQueryToOracleOptionsType = Parameters<typeof send>[1]
+type PostQueryToOracleOptionsType = Parameters<typeof sendTransaction>[1]
 & Parameters<typeof getQueryObject>[2]
 & BuildTxOptions<Tag.OracleQueryTx, 'oracleId' | 'senderId' | 'query' | 'queryTtlType' | 'queryTtlValue' | 'responseTtlType' | 'responseTtlValue'>
 & {
@@ -203,7 +189,6 @@ interface PostQueryToOracleOptions extends PostQueryToOracleOptionsType {}
 /**
  * Extend oracle ttl
  * @category oracle
- * @param oracleId - Oracle public key
  * @param options - Options object
  * @param options.fee - fee Transaction fee
  * @param options.ttl - Transaction time to leave
@@ -211,25 +196,25 @@ interface PostQueryToOracleOptions extends PostQueryToOracleOptionsType {}
  * @param options.oracleTtlValue - Oracle time to leave for extend
  * @returns Oracle object
  */
-export async function extendOracleTtl(
-  oracleId: Encoded.OracleAddress,
-  options: ExtendOracleTtlOptions,
-): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>> {
-  const oracleExtendTx = await _buildTx(Tag.OracleExtendTx, {
+export async function extendOracleTtl(options: ExtendOracleTtlOptions): Promise<
+Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>
+> {
+  const oracleId = encode(decode(options.onAccount.address), Encoding.OracleAddress);
+  const oracleExtendTx = await buildTxAsync({
     oracleTtlType: ORACLE_TTL.type,
     oracleTtlValue: ORACLE_TTL.value,
     ...options,
-    callerId: options.onAccount.address,
+    tag: Tag.OracleExtendTx,
     oracleId,
   });
   return {
-    ...await send(oracleExtendTx, options),
+    ...await sendTransaction(oracleExtendTx, options),
     // eslint-disable-next-line @typescript-eslint/no-use-before-define
     ...await getOracleObject(oracleId, options),
   };
 }
 
-type ExtendOracleTtlOptionsType = SendOptions & Parameters<typeof getOracleObject>[1]
+type ExtendOracleTtlOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1]
 & BuildTxOptions<Tag.OracleExtendTx, 'oracleTtlType' | 'oracleTtlValue' | 'callerId' | 'oracleId'>
 & { oracleTtlType?: ORACLE_TTL_TYPES; oracleTtlValue?: number };
 interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {}
@@ -237,7 +222,6 @@ interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {}
 /**
  * Extend oracle ttl
  * @category oracle
- * @param oracleId - Oracle public key
  * @param queryId - Oracle query id
  * @param response - Oracle query response
  * @param options - Options object
@@ -247,28 +231,30 @@ interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {}
  * @returns Oracle object
  */
 export async function respondToQuery(
-  oracleId: Encoded.OracleAddress,
   queryId: Encoded.OracleQueryId,
   response: string,
   options: RespondToQueryOptions,
-): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>> {
-  const oracleRespondTx = await _buildTx(Tag.OracleResponseTx, {
+): Promise<
+  Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>
+  > {
+  const oracleId = encode(decode(options.onAccount.address), Encoding.OracleAddress);
+  const oracleRespondTx = await buildTxAsync({
     responseTtlType: RESPONSE_TTL.type,
     responseTtlValue: RESPONSE_TTL.value,
     ...options,
-    callerId: options.onAccount.address,
+    tag: Tag.OracleResponseTx,
     oracleId,
     queryId,
     response,
   });
   return {
-    ...await send(oracleRespondTx, options),
+    ...await sendTransaction(oracleRespondTx, options),
     // eslint-disable-next-line @typescript-eslint/no-use-before-define
     ...await getOracleObject(oracleId, options),
   };
 }
 
-type RespondToQueryOptionsType = SendOptions & Parameters<typeof getOracleObject>[1]
+type RespondToQueryOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1]
 & BuildTxOptions<Tag.OracleResponseTx, 'callerId' | 'oracleId' | 'queryId' | 'response' | 'responseTtlType' | 'responseTtlValue'>
 & { responseTtlType?: ORACLE_TTL_TYPES; responseTtlValue?: number };
 interface RespondToQueryOptions extends RespondToQueryOptionsType {}
@@ -302,7 +288,10 @@ export async function getOracleObject(
           if (lastArg != null && typeof lastArg === 'object' && lastArg.constructor === Object) {
             Object.assign(lastArg, { ...options, ...lastArg });
           } else args.push(options);
-          return handler(oracleId, ...args);
+          return handler(
+            ...['extendOracle', 'respondToQuery'].includes(name) ? [] : [oracleId],
+            ...args,
+          );
         },
       ],
     ),
@@ -337,27 +326,28 @@ export async function registerOracle(
   queryFormat: string,
   responseFormat: string,
   options: RegisterOracleOptions,
-): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>> {
+): Promise<
+  Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>
+  > {
   const accountId = options.onAccount.address;
-  const oracleRegisterTx = await _buildTx(Tag.OracleRegisterTx, {
-    queryFee: QUERY_FEE,
+  const oracleRegisterTx = await buildTxAsync({
     oracleTtlValue: ORACLE_TTL.value,
     oracleTtlType: ORACLE_TTL.type,
     ...options,
+    tag: Tag.OracleRegisterTx,
     accountId,
     queryFormat,
     responseFormat,
   });
   return {
-    ...await send(oracleRegisterTx, options),
+    ...await sendTransaction(oracleRegisterTx, options),
     ...await getOracleObject(encode(decode(accountId), Encoding.OracleAddress), options),
   };
 }
 
-type RegisterOracleOptionsType = SendOptions & Parameters<typeof getOracleObject>[1]
-& BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat' | 'queryFee' | 'oracleTtlType' | 'oracleTtlValue'>
+type RegisterOracleOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1]
+& BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat' | 'oracleTtlType' | 'oracleTtlValue'>
 & {
-  queryFee?: number | string | BigNumber;
   oracleTtlType?: ORACLE_TTL_TYPES;
   oracleTtlValue?: number;
 };

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);
   }
@@ -110,24 +77,24 @@ export async function transferFunds(
     await getBalance.bind(options.onAccount)(senderId, options),
   );
   const desiredAmount = balance.times(fraction).integerValue(BigNumber.ROUND_HALF_UP);
-  const { tx: { fee } } = unpackTx(
-    await _buildTx(Tag.SpendTx, {
-      ...options, senderId, recipientId, amount: desiredAmount,
+  const { fee } = unpackTx(
+    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

@@ -2,6 +2,7 @@ import BigNumber from 'bignumber.js';
 import { mapObject } from '../../utils/other';
 
 export const MAX_AUTH_FUN_GAS = 50000;
+export type Int = number | string | BigNumber;
 // # AENS
 export type AensName = `${string}.chain`;
 export const NAME_TTL = 180000;
@@ -57,6 +58,35 @@ export const NAME_BID_RANGES = mapObject({
   1: 5702887,
 }, ([key, value]) => [key, new BigNumber(value).times(NAME_FEE_MULTIPLIER)]);
 
+export enum ConsensusProtocolVersion {
+  Iris = 5,
+  Ceres = 6,
+}
+
+/**
+ * @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 VmVersion {
+  NoVm = 0,
+  Sophia = 1,
+  SophiaImprovementsMinerva = 3,
+  SophiaImprovementsFortuna = 4,
+  Fate = 5,
+  SophiaImprovementsLima = 6,
+  Fate2 = 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 AbiVersion {
+  NoAbi = 0,
+  Sophia = 1,
+  Fate = 3,
+}
+
 /**
  * Enum with tag types
  * @category transaction builder
@@ -68,13 +98,13 @@ export enum Tag {
   Account = 10,
   SignedTx = 11,
   SpendTx = 12,
-  // Oracle = 20,
+  Oracle = 20,
   // OracleQuery = 21,
   OracleRegisterTx = 22,
   OracleQueryTx = 23,
   OracleResponseTx = 24,
   OracleExtendTx = 25,
-  // Name = 30,
+  Name = 30,
   // NameCommitment = 31,
   NameClaimTx = 32,
   NamePreclaimTx = 33,
@@ -116,10 +146,11 @@ export enum Tag {
   NameserviceMtree = 624,
   OraclesMtree = 625,
   AccountsMtree = 626,
-  CompilerSophia = 70,
+  // CompilerSophia = 70,
   GaAttachTx = 80,
   GaMetaTx = 81,
   PayingForTx = 82,
+  GaMetaTxAuthData = 810,
   // KeyBlock = 100,
   // MicroBlock = 101,
   // LightMicroBlock = 102,