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

package/types-legacy/ts4.2/apis/node/models/parameters.d.ts

@@ -10,8 +10,8 @@ export declare const strategy: OperationQueryParameter;
 export declare const contentType: OperationParameter;
 export declare const body: OperationParameter;
 export declare const body1: OperationParameter;
-export declare const fromParam: OperationQueryParameter;
+export declare const from: OperationQueryParameter;
 export declare const limit: OperationQueryParameter;
-export declare const typeParam: OperationQueryParameter;
+export declare const type: OperationQueryParameter;
 export declare const queryId: OperationURLParameter;
 export declare const name: OperationURLParameter;

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

@@ -72,26 +72,26 @@ export declare function waitForTxConfirm(txHash: Encoded.TxHash, { confirm, onNo
     onNode: Node;
 } & Parameters<typeof awaitHeight>[1]): Promise<number>;
 /**
- * Submit a signed transaction for mining
+ * Signs and submits transaction for mining
  * @category chain
- * @param tx - Transaction to submit
+ * @param txUnsigned - Transaction to sign and submit
  * @param options - Options
  * @param options.onNode - Node to use
  * @param options.onAccount - Account to use
- * @param options.verify - Verify transaction before sending
+ * @param options.verify - Verify transaction before broadcast, throw error if not
  * @param options.waitMined - Ensure that transaction get into block
  * @param options.confirm - Number of micro blocks that should be mined after tx get included
  * @returns Transaction details
  */
-export declare function sendTransaction(tx: Encoded.Transaction, { onNode, onAccount, verify, waitMined, confirm, ...options }: SendTransactionOptions): Promise<SendTransactionReturnType>;
+export declare function sendTransaction(txUnsigned: Encoded.Transaction, { onNode, onAccount, verify, waitMined, confirm, innerTx, ...options }: SendTransactionOptions): Promise<SendTransactionReturnType>;
 type SendTransactionOptionsType = {
     onNode: Node;
-    onAccount?: AccountBase;
+    onAccount: AccountBase;
     verify?: boolean;
     waitMined?: boolean;
     confirm?: boolean | number;
-} & Parameters<typeof poll>[1] & Omit<Parameters<typeof waitForTxConfirm>[1], 'confirm'>;
-interface SendTransactionOptions extends SendTransactionOptionsType {
+} & Parameters<typeof poll>[1] & Omit<Parameters<typeof waitForTxConfirm>[1], 'confirm'> & Parameters<AccountBase['signTransaction']>[1];
+export interface SendTransactionOptions extends SendTransactionOptionsType {
 }
 interface SendTransactionReturnType extends Partial<TransformNodeType<SignedTx>> {
     hash: Encoded.TxHash;
@@ -122,7 +122,7 @@ export declare function getAccount(address: Encoded.AccountAddress | Encoded.Con
  * (default: top of chain)
  * @param options.hash - The block hash on which to obtain the balance for (default: top of chain)
  */
-export declare function getBalance(address: Encoded.AccountAddress | Encoded.ContractAddress, { format, ...options }: {
+export declare function getBalance(address: Encoded.AccountAddress | Encoded.ContractAddress | Encoded.OracleAddress, { format, ...options }: {
     format?: AE_AMOUNT_FORMATS;
 } & Parameters<typeof getAccount>[1]): Promise<string>;
 /**
@@ -179,6 +179,14 @@ export declare function getKeyBlock(hashOrHeight: Encoded.KeyBlockHash | number,
 export declare function getMicroBlockHeader(hash: Encoded.MicroBlockHash, { onNode }: {
     onNode: Node;
 }): Promise<TransformNodeType<MicroBlockHeader>>;
+interface TxDryRunArguments {
+    tx: Encoded.Transaction;
+    accountAddress: Encoded.AccountAddress;
+    top?: number | Encoded.KeyBlockHash | Encoded.MicroBlockHash;
+    txEvents?: any;
+    resolve: Function;
+    reject: Function;
+}
 /**
  * Transaction dry-run
  * @category chain
@@ -191,7 +199,7 @@ export declare function getMicroBlockHeader(hash: Encoded.MicroBlockHash, { onNo
  * @param options.onNode - Node to use
  */
 export declare function txDryRun(tx: Encoded.Transaction, accountAddress: Encoded.AccountAddress, { top, txEvents, combine, onNode, }: {
-    top?: number;
+    top?: TxDryRunArguments['top'];
     txEvents?: boolean;
     combine?: boolean;
     onNode: Node;

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

@@ -1,9 +1,10 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
 import { w3cwebsocket as W3CWebSocket } from 'websocket';
-import { SignTx, ChannelOptions, ChannelState, ChannelHandler, ChannelAction, ChannelStatus, ChannelFsm } from './internal';
+import { Tag } from '../tx/builder/constants';
+import { SignTx, ChannelOptions, ChannelState, ChannelHandler, ChannelAction, ChannelStatus, ChannelFsm, ChannelMessage, ChannelEvents } from './internal';
 import { Encoded } from '../utils/encoder';
-type EventCallback = (...args: any[]) => void;
+import { TxUnpacked } from '../tx/builder/schema.generated';
 /**
  * Channel
  * @example
@@ -31,14 +32,14 @@ export default class Channel {
     _nextRpcMessageId: number;
     _rpcCallbacks: Map<number, (message: object) => void>;
     _fsmId?: Encoded.Bytearray;
-    _messageQueue: object[];
+    _messageQueue: ChannelMessage[];
     _isMessageQueueLocked: boolean;
     _actionQueue: ChannelAction[];
     _isActionQueueLocked: boolean;
     _status: ChannelStatus;
     _fsm: ChannelFsm;
     _websocket: W3CWebSocket;
-    _state?: Encoded.Transaction;
+    _state: Encoded.Transaction | '';
     _options: ChannelOptions;
     _channelId?: Encoded.Channel;
     /**
@@ -99,24 +100,29 @@ export default class Channel {
      * Possible events:
      *
      *   - "error"
+     *   - "stateChanged"
+     *   - "statusChanged"
+     *   - "message"
+     *   - "peerDisconnected"
      *   - "onChainTx"
      *   - "ownWithdrawLocked"
      *   - "withdrawLocked"
      *   - "ownDepositLocked"
      *   - "depositLocked"
+     *   - "channelReestablished"
+     *   - "newContract"
      *
-     * TODO: the event list looks outdated
      *
      * @param eventName - Event name
      * @param callback - Callback function
      */
-    on(eventName: string, callback: EventCallback): void;
+    on<E extends keyof ChannelEvents>(eventName: E, callback: ChannelEvents[E]): void;
     /**
      * Remove event listener function
      * @param eventName - Event name
      * @param callback - Callback function
      */
-    off(eventName: string, callback: EventCallback): void;
+    off<E extends keyof ChannelEvents>(eventName: E, callback: ChannelEvents[E]): void;
     /**
      * Close the connection
      */
@@ -128,7 +134,20 @@ export default class Channel {
     /**
      * Get current state
      */
-    state(): Promise<ChannelState>;
+    state(): Promise<{
+        calls: TxUnpacked & {
+            tag: Tag.CallsMtree;
+        };
+        halfSignedTx?: TxUnpacked & {
+            tag: Tag.SignedTx;
+        };
+        signedTx?: TxUnpacked & {
+            tag: Tag.SignedTx;
+        };
+        trees: TxUnpacked & {
+            tag: Tag.StateTrees;
+        };
+    }>;
     /**
      * Get current round
      *
@@ -191,4 +210,3 @@ export default class Channel {
     shutdown(sign: SignTx): Promise<Encoded.Transaction>;
     static reconnect(options: ChannelOptions, txParams: any): Promise<Channel>;
 }
-export {};

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 { Tag } from '../tx/builder/constants';
+import { TxUnpacked } from '../tx/builder/schema.generated';
 export default class ChannelSpend extends Channel {
     /**
      * Trigger a transfer update
@@ -61,7 +63,9 @@ export default class ChannelSpend extends Channel {
     poi({ accounts, contracts }: {
         accounts: Encoded.AccountAddress[];
         contracts?: Encoded.ContractAddress[];
-    }): Promise<Encoded.Poi>;
+    }): Promise<TxUnpacked & {
+        tag: Tag.TreesPoi;
+    }>;
     /**
      * Get balances
      *

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

@@ -2,6 +2,23 @@ import BigNumber from 'bignumber.js';
 import type Channel from './Base';
 import { Encoded } from '../utils/encoder';
 import { BaseError } from '../utils/errors';
+export interface ChannelEvents {
+    statusChanged: (status: ChannelStatus) => void;
+    stateChanged: (tx: Encoded.Transaction | '') => void;
+    depositLocked: () => void;
+    ownDepositLocked: () => void;
+    withdrawLocked: () => void;
+    ownWithdrawLocked: () => void;
+    peerDisconnected: () => void;
+    channelReestablished: () => void;
+    error: (error: Error) => void;
+    onChainTx: (tx: Encoded.Transaction, details: {
+        info: string;
+        type: string;
+    }) => void;
+    message: (message: string | Object) => void;
+    newContract: (contractAddress: Encoded.ContractAddress) => void;
+}
 export interface ChannelAction {
     guard: (channel: Channel, state?: ChannelFsm) => boolean;
     action: (channel: Channel, state?: ChannelFsm) => ChannelFsm;
@@ -92,10 +109,13 @@ interface ChannelMessageError {
     ];
     request: ChannelMessage;
 }
-export declare function emit(channel: Channel, ...args: any[]): void;
+export declare function emit<E extends keyof ChannelEvents>(channel: Channel, ...args: [
+    E,
+    ...Parameters<ChannelEvents[E]>
+]): void;
 export type ChannelStatus = 'connecting' | 'connected' | 'accepted' | 'halfSigned' | 'signed' | 'open' | 'closing' | 'closed' | 'died' | 'disconnected';
 export declare function changeStatus(channel: Channel, newStatus: ChannelStatus): void;
-export declare function changeState(channel: Channel, newState: Encoded.Transaction): void;
+export declare function changeState(channel: Channel, newState: Encoded.Transaction | ''): void;
 export declare function notify(channel: Channel, method: string, params?: object): void;
 export declare function enqueueAction(channel: Channel, guard: ChannelAction['guard'], action: () => {
     handler: ChannelHandler;

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

@@ -7,39 +7,19 @@
  */
 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/builder';
 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 { ContractCallObject as NodeContractCallObject, Event as NodeEvent } from '../apis/node';
+import CompilerBase, { Aci } from './compiler/Base';
 import Node, { TransformNodeType } from '../Node';
+import { txDryRun, sendTransaction, SendTransactionOptions } 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[];
-}
+import { TxUnpacked } from '../tx/builder/schema.generated';
 interface Event extends NodeEvent {
     address: Encoded.ContractAddress;
     data: Encoded.ContractBytearray;
 }
-export interface ContractCallObject extends NodeContractCallObject {
+export interface ContractCallObject extends TransformNodeType<NodeContractCallObject> {
     returnValue: Encoded.ContractBytearray;
     log: Event[];
 }
@@ -51,11 +31,13 @@ interface DecodedEvent {
         address: Encoded.ContractAddress;
     };
 }
-type TxData = Awaited<ReturnType<typeof send>>;
+type TxData = Awaited<ReturnType<typeof sendTransaction>>;
 interface SendAndProcessReturnType {
-    result?: TransformNodeType<ContractCallObject>;
+    result?: ContractCallObject;
     hash: TxData['hash'];
-    tx: Awaited<ReturnType<any>>;
+    tx: TxUnpacked & {
+        tag: Tag.ContractCallTx | Tag.ContractCreateTx;
+    };
     txData: TxData;
     rawTx: Encoded.Transaction;
 }
@@ -63,15 +45,13 @@ export interface ContractMethodsBase {
     [key: string]: (...args: any[]) => any;
 }
 type MethodsToContractApi<M extends ContractMethodsBase> = {
-    [Name in keyof M]: M[Name] extends (...args: infer Args) => infer Ret ? (...args: [
+    [Name in keyof M]: M[Name] extends (...args: infer Args) => any ? (...args: [
         ...Args,
         ...[
         ] | [
             Name extends 'init' ? Parameters<Contract<M>['$deploy']>[1] : Parameters<Contract<M>['$call']>[2]
         ]
-    ]) => Promise<Awaited<ReturnType<Contract<M>['$call']>> & {
-        decodedResult?: Ret;
-    }> : never;
+    ]) => ReturnType<Contract<M>['$call']> : never;
 };
 type ContractWithMethods<M extends ContractMethodsBase> = Contract<M> & MethodsToContractApi<M>;
 type MethodNames<M extends ContractMethodsBase> = keyof M & string | 'init';
@@ -79,6 +59,15 @@ type MethodParameters<M extends ContractMethodsBase, Fn extends MethodNames<M>>
     init: any;
 } ? Parameters<M['init']> : [
 ] : Parameters<M[Fn]>;
+interface GetContractNameByEventOptions {
+    contractAddressToName?: {
+        [key: string]: string;
+    };
+}
+interface GetCallResultByHashReturnType<M extends ContractMethodsBase, Fn extends MethodNames<M>> {
+    decodedResult: ReturnType<M[Fn]>;
+    decodedEvents?: ReturnType<Contract<M>['$decodeEvents']>;
+}
 /**
  * Generate contract ACI object with predefined js methods for contract usage - can be used for
  * creating a reference to already deployed contracts
@@ -97,73 +86,28 @@ type MethodParameters<M extends ContractMethodsBase, Fn extends MethodNames<M>>
  * stateful or not
  */
 declare class Contract<M extends ContractMethodsBase> {
-    /**
-     * 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 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
-     * @returns Signature
-     * @example
-     * ```js
-     * const aeSdk = new AeSdk({ ... })
-     * const contract = await aeSdk.initializeContract({ address: 'ct_asd2ks...' })
-     * const aensName = 'example.chain'
-     * const onAccount = new MemoryAccount(...) // Sign with a specific account
-     * // Preclaim signature
-     * const preclaimSig = await contract.$createDelegationSignature([], { onAccount })
-     * // Claim, transfer and revoke signature
-     * const aensDelegationSig = await contract
-     *   .$createDelegationSignature([aensName], { onAccount })
-     * ```
-     * @example
-     * ```js
-     * const aeSdk = new AeSdk({ ... })
-     * const contract = await aeSdk.initializeContract({ address: 'ct_asd2ks...' })
-     * const oracleQueryId = 'oq_...'
-     * const onAccount = new MemoryAccount(...) // Sign with a specific account
-     * // Oracle register and extend signature
-     * const oracleDelegationSig = await contract.$createDelegationSignature([], { onAccount })
-     * // Oracle respond signature
-     * const respondSig = await contract
-     *   .$createDelegationSignature([oracleQueryId], { onAccount, omitAddress: true })
-     * ```
-     */
-    $createDelegationSignature(ids?: Array<Encoded.Any | AensName>, _options?: {
-        omitAddress?: boolean;
-        onAccount?: AccountBase;
-    }): Promise<Uint8Array>;
+    #private;
     /**
      * Compile contract
      * @returns bytecode
      */
     $compile(): Promise<Encoded.ContractBytearray>;
-    protected _handleCallError({ returnType, returnValue }: {
-        returnType: ContractCallReturnType;
-        returnValue: Encoded.ContractBytearray;
-    }, transaction: string): void;
-    protected _sendAndProcess(tx: Encoded.Transaction, options: any): Promise<SendAndProcessReturnType>;
-    _estimateGas<Fn extends MethodNames<M>>(name: Fn, params: MethodParameters<M, Fn>, options?: object): Promise<number>;
+    $getCallResultByTxHash<Fn extends MethodNames<M>>(hash: Encoded.TxHash, fnName: Fn, options?: Parameters<Contract<M>['$decodeEvents']>[1]): Promise<GetCallResultByHashReturnType<M, Fn> & {
+        result: ContractCallObject;
+    }>;
+    _estimateGas<Fn extends MethodNames<M>>(name: Fn, params: MethodParameters<M, Fn>, options?: Omit<Parameters<Contract<M>['$call']>[2], 'callStatic'>): Promise<number>;
     /**
      * Deploy contract
      * @param params - Contract init function arguments array
      * @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>;
     /**
      * Call contract function
      * @param fn - Function name
@@ -171,23 +115,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<{
-        decodedResult?: any;
-        decodedEvents?: ReturnType<Contract<M>['$decodeEvents']>;
-    } & SendAndProcessReturnType>;
-    /**
-     * @param ctAddress - Contract address that emitted event
-     * @param nameHash - Hash of emitted event name
-     * @param options - Options
-     * @returns Contract name
-     * @throws {@link MissingEventDefinitionError}
-     * @throws {@link AmbiguousEventDefinitionError}
-     */
-    protected _getContractNameByEvent(ctAddress: Encoded.ContractAddress, nameHash: BigInt, { contractAddressToName }: {
-        contractAddressToName?: {
-            [key: string]: string;
-        };
-    }): string;
+    $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<SendTransactionOptions, 'onAccount' | 'onNode'> & Omit<Parameters<typeof txDryRun>[2], 'onNode'> & {
+        onAccount?: AccountBase;
+        onNode?: Node;
+        callStatic?: boolean;
+    }): Promise<SendAndProcessReturnType & Partial<GetCallResultByHashReturnType<M, Fn>>>;
     /**
      * Decode Events
      * @param events - Array of encoded events (callRes.result.log)
@@ -196,8 +128,8 @@ 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'> & {
+    } & GetContractNameByEventOptions): DecodedEvent[];
+    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 +137,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,74 @@
+import { Encoded } from '../../utils/encoder';
+interface FunctionAci {
+    arguments: any[];
+    name: string;
+    payable: boolean;
+    returns: any;
+    stateful: boolean;
+}
+export type Aci = Array<{
+    contract?: {
+        name: string;
+        event?: any;
+        functions: FunctionAci[];
+    };
+}>;
+/**
+ * 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>;
+}