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

package/types-legacy/ts4.2/contract/compiler/Http.d.ts

@@ -0,0 +1,32 @@
+import { Compiler as CompilerApi } from '../../apis/compiler';
+import CompilerBase, { Aci } from './Base';
+import { Encoded } from '../../utils/encoder';
+/**
+ * Contract Compiler over HTTP
+ *
+ * This class include api call's related to contract compiler functionality.
+ * @category contract
+ * @example CompilerHttp('COMPILER_URL')
+ */
+export default class CompilerHttp extends CompilerBase {
+    readonly api: CompilerApi;
+    /**
+     * @param compilerUrl - Url for compiler API
+     * @param options - Options
+     * @param options.ignoreVersion - Don't check compiler version
+     */
+    constructor(compilerUrl: string, { ignoreVersion }?: {
+        ignoreVersion?: boolean;
+    });
+    compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<{
+        bytecode: Encoded.ContractBytearray;
+        aci: Aci;
+    }>;
+    compile(path: string): Promise<{
+        bytecode: Encoded.ContractBytearray;
+        aci: Aci;
+    }>;
+    validateBySourceCode(bytecode: Encoded.ContractBytearray, sourceCode: string, fileSystem?: Record<string, string>): Promise<boolean>;
+    validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean>;
+    version(): Promise<string>;
+}

package/types-legacy/ts4.2/contract/compiler/HttpNode.d.ts

@@ -0,0 +1,17 @@
+import HttpBrowser from './Http';
+import { Aci } from './Base';
+import { Encoded } from '../../utils/encoder';
+/**
+ * Contract Compiler over HTTP for Nodejs
+ *
+ * Inherits CompilerHttp and implements `compile`, `validate` methods
+ * @category contract
+ * @example CompilerHttpNode('COMPILER_URL')
+ */
+export default class CompilerHttpNode extends HttpBrowser {
+    compile(path: string): Promise<{
+        bytecode: Encoded.ContractBytearray;
+        aci: Aci;
+    }>;
+    validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean>;
+}

package/types-legacy/ts4.2/contract/compiler/getFileSystem.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reads all files included in the provided contract
+ * Available only in Node.js
+ * @param path - a path to the main contract source code
+ */
+export default function getFileSystem(path: string): Promise<Record<string, string>>;

package/types-legacy/ts4.2/contract/delegation-signature.d.ts

@@ -0,0 +1,43 @@
+import { Encoded } from '../utils/encoder';
+import { AensName } from '../tx/builder/constants';
+import AccountBase from '../account/Base';
+import Node from '../Node';
+/**
+ * Helper to generate a signature to delegate
+ *  - pre-claim/claim/transfer/revoke of a name to a contract.
+ *  - register/extend/respond of an Oracle to a contract.
+ * @category contract
+ * @param contractAddress - Address of contract to delegate access
+ * @param ids - The list of id's to prepend
+ * @param options - Options
+ * @param options.omitAddress - Prepend delegation signature with an account address
+ * @param options.onAccount - Account to use
+ * @param options.onNode - Node to use
+ * @returns Signature
+ * @example
+ * ```js
+ * const aeSdk = new AeSdk({ ... })
+ * const contractAddress = 'ct_asd2ks...'
+ * const aensName = 'example.chain'
+ * const onAccount = new MemoryAccount(...) // Sign with a specific account
+ * // Preclaim signature
+ * const preclaimSig = await aeSdk.createDelegationSignature(contractAddress, [], { onAccount })
+ * // Claim, transfer and revoke signature
+ * const aensDelegationSig = await aeSdk
+ *   .createDelegationSignature(contractAddress, [aensName], { onAccount })
+ *
+ * const oracleQueryId = 'oq_...'
+ * const onAccount = new MemoryAccount(...) // Sign with a specific account
+ * // Oracle register and extend signature
+ * const oracleDelegationSig = await aeSdk
+ *   .createDelegationSignature(contractAddress, [], { onAccount })
+ * // Oracle respond signature
+ * const respondSig = await aeSdk
+ *   .createDelegationSignature(contractAddress, [oracleQueryId], { onAccount, omitAddress: true })
+ * ```
+ */
+export default function createDelegationSignature(contractAddress: Encoded.ContractAddress, ids: Array<Encoded.Any | AensName>, options: {
+    omitAddress?: boolean;
+    onAccount: AccountBase;
+    onNode: Node;
+}): Promise<Uint8Array>;

package/types-legacy/ts4.2/contract/ga.d.ts

@@ -1,13 +1,15 @@
+/// <reference types="node" />
 /**
  * Generalized Account module - routines to use generalized account
  */
-import { Tag } from '../tx/builder/constants';
-import { BuildTxOptions } from '../tx';
+import { Int, Tag } from '../tx/builder/constants';
+import { BuildTxOptions } from '../tx/builder';
 import { Encoded } from '../utils/encoder';
 import AccountBase from '../account/Base';
-import { SendOptions } from '../spend';
+import Contract from './Contract';
 import Node from '../Node';
-import CompilerHttp from './CompilerHttp';
+import { SendTransactionOptions } from '../chain';
+import CompilerBase from './compiler/Base';
 /**
  * Convert current account to GA
  * @category contract
@@ -17,27 +19,42 @@ import CompilerHttp from './CompilerHttp';
  * @param options - Options
  * @returns General Account Object
  */
-export declare function createGeneralizedAccount(authFnName: string, sourceCode: string, args: any[], { onAccount, onCompiler, onNode, ...options }: CreateGeneralizedAccountOptions): Promise<Readonly<{
+export declare function createGeneralizedAccount(authFnName: string, args: any[], { onAccount, onCompiler, onNode, bytecode, aci, sourceCodePath, sourceCode, fileSystem, ...options }: CreateGeneralizedAccountOptions): Promise<Readonly<{
     owner: Encoded.AccountAddress;
     transaction: Encoded.TxHash;
     rawTx: Encoded.Transaction;
     gaContractId: Encoded.ContractAddress;
 }>>;
-interface CreateGeneralizedAccountOptions extends BuildTxOptions<Tag.GaAttachTx, 'authFun' | 'callData' | 'code' | 'ownerId' | 'gasLimit'>, SendOptions {
+interface CreateGeneralizedAccountOptions extends BuildTxOptions<Tag.GaAttachTx, 'authFun' | 'callData' | 'code' | 'ownerId' | 'gasLimit'>, SendTransactionOptions, Pick<Parameters<typeof Contract.initialize>[0], 'bytecode' | 'aci' | 'sourceCodePath' | 'sourceCode' | 'fileSystem'> {
     onAccount: AccountBase;
-    onCompiler: CompilerHttp;
+    onCompiler: CompilerBase;
     onNode: Node;
     gasLimit?: number;
 }
 /**
- * Build a transaction hash the same as `Auth.tx_hash`
+ * Build a transaction hash the same as `Auth.tx_hash` by GaMetaTx payload
  * @category contract
  * @param transaction - tx-encoded transaction
  * @param options - Options
+ * @param options.fee - GaMetaTx fee, required in Ceres
+ * @param options.gasPrice - GaMetaTx gasPrice, required in Ceres
  * @param options.onNode - Node to use
  * @returns Transaction hash
  */
-export declare function buildAuthTxHash(transaction: Encoded.Transaction, { onNode }: {
+export declare function buildAuthTxHash(transaction: Encoded.Transaction, { fee, gasPrice, onNode }: {
+    fee?: Int;
+    gasPrice?: Int;
     onNode: Node;
-}): Promise<Uint8Array>;
+}): Promise<Buffer>;
+/**
+ * Build a transaction hash the same as `Auth.tx_hash` by GaMetaTx
+ * @category contract
+ * @param transaction - tx-encoded signed GaMeta transaction
+ * @param options - Options
+ * @param options.onNode - Node to use
+ * @returns Transaction hash
+ */
+export declare function buildAuthTxHashByGaMetaTx(transaction: Encoded.Transaction, { onNode }: {
+    onNode: Node;
+}): Promise<Buffer>;
 export {};

package/types-legacy/ts4.2/index-browser.d.ts

@@ -0,0 +1,40 @@
+export * from './chain';
+export * from './utils/crypto';
+export * from './utils/keystore';
+export * from './utils/bytes';
+export { buildTx, buildTxAsync, buildTxHash, unpackTx, buildContractIdByContractTx, } from './tx/builder';
+export * from './tx/builder/helpers';
+export * from './tx/builder/constants';
+export { ORACLE_TTL_TYPES, ORACLE_TTL, QUERY_TTL, RESPONSE_TTL, DRY_RUN_ACCOUNT, CallReturnType, } from './tx/builder/schema';
+export { getExecutionCost, getExecutionCostBySignedTx, getExecutionCostUsingNode, } from './tx/execution-cost';
+export { default as getTransactionSignerAddress } from './tx/transaction-signer';
+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 CompilerBase } from './contract/compiler/Base';
+export { default as CompilerHttp } from './contract/compiler/Http';
+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';

package/types-legacy/ts4.2/index.d.ts

@@ -1,39 +1,5 @@
-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 * from './index-browser';
+export { default as CompilerCli } from './contract/compiler/Cli';
+export { default as getFileSystem } from './contract/compiler/getFileSystem';
+export { default as CompilerHttpNode } from './contract/compiler/HttpNode';
 import './globals';

package/types-legacy/ts4.2/oracle.d.ts

@@ -5,13 +5,11 @@
  * https://github.com/aeternity/protocol/blob/master/ORACLE.md in the protocol
  * repository.
  */
-import BigNumber from 'bignumber.js';
-import { send, SendOptions } from './spend';
+import { BuildTxOptions } from './tx/builder';
 import { ORACLE_TTL_TYPES } from './tx/builder/schema';
 import { Tag } from './tx/builder/constants';
 import { Encoded } from './utils/encoder';
-import { _getPollInterval } from './chain';
-import { BuildTxOptions } from './tx';
+import { _getPollInterval, sendTransaction, SendTransactionOptions } from './chain';
 import Node from './Node';
 import AccountBase from './account/Base';
 type OracleQueries = Awaited<ReturnType<Node['getOracleQueriesByPubkey']>>['oracleQueries'];
@@ -25,7 +23,7 @@ type OracleQueries = Awaited<ReturnType<Node['getOracleQueriesByPubkey']>>['orac
  * @param options.onNode - Node to use
  * @returns Callback to stop polling function
  */
-export declare function pollForQueries(oracleId: Encoded.OracleAddress, onQuery: (queries: OracleQueries) => void, { interval, onNode, ...options }: {
+export declare function pollForQueries(oracleId: Encoded.OracleAddress, onQuery: (query: OracleQueries[number]) => void, { interval, onNode, ...options }: {
     interval?: number;
     onNode: Node;
 } & Parameters<typeof _getPollInterval>[1]): () => void;
@@ -55,7 +53,7 @@ export declare function getQueryObject(oracleId: Encoded.OracleAddress, queryId:
 interface GetQueryObjectReturnType extends Awaited<ReturnType<Node['getOracleQueryByPubkeyAndQueryId']>> {
     decodedQuery: string;
     decodedResponse: string;
-    respond: (response: string, options?: Parameters<typeof respondToQuery>[3]) => ReturnType<typeof respondToQuery>;
+    respond: (response: string, options?: Parameters<typeof respondToQuery>[2]) => ReturnType<typeof respondToQuery>;
     pollForResponse: (options?: Parameters<typeof pollForQueryResponse>[2]) => ReturnType<typeof pollForQueryResponse>;
 }
 /**
@@ -71,8 +69,8 @@ interface GetQueryObjectReturnType extends Awaited<ReturnType<Node['getOracleQue
  * @param options.ttl - Transaction time to leave
  * @returns Query object
  */
-export declare function postQueryToOracle(oracleId: Encoded.OracleAddress, query: string, options: PostQueryToOracleOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getQueryObject>>>;
-type PostQueryToOracleOptionsType = Parameters<typeof send>[1] & Parameters<typeof getQueryObject>[2] & BuildTxOptions<Tag.OracleQueryTx, 'oracleId' | 'senderId' | 'query' | 'queryTtlType' | 'queryTtlValue' | 'responseTtlType' | 'responseTtlValue'> & {
+export declare function postQueryToOracle(oracleId: Encoded.OracleAddress, query: string, options: PostQueryToOracleOptions): Promise<Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getQueryObject>>>;
+type PostQueryToOracleOptionsType = Parameters<typeof sendTransaction>[1] & Parameters<typeof getQueryObject>[2] & BuildTxOptions<Tag.OracleQueryTx, 'oracleId' | 'senderId' | 'query' | 'queryTtlType' | 'queryTtlValue' | 'responseTtlType' | 'responseTtlValue'> & {
     queryTtlType?: ORACLE_TTL_TYPES;
     queryTtlValue?: number;
     responseTtlType?: ORACLE_TTL_TYPES;
@@ -83,7 +81,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
@@ -91,8 +88,8 @@ interface PostQueryToOracleOptions extends PostQueryToOracleOptionsType {
  * @param options.oracleTtlValue - Oracle time to leave for extend
  * @returns Oracle object
  */
-export declare function extendOracleTtl(oracleId: Encoded.OracleAddress, options: ExtendOracleTtlOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>>;
-type ExtendOracleTtlOptionsType = SendOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleExtendTx, 'oracleTtlType' | 'oracleTtlValue' | 'callerId' | 'oracleId'> & {
+export declare function extendOracleTtl(options: ExtendOracleTtlOptions): Promise<Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>>;
+type ExtendOracleTtlOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleExtendTx, 'oracleTtlType' | 'oracleTtlValue' | 'callerId' | 'oracleId'> & {
     oracleTtlType?: ORACLE_TTL_TYPES;
     oracleTtlValue?: number;
 };
@@ -101,7 +98,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
@@ -110,8 +106,8 @@ interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {
  * @param options.ttl - Transaction time to leave
  * @returns Oracle object
  */
-export declare function respondToQuery(oracleId: Encoded.OracleAddress, queryId: Encoded.OracleQueryId, response: string, options: RespondToQueryOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>>;
-type RespondToQueryOptionsType = SendOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleResponseTx, 'callerId' | 'oracleId' | 'queryId' | 'response' | 'responseTtlType' | 'responseTtlValue'> & {
+export declare function respondToQuery(queryId: Encoded.OracleQueryId, response: string, options: RespondToQueryOptions): Promise<Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>>;
+type RespondToQueryOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleResponseTx, 'callerId' | 'oracleId' | 'queryId' | 'response' | 'responseTtlType' | 'responseTtlValue'> & {
     responseTtlType?: ORACLE_TTL_TYPES;
     responseTtlValue?: number;
 };
@@ -150,9 +146,8 @@ interface GetOracleObjectReturnType extends Awaited<ReturnType<Node['getOracleBy
  * @param options.ttl - Transaction time to leave
  * @returns Oracle object
  */
-export declare function registerOracle(queryFormat: string, responseFormat: string, options: RegisterOracleOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>>;
-type RegisterOracleOptionsType = SendOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat' | 'queryFee' | 'oracleTtlType' | 'oracleTtlValue'> & {
-    queryFee?: number | string | BigNumber;
+export declare function registerOracle(queryFormat: string, responseFormat: string, options: RegisterOracleOptions): Promise<Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>>;
+type RegisterOracleOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat' | 'oracleTtlType' | 'oracleTtlValue'> & {
     oracleTtlType?: ORACLE_TTL_TYPES;
     oracleTtlValue?: number;
 };

package/types-legacy/ts4.2/spend.d.ts

@@ -1,25 +1,8 @@
-import { sendTransaction, resolveName } from './chain';
-import { BuildTxOptions } from './tx';
+import { sendTransaction, resolveName, SendTransactionOptions } from './chain';
+import { BuildTxOptions } from './tx/builder';
 import { Encoded } 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 declare function send(tx: Encoded.Transaction, options: SendOptions): Promise<SendReturnType>;
-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
@@ -28,24 +11,33 @@ interface SendReturnType extends Awaited<ReturnType<typeof sendTransaction>> {
  * @param options - Options
  * @returns Transaction
  */
-export declare function spend(amount: number | string, recipientIdOrName: Encoded.AccountAddress | AensName, options: SpendOptions): ReturnType<typeof send>;
+export declare function spend(amount: number | string, recipientIdOrName: Encoded.AccountAddress | AensName, options: SpendOptions): ReturnType<typeof sendTransaction>;
 type SpendOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'> & Parameters<typeof resolveName>[2] & {
     onAccount: AccountBase;
-} & SendOptions;
+} & SendTransactionOptions;
 interface SpendOptions extends SpendOptionsType {
 }
 /**
- * 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 declare function transferFunds(fraction: number | string, recipientIdOrName: AensName | Encoded.AccountAddress, options: TransferFundsOptions): ReturnType<typeof send>;
+export declare function transferFunds(fraction: number | string, recipientIdOrName: AensName | Encoded.AccountAddress, options: TransferFundsOptions): ReturnType<typeof sendTransaction>;
 type TransferFundsOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'> & Parameters<typeof resolveName>[2] & {
     onAccount: AccountBase;
-} & SendOptions;
+} & SendTransactionOptions;
 interface TransferFundsOptions extends TransferFundsOptionsType {
 }
 /**
@@ -55,8 +47,8 @@ interface TransferFundsOptions extends TransferFundsOptionsType {
  * @param options - Options
  * @returns Object Transaction
  */
-export declare function payForTransaction(transaction: Encoded.Transaction, options: PayForTransactionOptions): ReturnType<typeof send>;
-interface PayForTransactionOptions extends BuildTxOptions<Tag.PayingForTx, 'payerId' | 'tx'>, SendOptions {
+export declare function payForTransaction(transaction: Encoded.Transaction, options: PayForTransactionOptions): ReturnType<typeof sendTransaction>;
+interface PayForTransactionOptions extends BuildTxOptions<Tag.PayingForTx, 'payerId' | 'tx' | 'onNode'>, SendTransactionOptions {
     onAccount: AccountBase;
 }
 export {};

package/types-legacy/ts4.2/tx/builder/SchemaTypes.d.ts

@@ -0,0 +1,37 @@
+import { Field as OriginalField } from './field-types';
+import { UnionToIntersection } from '../../utils/other';
+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>;
+}
+export {};

package/types-legacy/ts4.2/tx/builder/constants.d.ts

@@ -1,5 +1,6 @@
 import BigNumber from 'bignumber.js';
 export declare const MAX_AUTH_FUN_GAS = 50000;
+export type Int = number | string | BigNumber;
 export type AensName = `${string}.chain`;
 export declare const NAME_TTL = 180000;
 export declare const NAME_MAX_TTL = 36000;
@@ -14,6 +15,32 @@ export declare const NAME_BID_MAX_LENGTH = 12;
 export declare const NAME_BID_RANGES: {
     [k: string]: BigNumber;
 };
+export declare 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 declare 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 declare enum AbiVersion {
+    NoAbi = 0,
+    Sophia = 1,
+    Fate = 3
+}
 /**
  * Enum with tag types
  * @category transaction builder
@@ -24,10 +51,12 @@ export declare enum Tag {
     Account = 10,
     SignedTx = 11,
     SpendTx = 12,
+    Oracle = 20,
     OracleRegisterTx = 22,
     OracleQueryTx = 23,
     OracleResponseTx = 24,
     OracleExtendTx = 25,
+    Name = 30,
     NameClaimTx = 32,
     NamePreclaimTx = 33,
     NameUpdateTx = 34,
@@ -64,8 +93,8 @@ export declare enum Tag {
     NameserviceMtree = 624,
     OraclesMtree = 625,
     AccountsMtree = 626,
-    CompilerSophia = 70,
     GaAttachTx = 80,
     GaMetaTx = 81,
-    PayingForTx = 82
+    PayingForTx = 82,
+    GaMetaTxAuthData = 810
 }

package/types-legacy/ts4.2/tx/builder/field-types/abi-version.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { Tag, ConsensusProtocolVersion, AbiVersion } from '../constants';
+import Node from '../../../Node';
+declare const _default: {
+    _getProtocolDetails(c: ConsensusProtocolVersion, tag: Tag): AbiVersion;
+    serialize(value: AbiVersion | undefined, { tag }: {
+        tag: Tag;
+    }, { consensusProtocolVersion }: {
+        consensusProtocolVersion?: ConsensusProtocolVersion | undefined;
+    }): Buffer;
+    prepare(value: AbiVersion | undefined, { tag }: {
+        tag: Tag;
+    }, options: {
+        consensusProtocolVersion?: ConsensusProtocolVersion;
+        onNode?: Node;
+    }): Promise<AbiVersion | undefined>;
+    deserialize(buffer: Buffer): AbiVersion;
+};
+export default _default;

package/types-legacy/ts4.2/tx/builder/field-types/address.d.ts

@@ -1,22 +1,21 @@
 /// <reference types="node" />
-import { Encoding } from '../../../utils/encoder';
+import { Encoded } from '../../../utils/encoder';
 /**
  * Map of prefix to ID tag constant
  * @see {@link https://github.com/aeternity/protocol/blob/master/serializations.md#the-id-type}
  * @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}
  */
-declare const idTagToEncoding: readonly [
-    Encoding.AccountAddress,
-    Encoding.Name,
-    Encoding.Commitment,
-    Encoding.OracleAddress,
-    Encoding.ContractAddress,
-    Encoding.Channel
+export declare const idTagToEncoding: readonly [
+    Encoded.Encoding.AccountAddress,
+    Encoded.Encoding.Name,
+    Encoded.Encoding.Commitment,
+    Encoded.Encoding.OracleAddress,
+    Encoded.Encoding.ContractAddress,
+    Encoded.Encoding.Channel
 ];
 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>;
 };
-export {};

package/types-legacy/ts4.2/tx/builder/field-types/array.d.ts

@@ -0,0 +1,7 @@
+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[];
+};

package/types-legacy/ts4.2/tx/builder/field-types/boolean.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+declare const _default: {
+    serialize(value: boolean): Buffer;
+    deserialize(buffer: Buffer): boolean;
+};
+export default _default;

package/types-legacy/ts4.2/tx/builder/field-types/coin-amount.d.ts

@@ -1,12 +1,11 @@
 /// <reference types="node" />
-import { Int } from './u-int';
+import { Int } from '../constants';
 import { AE_AMOUNT_FORMATS } from '../../../utils/amount-formatter';
-export interface Options {
-    denomination?: AE_AMOUNT_FORMATS;
-}
 declare const _default: {
     serializeAettos(value: string | undefined): string;
-    serialize(value: Int | undefined, { denomination, ...options }: Options): Buffer;
+    serialize(value: Int | undefined, params: {}, { denomination }: {
+        denomination?: AE_AMOUNT_FORMATS | undefined;
+    }): Buffer;
     deserialize(value: Buffer): string;
 };
 export default _default;