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

package/types-legacy/ts4.2/channel/Contract.d.ts

@@ -1,4 +1,5 @@
 import BigNumber from 'bignumber.js';
+import { AbiVersion, VmVersion } from '../tx/builder/constants';
 import { SignTx, ChannelState, ChannelOptions } from './internal';
 import { Encoded } from '../utils/encoder';
 import { ContractCallReturnType } from '../apis/node';
@@ -7,7 +8,7 @@ import ChannelSpend from './Spend';
 interface CallContractOptions {
     amount?: number | BigNumber;
     callData?: Encoded.ContractBytearray;
-    abiVersion?: number;
+    abiVersion?: AbiVersion;
     contract?: Encoded.ContractAddress;
     returnValue?: any;
     gasUsed?: number | BigNumber;
@@ -18,13 +19,13 @@ interface CallContractOptions {
     returnType?: ContractCallReturnType;
 }
 interface Contract {
-    abiVersion: number;
+    abiVersion: AbiVersion;
     active: boolean;
     deposit: number | BigNumber;
     id: string;
     ownerId: string;
     referrerIds: string[];
-    vmVersion: number;
+    vmVersion: VmVersion;
 }
 export default class ChannelContract extends ChannelSpend {
     static initialize(options: ChannelOptions): Promise<ChannelContract>;
@@ -66,8 +67,8 @@ export default class ChannelContract extends ChannelSpend {
         code: Encoded.ContractBytearray;
         callData: Encoded.ContractBytearray;
         deposit: number | BigNumber;
-        vmVersion: number;
-        abiVersion: number;
+        vmVersion: VmVersion;
+        abiVersion: AbiVersion;
     }, sign: SignTx): Promise<{
         accepted: boolean;
         signedTx: Encoded.Transaction;
@@ -148,7 +149,7 @@ export default class ChannelContract extends ChannelSpend {
         amount: number;
         callData: Encoded.ContractBytearray;
         contract: Encoded.ContractAddress;
-        abiVersion: number;
+        abiVersion: AbiVersion;
         gasLimit?: number;
         gasPrice?: number;
     }, sign: SignTx, { onOnChainTx }?: Pick<ChannelState, 'onOnChainTx'>): Promise<{
@@ -189,7 +190,7 @@ export default class ChannelContract extends ChannelSpend {
         amount: number;
         callData: Encoded.ContractBytearray;
         contract: Encoded.ContractAddress;
-        abiVersion: number;
+        abiVersion: AbiVersion;
     }): Promise<CallContractOptions>;
     /**
      * Get contract call result

package/types-legacy/ts4.2/channel/Spend.d.ts

@@ -2,6 +2,8 @@ import BigNumber from 'bignumber.js';
 import { SignTx, ChannelState } from './internal';
 import { Encoded } from '../utils/encoder';
 import Channel from './Base';
+import { unpackTx } from '../tx/builder';
+import { Tag } from '../tx/builder/constants';
 export default class ChannelSpend extends Channel {
     /**
      * Trigger a transfer update
@@ -61,7 +63,7 @@ export default class ChannelSpend extends Channel {
     poi({ accounts, contracts }: {
         accounts: Encoded.AccountAddress[];
         contracts?: Encoded.ContractAddress[];
-    }): Promise<Encoded.Poi>;
+    }): Promise<ReturnType<any>>;
     /**
      * Get balances
      *

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

@@ -8,33 +8,15 @@
 import { Encoder as Calldata } from '@aeternity/aepp-calldata';
 import { Tag, AensName } from '../tx/builder/constants';
 import { unpackTx } from '../tx/builder';
-import { send } from '../spend';
+import { BuildTxOptions } from '../tx';
+import { send, SendOptions } from '../spend';
 import { Encoded } from '../utils/encoder';
-import { Aci as BaseAci } from '../apis/compiler';
 import { ContractCallObject as NodeContractCallObject, ContractCallReturnType, Event as NodeEvent } from '../apis/node';
-import CompilerHttp from './CompilerHttp';
+import CompilerBase, { Aci } from './compiler/Base';
 import Node, { TransformNodeType } from '../Node';
+import { txDryRun } from '../chain';
 import AccountBase from '../account/Base';
-interface FunctionACI {
-    arguments: any[];
-    name: string;
-    payable: boolean;
-    returns: string;
-    stateful: boolean;
-}
-interface Aci extends BaseAci {
-    encodedAci: {
-        contract: {
-            name: string;
-            event: any;
-            kind: string;
-            state: any;
-            type_defs: any[];
-            functions: FunctionACI[];
-        };
-    };
-    externalEncodedAci: any[];
-}
+type FunctionAci = Aci['encodedAci']['contract']['functions'][0];
 interface Event extends NodeEvent {
     address: Encoded.ContractAddress;
     data: Encoded.ContractBytearray;
@@ -145,7 +127,7 @@ declare class Contract<M extends ContractMethodsBase> {
         returnType: ContractCallReturnType;
         returnValue: Encoded.ContractBytearray;
     }, transaction: string): void;
-    protected _sendAndProcess(tx: Encoded.Transaction, options: any): Promise<SendAndProcessReturnType>;
+    protected _sendAndProcess(tx: Encoded.Transaction, options: SendOptions): Promise<SendAndProcessReturnType>;
     _estimateGas<Fn extends MethodNames<M>>(name: Fn, params: MethodParameters<M, Fn>, options?: object): Promise<number>;
     /**
      * Deploy contract
@@ -153,17 +135,18 @@ declare class Contract<M extends ContractMethodsBase> {
      * @param options - Options
      * @returns deploy info
      */
-    $deploy(params: MethodParameters<M, 'init'>, options?: Parameters<Contract<M>['$call']>[2] & Parameters<Contract<M>['_sendAndProcess']>[1]): Promise<Omit<SendAndProcessReturnType, 'hash'> & {
+    $deploy(params: MethodParameters<M, 'init'>, options?: Parameters<Contract<M>['$call']>[2] & Partial<BuildTxOptions<Tag.ContractCreateTx, 'ownerId' | 'code' | 'callData'>>): Promise<Omit<SendAndProcessReturnType, 'hash'> & {
         transaction?: Encoded.TxHash;
         owner?: Encoded.AccountAddress;
         address?: Encoded.ContractAddress;
+        decodedEvents?: ReturnType<Contract<M>['$decodeEvents']>;
     }>;
     /**
      * Get function schema from contract ACI object
      * @param name - Function name
      * @returns function ACI
      */
-    protected _getFunctionACI(name: string): Partial<FunctionACI>;
+    protected _getFunctionACI(name: string): Partial<FunctionAci>;
     /**
      * Call contract function
      * @param fn - Function name
@@ -171,7 +154,11 @@ declare class Contract<M extends ContractMethodsBase> {
      * @param options - Array of function arguments
      * @returns CallResult
      */
-    $call<Fn extends MethodNames<M>>(fn: Fn, params: MethodParameters<M, Fn>, options?: object): Promise<{
+    $call<Fn extends MethodNames<M>>(fn: Fn, params: MethodParameters<M, Fn>, options?: Partial<BuildTxOptions<Tag.ContractCallTx, 'callerId' | 'contractId' | 'callData'>> & Parameters<Contract<M>['$decodeEvents']>[1] & Omit<Parameters<Contract<M>['_sendAndProcess']>[1], 'onAccount' | 'onNode'> & Omit<Parameters<typeof txDryRun>[2], 'onNode'> & {
+        onAccount?: AccountBase;
+        onNode?: Node;
+        callStatic?: boolean;
+    }): Promise<{
         decodedResult?: any;
         decodedEvents?: ReturnType<Contract<M>['$decodeEvents']>;
     } & SendAndProcessReturnType>;
@@ -197,7 +184,7 @@ declare class Contract<M extends ContractMethodsBase> {
     $decodeEvents(events: Event[], { omitUnknown, ...opt }?: {
         omitUnknown?: boolean;
     } & Parameters<Contract<M>['_getContractNameByEvent']>[2]): DecodedEvent[];
-    static initialize<M extends ContractMethodsBase>({ onCompiler, onNode, sourceCode, bytecode, aci, address, fileSystem, validateBytecode, ...otherOptions }: Omit<ConstructorParameters<typeof Contract>[0], 'aci' | 'address'> & {
+    static initialize<M extends ContractMethodsBase>({ onCompiler, onNode, bytecode, aci, address, sourceCodePath, sourceCode, fileSystem, validateBytecode, ...otherOptions }: Omit<ConstructorParameters<typeof Contract>[0], 'aci' | 'address'> & {
         validateBytecode?: boolean;
         aci?: Aci;
         address?: Encoded.ContractAddress | AensName;
@@ -205,29 +192,17 @@ declare class Contract<M extends ContractMethodsBase> {
     _aci: Aci;
     _name: string;
     _calldata: Calldata;
-    $options: {
-        sourceCode?: string;
-        bytecode?: Encoded.ContractBytearray;
-        address?: Encoded.ContractAddress;
-        onCompiler: CompilerHttp;
-        onNode: Node;
-        omitUnknown?: boolean;
-        contractAddressToName?: {
-            [key: string]: string;
-        };
-        [key: string]: any;
-    };
+    $options: Omit<ConstructorParameters<typeof Contract>[0], 'aci'>;
     constructor({ aci, ...otherOptions }: {
-        onAccount?: AccountBase;
-        onCompiler: CompilerHttp;
+        onCompiler?: CompilerBase;
         onNode: Node;
-        sourceCode?: string;
         bytecode?: Encoded.ContractBytearray;
         aci: Aci;
         address?: Encoded.ContractAddress;
-        fileSystem?: Record<string, string>;
-        [key: string]: any;
-    });
+        sourceCodePath?: Parameters<CompilerBase['compile']>[0];
+        sourceCode?: Parameters<CompilerBase['compileBySourceCode']>[0];
+        fileSystem?: Parameters<CompilerBase['compileBySourceCode']>[1];
+    } & Parameters<Contract<M>['$deploy']>[1]);
 }
 interface ContractWithMethodsClass {
     new <M extends ContractMethodsBase>(options: ConstructorParameters<typeof Contract>[0]): ContractWithMethods<M>;

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

@@ -0,0 +1,81 @@
+import { Encoded } from '../../utils/encoder';
+import { Aci as BaseAci } from '../../apis/compiler';
+interface FunctionAci {
+    arguments: any[];
+    name: string;
+    payable: boolean;
+    returns: string;
+    stateful: boolean;
+}
+export interface Aci extends BaseAci {
+    encodedAci: {
+        contract: {
+            name: string;
+            event: any;
+            kind: string;
+            state: any;
+            type_defs: any[];
+            functions: FunctionAci[];
+        };
+    };
+    externalEncodedAci: any[];
+}
+/**
+ * A base class for all compiler implementations
+ */
+export default abstract class CompilerBase {
+    /**
+     * Compile contract by contract's path
+     * Available only in Node.js
+     * @param path - Path to contract source code
+     * @returns ACI and bytecode
+     */
+    abstract compile(path: string): Promise<{
+        bytecode: Encoded.ContractBytearray;
+        aci: Aci;
+    }>;
+    /**
+     * Compile contract by contract's source code
+     * @param sourceCode - Contract source code as string
+     * @param fileSystem - A map of contract filename to the corresponding contract source code to
+     * include into the main contract
+     * @example
+     * ```js
+     * {
+     *   'library.aes': 'namespace TestLib =\n  function sum(x: int, y: int) : int = x + y'
+     * }
+     * ```
+     * @returns ACI and bytecode
+     */
+    abstract compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<{
+        bytecode: Encoded.ContractBytearray;
+        aci: Aci;
+    }>;
+    /**
+     * Verify that a contract bytecode is the result of compiling the given source code
+     * Available only in Node.js
+     * @param bytecode - Contract bytecode to verify
+     * @param path - Path to contract source code
+     * @returns ACI and bytecode
+     */
+    abstract validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean>;
+    /**
+     * Verify that a contract bytecode is the result of compiling the given source code
+     * @param bytecode - Contract bytecode to verify
+     * @param sourceCode - Contract source code as string
+     * @param fileSystem - A map of contract filename to the corresponding contract source code to
+     * include into the main contract
+     * @example
+     * ```js
+     * {
+     *   'library.aes': 'namespace TestLib =\n  function sum(x: int, y: int) : int = x + y'
+     * }
+     * ```
+     */
+    abstract validateBySourceCode(bytecode: Encoded.ContractBytearray, sourceCode: string, fileSystem?: Record<string, string>): Promise<boolean>;
+    /**
+     * @returns Compiler version
+     */
+    abstract version(): Promise<string>;
+}
+export {};

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

@@ -0,0 +1,23 @@
+import CompilerBase, { Aci } from './Base';
+import { Encoded } from '../../utils/encoder';
+/**
+ * A wrapper around aesophia_cli, available only in Node.js
+ * Assumes that `escript` is available in PATH.
+ */
+export default class CompilerCli extends CompilerBase {
+    #private;
+    constructor(compilerPath?: string, { ignoreVersion }?: {
+        ignoreVersion?: boolean;
+    });
+    compile(path: string): Promise<{
+        bytecode: Encoded.ContractBytearray;
+        aci: Aci;
+    }>;
+    compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<{
+        bytecode: Encoded.ContractBytearray;
+        aci: Aci;
+    }>;
+    validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean>;
+    validateBySourceCode(bytecode: Encoded.ContractBytearray, sourceCode: string, fileSystem?: Record<string, string>): Promise<boolean>;
+    version(): Promise<string>;
+}

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/ga.d.ts

@@ -5,9 +5,10 @@ import { Tag } from '../tx/builder/constants';
 import { BuildTxOptions } from '../tx';
 import { Encoded } from '../utils/encoder';
 import AccountBase from '../account/Base';
+import Contract from './Contract';
 import { SendOptions } from '../spend';
 import Node from '../Node';
-import CompilerHttp from './CompilerHttp';
+import CompilerBase from './compiler/Base';
 /**
  * Convert current account to GA
  * @category contract
@@ -17,15 +18,15 @@ 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'>, SendOptions, Pick<Parameters<typeof Contract.initialize>[0], 'bytecode' | 'aci' | 'sourceCodePath' | 'sourceCode' | 'fileSystem'> {
     onAccount: AccountBase;
-    onCompiler: CompilerHttp;
+    onCompiler: CompilerBase;
     onNode: Node;
     gasLimit?: number;
 }

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

@@ -0,0 +1,39 @@
+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 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/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,31 @@ export declare const NAME_BID_MAX_LENGTH = 12;
 export declare const NAME_BID_RANGES: {
     [k: string]: BigNumber;
 };
+export declare enum ConsensusProtocolVersion {
+    Iris = 5
+}
+/**
+ * @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 +50,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,7 +92,6 @@ export declare enum Tag {
     NameserviceMtree = 624,
     OraclesMtree = 625,
     AccountsMtree = 626,
-    CompilerSophia = 70,
     GaAttachTx = 80,
     GaMetaTx = 81,
     PayingForTx = 82

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

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Tag, ConsensusProtocolVersion, AbiVersion } from '../constants';
+declare const _default: {
+    serialize(value: AbiVersion | undefined, { tag, consensusProtocolVersion }: {
+        tag: Tag;
+        consensusProtocolVersion: ConsensusProtocolVersion;
+    }): Buffer;
+    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: 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,5 +1,5 @@
 /// <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;

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

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+import { ConsensusProtocolVersion, VmVersion, AbiVersion } from '../constants';
+export declare const ProtocolToVmAbi: {
+    readonly 5: {
+        readonly 'contract-create': {
+            readonly vmVersion: readonly [
+                VmVersion.Fate2
+            ];
+            readonly abiVersion: readonly [
+                AbiVersion.Fate
+            ];
+        };
+        readonly 'contract-call': {
+            readonly vmVersion: readonly [
+            ];
+            readonly abiVersion: readonly [
+                AbiVersion.Fate,
+                AbiVersion.Sophia
+            ];
+        };
+        readonly 'oracle-call': {
+            readonly vmVersion: readonly [
+            ];
+            readonly abiVersion: readonly [
+                AbiVersion.NoAbi,
+                AbiVersion.Sophia
+            ];
+        };
+    };
+};
+export interface CtVersion {
+    vmVersion: VmVersion;
+    abiVersion: AbiVersion;
+}
+export declare function getProtocolDetails(protocolVersion: ConsensusProtocolVersion, type: 'contract-create' | 'contract-call' | 'oracle-call'): CtVersion;
+declare const _default: {
+    serialize(value: CtVersion | undefined, { consensusProtocolVersion }: {
+        consensusProtocolVersion: ConsensusProtocolVersion;
+    }): Buffer;
+    deserialize(buffer: Buffer): CtVersion;
+};
+export default _default;