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

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

@@ -1,34 +1,19 @@
-/**
- * Transaction methods
- *
- * This is implementation of [Tx](api/tx.md) relays
- * the creation of transactions to {@link Node}.
- * These methods provide ability to create native transactions.
- */
-import BigNumber from 'bignumber.js';
-import { ABI_VERSIONS, CtVersion } from './builder/schema';
 import { Tag } from './builder/constants';
 import Node from '../Node';
 import { Encoded } from '../utils/encoder';
 import { buildTx as syncBuildTx } from './builder/index';
 import { AE_AMOUNT_FORMATS } from '../utils/amount-formatter';
-type Int = number | string | BigNumber;
 export type BuildTxOptions<TxType extends Tag, OmitFields extends string> = Omit<Parameters<any>[1], OmitFields>;
 /**
  * @category transaction builder
  */
-export declare function _buildTx<TxType extends Tag>(txType: TxType, { denomination, absoluteTtl, ..._params }: Omit<Parameters<any>[0], 'fee' | 'nonce' | 'ttl' | 'ctVersion' | 'abiVersion'> & {
-    onNode: Node;
-    fee?: Int;
-    nonce?: number;
-    ttl?: number;
+export declare function _buildTx<TxType extends Tag>(txType: TxType, { denomination, absoluteTtl, strategy, onNode, ..._params }: Omit<Parameters<any>[0], 'tag' | 'nonce' | 'ttl'> & {
     denomination?: AE_AMOUNT_FORMATS;
     absoluteTtl?: boolean;
+    strategy?: 'continuity' | 'max';
+    onNode: Node;
+    ttl?: number;
+    nonce?: number;
 } & (TxType extends Tag.OracleExtendTx | Tag.OracleResponseTx ? {
     callerId: Encoded.AccountAddress;
-} : {}) & (TxType extends Tag.ContractCreateTx | Tag.GaAttachTx ? {
-    ctVersion?: CtVersion;
-} : {}) & (TxType extends Tag.ContractCallTx | Tag.OracleRegisterTx ? {
-    abiVersion?: ABI_VERSIONS;
 } : {})): Promise<Encoded.Transaction>;
-export {};

package/types-legacy/ts4.2/tx/validator.d.ts

@@ -1,5 +1,4 @@
-import { Tag } from './builder/constants';
-import { Encoded } from '../utils/encoder';
+import { unpackTx } from './builder';
 import Node from '../Node';
 export interface ValidatorResult {
     message: string;
@@ -8,13 +7,12 @@ export interface ValidatorResult {
 }
 /**
  * Transaction Validator
- * This function validates some of transaction properties,
+ * This function validates some transaction properties,
  * to make sure it can be posted it to the chain
  * @category transaction builder
  * @param transaction - Base64Check-encoded transaction
  * @param nodeNotCached - Node to validate transaction against
- * @param parentTxTypes - Types of parent transactions
  * @returns Array with verification errors
  * @example const errors = await verifyTransaction(transaction, node)
  */
-export default function verifyTransaction(transaction: Encoded.Transaction | Encoded.Poi, nodeNotCached: Node, parentTxTypes?: Tag[]): Promise<ValidatorResult[]>;
+export default function verifyTransaction(transaction: Parameters<typeof unpackTx>[0], nodeNotCached: Node): Promise<ValidatorResult[]>;

package/types-legacy/ts4.2/utils/errors.d.ts

@@ -1,4 +1,5 @@
 import BigNumber from 'bignumber.js';
+import { Int } from '../tx/builder/constants';
 /**
  * aepp-sdk originated error
  * @category exception
@@ -70,7 +71,7 @@ export declare class WalletError extends BaseError {
  * @category exception
  */
 export declare class ArgumentError extends BaseError {
-    constructor(argumentName: string, requirement: string, argumentValue: any);
+    constructor(argumentName: string, requirement: unknown, argumentValue: unknown);
 }
 /**
  * @category exception
@@ -317,7 +318,7 @@ export declare class NoSuchContractFunctionError extends ContractError {
  * @category exception
  */
 export declare class NotPayableFunctionError extends ContractError {
-    constructor(amount: string, fn: string);
+    constructor(amount: Int, fn: string);
 }
 /**
  * @category exception
@@ -442,12 +443,6 @@ export declare class TagNotFoundError extends TransactionError {
 export declare class TxNotInChainError extends TransactionError {
     constructor(txHash: string);
 }
-/**
- * @category exception
- */
-export declare class UnknownTxError extends TransactionError {
-    constructor(message: string);
-}
 /**
  * @category exception
  */

package/types-legacy/ts4.2/utils/other.d.ts

@@ -14,7 +14,7 @@ export declare const mapObject: <InputV, OutputV>(object: {
 ]) => {
     [k: string]: OutputV;
 };
-export declare const concatBuffers: (list: readonly Uint8Array[], totalLength?: number | undefined) => Buffer;
+export declare const concatBuffers: typeof Buffer.concat;
 /**
  * Object key type guard
  * @param key - Maybe object key

package/types-legacy/ts4.5/AeSdkBase.d.ts

@@ -1,7 +1,7 @@
 import Node from './Node';
 import AccountBase from './account/Base';
 import { Encoded } from './utils/encoder';
-import CompilerHttp from './contract/CompilerHttp';
+import CompilerBase from './contract/compiler/Base';
 import AeSdkMethods, { OnAccount } from './AeSdkMethods';
 type NodeInfo = Awaited<ReturnType<Node['getNodeInfo']>> & {
     name: string;
@@ -25,7 +25,7 @@ export default class AeSdkBase extends AeSdkMethods {
             instance: Node;
         }>;
     });
-    get compilerApi(): CompilerHttp;
+    get compilerApi(): CompilerBase;
     get api(): Node;
     /**
      * Add Node
@@ -85,7 +85,7 @@ export default class AeSdkBase extends AeSdkMethods {
     _getOptions(): {
         onNode: Node;
         onAccount: AccountBase;
-        onCompiler: CompilerHttp;
+        onCompiler: CompilerBase;
     };
 }
 export {};

package/types-legacy/ts4.5/AeSdkMethods.d.ts

@@ -10,7 +10,7 @@ import Node from './Node';
 import { Tag } from './tx/builder/constants';
 import AccountBase from './account/Base';
 import { Encoded } from './utils/encoder';
-import CompilerHttp from './contract/CompilerHttp';
+import CompilerBase from './contract/compiler/Base';
 export type OnAccount = Encoded.AccountAddress | AccountBase | undefined;
 export declare function getValueOrErrorProxy<Value extends object>(valueCb: () => Value): Value;
 declare const methods: {
@@ -105,9 +105,8 @@ declare class AeSdkMethods {
     buildTx<TxType extends Tag>(txType: TxType, options: Omit<Parameters<any>[1], 'onNode'> & {
         onNode?: Node;
     }): Promise<Encoded.Transaction>;
-    initializeContract<Methods extends ContractMethodsBase>(options?: Omit<Parameters<typeof Contract.initialize>[0], 'onNode' | 'onCompiler'> & {
+    initializeContract<Methods extends ContractMethodsBase>(options?: Omit<Parameters<typeof Contract.initialize>[0], 'onNode'> & {
         onNode?: Node;
-        onCompiler?: CompilerHttp;
     }): Promise<Contract<Methods>>;
 }
 type RequiredKeys<T> = {
@@ -120,7 +119,7 @@ type OptionalIfNotRequired<T extends [
 type MakeOptional<Options> = OptionalIfNotRequired<[
     Omit<Options, 'onNode' | 'onCompiler' | 'onAccount'> & {
         onNode?: Node;
-        onCompiler?: CompilerHttp;
+        onCompiler?: CompilerBase;
         onAccount?: OnAccount;
     }
 ]>;

package/types-legacy/ts4.5/Node.d.ts

@@ -1,5 +1,6 @@
 import { Node as NodeApi, NodeOptionalParams } from './apis/node';
 import { Encoded } from './utils/encoder';
+import { ConsensusProtocolVersion } from './tx/builder/constants';
 declare const bigIntPropertyNames: readonly [
     "balance",
     "queryFee",
@@ -24,7 +25,6 @@ declare const numberPropertyNames: readonly [
     "nextNonce",
     "height",
     "blockHeight",
-    "top",
     "topBlockHeight",
     "ttl",
     "nameTtl",
@@ -50,7 +50,7 @@ export type TransformNodeType<Type> = Type extends (...args: infer Args) => infe
 ] : Type extends Array<infer Item> ? Array<TransformNodeType<Item>> : Type extends Promise<infer T> ? Promise<TransformNodeType<T>> : Type extends {
     [P in any]: any;
 } ? {
-    [Property in keyof Type]: Property extends BigIntPropertyNames ? PreserveOptional<bigint, Type[Property]> : Property extends NumberPropertyNames ? PreserveOptional<number, Type[Property]> : Property extends 'txHash' ? PreserveOptional<Encoded.TxHash, Type[Property]> : TransformNodeType<Type[Property]>;
+    [Property in keyof Type]: Property extends BigIntPropertyNames ? PreserveOptional<bigint, Type[Property]> : Property extends NumberPropertyNames ? PreserveOptional<number, Type[Property]> : Property extends 'txHash' ? PreserveOptional<Encoded.TxHash, Type[Property]> : Property extends 'bytecode' ? PreserveOptional<Encoded.ContractBytearray, Type[Property]> : TransformNodeType<Type[Property]>;
 } : Type;
 type NodeTransformedApi = new (...args: ConstructorParameters<typeof NodeApi>) => {
     [Name in keyof InstanceType<typeof NodeApi>]: Name extends 'pipeline' | 'sendRequest' | 'sendOperationRequest' ? NodeApi[Name] : TransformNodeType<NodeApi[Name]>;
@@ -59,7 +59,7 @@ export interface NodeInfo {
     url: string;
     nodeNetworkId: string;
     version: string;
-    consensusProtocolVersion: number;
+    consensusProtocolVersion: ConsensusProtocolVersion;
 }
 declare const Node_base: NodeTransformedApi;
 export default class Node extends Node_base {

package/types-legacy/ts4.5/account/Base.d.ts

@@ -1,6 +1,6 @@
 import { Encoded } from '../utils/encoder';
 import Node from '../Node';
-import CompilerHttp from '../contract/CompilerHttp';
+import CompilerBase from '../contract/compiler/Base';
 /**
  * Account is one of the three basic building blocks of an
  * {@link AeSdk} and provides access to a signing key pair.
@@ -24,7 +24,7 @@ export default abstract class AccountBase {
             args?: any[];
         };
         onNode?: Node;
-        onCompiler?: CompilerHttp;
+        onCompiler?: CompilerBase;
         aeppOrigin?: string;
         aeppRpcClientId?: string;
     }): Promise<Encoded.Transaction>;

package/types-legacy/ts4.5/aens.d.ts

@@ -196,7 +196,7 @@ export declare function aensPreclaim(name: AensName, options: AensPreclaimOption
     commitmentId: string;
     claim: (opts?: Parameters<typeof aensClaim>[2]) => ReturnType<typeof aensClaim>;
 }>>;
-interface AensPreclaimOptions extends BuildTxOptions<Tag.NamePreclaimTx, 'accountId' | 'commitmentId'>, SendOptions, AensClaimOptions {
+interface AensPreclaimOptions extends BuildTxOptions<Tag.NamePreclaimTx, 'accountId' | 'commitmentId'>, SendOptions, Omit<AensClaimOptions, 'version'> {
 }
 /**
  * Bid to name auction

package/types-legacy/ts4.5/aepp-wallet-communication/connection/BrowserRuntime.d.ts

@@ -6,6 +6,7 @@ import BrowserConnection from './Browser';
  * @category aepp wallet communication
  */
 export default class BrowserRuntimeConnection extends BrowserConnection {
+    #private;
     port: Runtime.Port;
     constructor({ port, ...options }: {
         port: Runtime.Port;

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

@@ -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.5/channel/Base.d.ts

@@ -128,7 +128,12 @@ export default class Channel {
     /**
      * Get current state
      */
-    state(): Promise<ChannelState>;
+    state(): Promise<{
+        calls: Encoded.CallStateTree;
+        halfSignedTx: Encoded.Transaction | '';
+        signedTx: Encoded.Transaction;
+        trees: Encoded.StateTrees;
+    }>;
     /**
      * Get current round
      *

package/types-legacy/ts4.5/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.5/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.5/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: Encoded.ContractAddress]: 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.5/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.5/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.5/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.5/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.5/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>>;