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

package/src/chain.ts

@@ -353,7 +353,7 @@ export async function getMicroBlockHeader(
 interface TxDryRunArguments {
   tx: Encoded.Transaction;
   accountAddress: Encoded.AccountAddress;
-  top?: number;
+  top?: number | Encoded.KeyBlockHash | Encoded.MicroBlockHash;
   txEvents?: any;
   resolve: Function;
   reject: Function;
@@ -367,8 +367,10 @@ async function txDryRunHandler(key: string, onNode: Node): Promise<void> {
 
   let dryRunRes;
   try {
+    const top = typeof rs[0].top === 'number'
+      ? (await getKeyBlock(rs[0].top, { onNode })).hash : rs[0].top;
     dryRunRes = await onNode.protectedDryRunTxs({
-      top: rs[0].top,
+      top,
       txEvents: rs[0].txEvents,
       txs: rs.map((req) => ({ tx: req.tx })),
       accounts: Array.from(new Set(rs.map((req) => req.accountAddress)))
@@ -406,7 +408,7 @@ export async function txDryRun(
   {
     top, txEvents, combine, onNode,
   }:
-  { top?: number; txEvents?: boolean; combine?: boolean; onNode: Node },
+  { top?: TxDryRunArguments['top']; txEvents?: boolean; combine?: boolean; onNode: Node },
 ): Promise<{
     txEvents?: TransformNodeType<DryRunResults['txEvents']>;
   } & TransformNodeType<DryRunResult>> {

package/src/channel/Base.ts

@@ -210,7 +210,12 @@ export default class Channel {
   /**
    * Get current state
    */
-  async state(): Promise<ChannelState> {
+  async state(): Promise<{
+    calls: Encoded.CallStateTree;
+    halfSignedTx: Encoded.Transaction | '';
+    signedTx: Encoded.Transaction;
+    trees: Encoded.StateTrees;
+  }> {
     return snakeToPascalObjKeys(await call(this, 'channels.get.offchain_state', {}));
   }
 
@@ -224,14 +229,14 @@ export default class Channel {
     if (this._state == null) {
       return null;
     }
-    const { txType, tx } = unpackTx(this._state, Tag.SignedTx).tx.encodedTx;
-    switch (txType) {
+    const { tag, round } = unpackTx(this._state, Tag.SignedTx).encodedTx;
+    switch (tag) {
       case Tag.ChannelCreateTx:
         return 1;
       case Tag.ChannelOffChainTx:
       case Tag.ChannelWithdrawTx:
       case Tag.ChannelDepositTx:
-        return tx.round;
+        return round;
       default:
         return null;
     }
@@ -321,7 +326,10 @@ export default class Channel {
 
     return Channel.initialize({
       ...options,
-      reconnectTx: await sign('reconnect', buildTx(txParams, Tag.ChannelClientReconnectTx).tx),
+      reconnectTx: await sign(
+        'reconnect',
+        buildTx({ ...txParams, tag: Tag.ChannelClientReconnectTx }),
+      ),
     });
   }
 }

package/src/channel/Contract.ts

@@ -16,7 +16,9 @@
  */
 import BigNumber from 'bignumber.js';
 import { snakeToPascal } from '../utils/string';
-import { MIN_GAS_PRICE, Tag } from '../tx/builder/constants';
+import {
+  MIN_GAS_PRICE, Tag, AbiVersion, VmVersion,
+} from '../tx/builder/constants';
 import {
   signAndNotify,
   awaitingCompletion,
@@ -46,7 +48,7 @@ function snakeToPascalObjKeys<Type>(obj: object): Type {
 interface CallContractOptions {
   amount?: number | BigNumber;
   callData?: Encoded.ContractBytearray;
-  abiVersion?: number;
+  abiVersion?: AbiVersion;
   contract?: Encoded.ContractAddress;
   returnValue?: any;
   gasUsed?: number | BigNumber;
@@ -58,13 +60,13 @@ interface CallContractOptions {
 }
 
 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 {
@@ -113,8 +115,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<{
@@ -150,8 +152,7 @@ export default class ChannelContract extends ChannelSpend {
               state2: ChannelState,
             ): ChannelFsm => (
               awaitingCompletion(this, message2, state2, () => {
-                const { round } = unpackTx(message2.params.data.state, Tag.SignedTx)
-                  .tx.encodedTx.tx;
+                const { round } = unpackTx(message2.params.data.state, Tag.SignedTx).encodedTx;
                 const addressKey = this._options.role === 'initiator'
                   ? 'initiatorId' : 'responderId';
                 const owner = this._options[addressKey];
@@ -294,7 +295,7 @@ export default class ChannelContract extends ChannelSpend {
       amount: number;
       callData: Encoded.ContractBytearray;
       contract: Encoded.ContractAddress;
-      abiVersion: number;
+      abiVersion: AbiVersion;
       gasLimit?: number;
       gasPrice?: number;
     },
@@ -390,7 +391,7 @@ export default class ChannelContract extends ChannelSpend {
       amount: number;
       callData: Encoded.ContractBytearray;
       contract: Encoded.ContractAddress;
-      abiVersion: number;
+      abiVersion: AbiVersion;
     },
   ): Promise<CallContractOptions> {
     return snakeToPascalObjKeys(await call(this, 'channels.dry_run.call_contract', {

package/src/channel/Spend.ts

@@ -25,6 +25,8 @@ import { ChannelConnectionError } from '../utils/errors';
 import {
   awaitingCompletion, channelOpen, handleUnexpectedMessage, signAndNotify,
 } from './handlers';
+import { unpackTx } from '../tx/builder';
+import { Tag } from '../tx/builder/constants';
 
 export default class ChannelSpend extends Channel {
   /**
@@ -133,8 +135,11 @@ export default class ChannelSpend extends Channel {
       accounts: Encoded.AccountAddress[];
       contracts?: Encoded.ContractAddress[];
     },
-  ): Promise<Encoded.Poi> {
-    return (await call(this, 'channels.get.poi', { accounts, contracts })).poi;
+  ): Promise<ReturnType<typeof unpackTx<Tag.TreesPoi>>> {
+    return unpackTx(
+      (await call(this, 'channels.get.poi', { accounts, contracts })).poi,
+      Tag.TreesPoi,
+    );
   }
 
   /**

package/src/channel/handlers.ts

@@ -21,7 +21,6 @@ import {
   ChannelState,
   changeStatus,
   changeState,
-  call,
   notify,
   emit,
   disconnect,
@@ -31,7 +30,7 @@ import {
   ChannelStatus,
 } from './internal';
 import { unpackTx, buildTx } from '../tx/builder';
-import { encode, Encoded, Encoding } from '../utils/encoder';
+import { decode, Encoded } from '../utils/encoder';
 import {
   IllegalArgumentError,
   InsufficientBalanceError,
@@ -46,14 +45,16 @@ export async function appendSignature(
   tx: Encoded.Transaction,
   signFn: SignTx,
 ): Promise<Encoded.Transaction | number | null> {
-  const { signatures, encodedTx } = unpackTx(tx, Tag.SignedTx).tx;
-  const result = await signFn(encode(encodedTx.rlpEncoded, Encoding.Transaction));
+  const { signatures, encodedTx } = unpackTx(tx, Tag.SignedTx);
+  const payloadTx = buildTx(encodedTx);
+  const result = await signFn(payloadTx);
   if (typeof result === 'string') {
-    const { tx: signedTx } = unpackTx(result, Tag.SignedTx);
+    const { signatures: signatures2 } = unpackTx(result, Tag.SignedTx);
     return buildTx({
-      signatures: signatures.concat(signedTx.signatures),
-      encodedTx: signedTx.encodedTx.rlpEncoded,
-    }, Tag.SignedTx).tx;
+      tag: Tag.SignedTx,
+      signatures: signatures.concat(signatures2),
+      encodedTx: decode(payloadTx),
+    });
   }
   return result;
 }
@@ -164,7 +165,7 @@ export async function awaitingReconnection(
   if (message.method === 'channels.info') {
     if (message.params.data.event === 'fsm_up') {
       channel._fsmId = message.params.data.fsm_id;
-      changeState(channel, (await call(channel, 'channels.get.offchain_state', {})).signed_tx);
+      changeState(channel, (await channel.state()).signedTx);
       return { handler: channelOpen };
     }
   }

package/src/channel/internal.ts

@@ -317,7 +317,7 @@ export async function initialize(
         changeStatus(channel, 'connected');
         if (channelOptions.reconnectTx != null) {
           enterState(channel, { handler: openHandler });
-          const signedTx = (await call(channel, 'channels.get.offchain_state', {})).signed_tx;
+          const { signedTx } = await channel.state();
           changeState(channel, signedTx);
         }
         ping(channel);

package/src/contract/Contract.ts

@@ -26,8 +26,8 @@ import { Encoder as Calldata } from '@aeternity/aepp-calldata';
 import { DRY_RUN_ACCOUNT } from '../tx/builder/schema';
 import { Tag, AensName } from '../tx/builder/constants';
 import { buildContractIdByContractTx, unpackTx } from '../tx/builder';
-import { _buildTx } from '../tx';
-import { send } from '../spend';
+import { _buildTx, BuildTxOptions } from '../tx';
+import { send, SendOptions } from '../spend';
 import { decode, Encoded } from '../utils/encoder';
 import {
   MissingContractDefError,
@@ -49,40 +49,19 @@ import {
   NoWalletConnectedError,
 } from '../utils/errors';
 import { hash as calcHash } from '../utils/crypto';
-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 {
-  getAccount, getContract, getContractByteCode, getKeyBlock, resolveName, txDryRun,
+  getAccount, getContract, getContractByteCode, resolveName, txDryRun,
 } from '../chain';
 import AccountBase from '../account/Base';
 import { concatBuffers } from '../utils/other';
 import { isNameValid, produceNameId } from '../tx/builder/helpers';
 
-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;
@@ -217,9 +196,10 @@ class Contract<M extends ContractMethodsBase> {
   async $compile(): Promise<Encoded.ContractBytearray> {
     if (this.$options.bytecode != null) return this.$options.bytecode;
     if (this.$options.sourceCode == null) throw new IllegalArgumentError('Can\'t compile without source code');
-    this.$options.bytecode = (await this.$options.onCompiler.compileContract({
-      code: this.$options.sourceCode, options: { fileSystem: this.$options.fileSystem },
-    })).bytecode as Encoded.ContractBytearray;
+    if (this.$options.onCompiler == null) throw new IllegalArgumentError('Can\'t compile without compiler');
+    this.$options.bytecode = (await this.$options.onCompiler
+      .compileBySourceCode(this.$options.sourceCode, this.$options.fileSystem)
+    ).bytecode;
     return this.$options.bytecode;
   }
 
@@ -247,10 +227,9 @@ class Contract<M extends ContractMethodsBase> {
 
   protected async _sendAndProcess(
     tx: Encoded.Transaction,
-    options: any,
+    options: SendOptions,
   ): Promise<SendAndProcessReturnType> {
-    options = { ...this.$options, ...options };
-    const txData = await send(tx, options);
+    const txData = await send(tx, { ...this.$options, ...options });
     const result = {
       hash: txData.hash,
       tx: unpackTx<Tag.ContractCallTx | Tag.ContractCreateTx>(txData.rawTx),
@@ -285,18 +264,22 @@ class Contract<M extends ContractMethodsBase> {
    */
   async $deploy(
     params: MethodParameters<M, 'init'>,
-    options?: Parameters<Contract<M>['$call']>[2] & Parameters<Contract<M>['_sendAndProcess']>[1],
+    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']>;
     }> {
-    const opt = { ...this.$options, ...options };
+    const { callStatic, ...opt } = { ...this.$options, ...options };
     if (this.$options.bytecode == null) await this.$compile();
-    if (opt.callStatic === true) return this.$call('init', params, opt);
+    if (callStatic === true) return this.$call('init', params, { ...opt, callStatic });
     if (this.$options.address != null) throw new DuplicateContractError();
 
+    if (opt.onAccount == null) throw new IllegalArgumentError('Can\'t deploy without account');
     const ownerId = opt.onAccount.address;
+    if (this.$options.bytecode == null) throw new IllegalArgumentError('Can\'t deploy without bytecode');
     const tx = await _buildTx(Tag.ContractCreateTx, {
       ...opt,
       gasLimit: opt.gasLimit ?? await this._estimateGas('init', params, opt),
@@ -305,9 +288,12 @@ class Contract<M extends ContractMethodsBase> {
       ownerId,
     });
     this.$options.address = buildContractIdByContractTx(tx);
-    const { hash, ...other } = await this._sendAndProcess(tx, opt);
+    const { hash, ...other } = await this._sendAndProcess(tx, { ...opt, onAccount: opt.onAccount });
     return {
       ...other,
+      ...other.result?.log != null && {
+        decodedEvents: this.$decodeEvents(other.result.log, opt),
+      },
       owner: ownerId,
       transaction: hash,
       address: this.$options.address,
@@ -319,7 +305,7 @@ class Contract<M extends ContractMethodsBase> {
    * @param name - Function name
    * @returns function ACI
    */
-  protected _getFunctionACI(name: string): Partial<FunctionACI> {
+  protected _getFunctionACI(name: string): Partial<FunctionAci> {
     const fn = this._aci.encodedAci.contract.functions.find(
       (f: { name: string }) => f.name === name,
     );
@@ -340,25 +326,32 @@ class Contract<M extends ContractMethodsBase> {
   async $call<Fn extends MethodNames<M>>(
     fn: Fn,
     params: MethodParameters<M, Fn>,
-    options: object = {},
+    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> {
-    const opt = { ...this.$options, ...options };
+    const { callStatic, top, ...opt } = { ...this.$options, ...options };
     const fnACI = this._getFunctionACI(fn);
     const contractId = this.$options.address;
     const { onNode } = opt;
 
     if (fn == null) throw new MissingFunctionNameError();
-    if (fn === 'init' && opt.callStatic === false) throw new InvalidMethodInvocationError('"init" can be called only via dryRun');
-    if (fn !== 'init' && opt.amount > 0 && fnACI.payable === false) throw new NotPayableFunctionError(opt.amount, fn);
+    if (fn === 'init' && callStatic !== true) throw new InvalidMethodInvocationError('"init" can be called only via dryRun');
+    if (fn !== 'init' && opt.amount != null && opt.amount > 0 && fnACI.payable === false) {
+      throw new NotPayableFunctionError(opt.amount, fn);
+    }
 
     let callerId;
     try {
+      if (opt.onAccount == null) throw new InternalError('Use fallback account');
       callerId = opt.onAccount.address;
     } catch (error) {
-      const useFallbackAccount = opt.callStatic === true && (
+      const useFallbackAccount = callStatic === true && (
         (error instanceof TypeError && error.message === 'Account should be an address (ak-prefixed string), or instance of AccountBase, got undefined instead')
         || (error instanceof NoWalletConnectedError)
       );
@@ -368,14 +361,12 @@ class Contract<M extends ContractMethodsBase> {
     const callData = this._calldata.encode(this._name, fn, params);
 
     let res: any;
-    if (opt.callStatic === true) {
-      if (typeof opt.top === 'number') {
-        opt.top = (await getKeyBlock(opt.top, { onNode })).hash;
+    if (callStatic === true) {
+      if (opt.nonce == null && top != null) {
+        const topKey = typeof top === 'number' ? 'height' : 'hash';
+        opt.nonce = (await getAccount(callerId, { [topKey]: top, onNode })).nonce + 1;
       }
       const txOpt = { ...opt, onNode, callData };
-      if (opt.nonce == null && opt.top != null) {
-        opt.nonce = (await getAccount(callerId, { hash: opt.top, onNode })).nonce + 1;
-      }
       let tx;
       if (fn === 'init') {
         if (this.$options.bytecode == null) throw new IllegalArgumentError('Can\'t dry-run "init" without bytecode');
@@ -388,7 +379,7 @@ class Contract<M extends ContractMethodsBase> {
         tx = await _buildTx(Tag.ContractCallTx, { ...txOpt, callerId, contractId });
       }
 
-      const { callObj, ...dryRunOther } = await txDryRun(tx, callerId, opt);
+      const { callObj, ...dryRunOther } = await txDryRun(tx, callerId, { ...opt, top });
       if (callObj == null) throw new UnexpectedTsError();
       this._handleCallError({
         returnType: callObj.returnType as ContractCallReturnType,
@@ -396,6 +387,7 @@ class Contract<M extends ContractMethodsBase> {
       }, tx);
       res = { ...dryRunOther, tx: unpackTx(tx), result: callObj };
     } else {
+      if (top != null) throw new IllegalArgumentError('Can\'t handle `top` option in on-chain contract call');
       if (contractId == null) throw new MissingContractAddressError('Can\'t call contract without address');
       const tx = await _buildTx(Tag.ContractCallTx, {
         ...opt,
@@ -404,9 +396,10 @@ class Contract<M extends ContractMethodsBase> {
         contractId,
         callData,
       });
-      res = await this._sendAndProcess(tx, opt);
+      if (opt.onAccount == null) throw new IllegalArgumentError('Can\'t call contract on chain without account');
+      res = await this._sendAndProcess(tx, { ...opt, onAccount: opt.onAccount });
     }
-    if (opt.callStatic === true || res.txData.blockHeight != null) {
+    if (callStatic === true || res.txData.blockHeight != null) {
       res.decodedResult = fnACI.returns != null && fnACI.returns !== 'unit' && fn !== 'init'
         && this._calldata.decode(this._name, fn, res.result.returnValue);
       res.decodedEvents = this.$decodeEvents(res.result.log, opt);
@@ -489,10 +482,11 @@ class Contract<M extends ContractMethodsBase> {
     {
       onCompiler,
       onNode,
-      sourceCode,
       bytecode,
       aci,
       address,
+      sourceCodePath,
+      sourceCode,
       fileSystem,
       validateBytecode,
       ...otherOptions
@@ -502,9 +496,14 @@ class Contract<M extends ContractMethodsBase> {
       address?: Encoded.ContractAddress | AensName;
     },
   ): Promise<ContractWithMethods<M>> {
-    if (aci == null && sourceCode != null) {
-      // TODO: should be fixed when the compiledAci interface gets updated
-      aci = await onCompiler.generateACI({ code: sourceCode, options: { fileSystem } }) as Aci;
+    if (aci == null && onCompiler != null) {
+      let res;
+      if (sourceCodePath != null) res = await onCompiler.compile(sourceCodePath);
+      if (sourceCode != null) res = await onCompiler.compileBySourceCode(sourceCode, fileSystem);
+      if (res != null) {
+        aci = res.aci;
+        bytecode ??= res.bytecode;
+      }
     }
     if (aci == null) throw new MissingContractDefError();
 
@@ -525,14 +524,15 @@ class Contract<M extends ContractMethodsBase> {
       if (contract.active == null) throw new InactiveContractError(address);
     }
 
-    if (validateBytecode != null) {
+    if (validateBytecode === true) {
       if (address == null) throw new MissingContractAddressError('Can\'t validate bytecode without contract address');
       const onChanBytecode = (await getContractByteCode(address, { onNode })).bytecode;
-      const isValid: boolean = sourceCode != null
-        ? await onCompiler.validateByteCode(
-          { bytecode: onChanBytecode, source: sourceCode, options: { fileSystem } },
-        ).then(() => true, () => false)
-        : bytecode === onChanBytecode;
+      let isValid = false;
+      if (bytecode != null) isValid = bytecode === onChanBytecode;
+      else if (sourceCode != null) {
+        if (onCompiler == null) throw new IllegalArgumentError('Can\'t validate bytecode without compiler');
+        isValid = await onCompiler.validateBySourceCode(onChanBytecode, sourceCode, fileSystem);
+      }
       if (!isValid) throw new BytecodeMismatchError(sourceCode != null ? 'source code' : 'bytecode');
     }
 
@@ -547,32 +547,22 @@ class Contract<M extends ContractMethodsBase> {
 
   _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]) {
     this._aci = aci;
     this._name = aci.encodedAci.contract.name;
     this._calldata = new Calldata([aci.encodedAci, ...aci.externalEncodedAci]);
-    this.$options = { callStatic: false, ...otherOptions };
+    this.$options = otherOptions;
 
     /**
      * Generate proto function based on contract function using Contract ACI schema
@@ -591,7 +581,7 @@ class Contract<M extends ContractMethodsBase> {
     Object.assign(
       this,
       Object.fromEntries(this._aci.encodedAci.contract.functions
-        .map(({ name, arguments: aciArgs, stateful }: FunctionACI) => {
+        .map(({ name, arguments: aciArgs, stateful }: FunctionAci) => {
           const callStatic = name !== 'init' && !stateful;
           return [
             name,

package/src/contract/compiler/Base.ts

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