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

package/src/contract/Contract.ts

@@ -1,20 +1,3 @@
-/*
-* ISC License (ISC)
-* Copyright (c) 2022 aeternity developers
-*
-*  Permission to use, copy, modify, and/or distribute this software for any
-*  purpose with or without fee is hereby granted, provided that the above
-*  copyright notice and this permission notice appear in all copies.
-*
-*  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-*  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-*  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-*  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-*  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-*  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-*  PERFORMANCE OF THIS SOFTWARE.
-*/
-
 /**
  * Contract module - routines to interact with the æternity contract
  *
@@ -25,9 +8,9 @@
 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 {
+  buildContractIdByContractTx, unpackTx, buildTxAsync, BuildTxOptions, buildTxHash,
+} from '../tx/builder';
 import { decode, Encoded } from '../utils/encoder';
 import {
   MissingContractDefError,
@@ -47,49 +30,30 @@ import {
   UnexpectedTsError,
   InternalError,
   NoWalletConnectedError,
+  ContractError,
 } 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,
+  ContractCallObject as NodeContractCallObject, 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, sendTransaction,
+  SendTransactionOptions,
 } from '../chain';
 import AccountBase from '../account/Base';
-import { concatBuffers } from '../utils/other';
-import { isNameValid, produceNameId } from '../tx/builder/helpers';
+import { TxUnpacked } from '../tx/builder/schema.generated';
 
-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 ContractAci = NonNullable<Aci[0]['contract']>;
+type FunctionAci = ContractAci['functions'][0];
 
 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[];
 }
@@ -103,12 +67,12 @@ interface DecodedEvent {
   };
 }
 
-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<typeof unpackTx<Tag.ContractCallTx | Tag.ContractCreateTx>>>;
+  tx: TxUnpacked & { tag: Tag.ContractCallTx | Tag.ContractCreateTx };
   txData: TxData;
   rawTx: Encoded.Transaction;
 }
@@ -117,15 +81,12 @@ 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
+  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 }
-    >
+    ]) => ReturnType<Contract<M>['$call']>
     : never
 };
 
@@ -138,6 +99,15 @@ type MethodParameters<M extends ContractMethodsBase, Fn extends MethodNames<M>>
     ? M extends { init: any } ? Parameters<M['init']> : []
     : Parameters<M[Fn]>;
 
+interface GetContractNameByEventOptions {
+  contractAddressToName?: { [key: Encoded.ContractAddress]: 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
@@ -156,60 +126,6 @@ type MethodParameters<M extends ContractMethodsBase, Fn extends MethodNames<M>>
  * stateful or not
  */
 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 })
-   * ```
-   */
-  async $createDelegationSignature(
-    ids: Array<Encoded.Any | AensName> = [],
-    _options?: { omitAddress?: boolean; onAccount?: AccountBase },
-  ): Promise<Uint8Array> {
-    const options = { ...this.$options, ..._options };
-    const contractId = this.$options.address;
-    if (options.onAccount == null) throw new IllegalArgumentError('Can\'t create delegation signature without account');
-    if (contractId == null) throw new MissingContractAddressError('Can\'t create delegation signature without address');
-    return options.onAccount.sign(
-      concatBuffers([
-        Buffer.from(await options.onNode.getNetworkId()),
-        ...options.omitAddress === true ? [] : [decode(options.onAccount.address)],
-        ...ids.map((e) => (isNameValid(e) ? produceNameId(e) : e)).map((e) => decode(e)),
-        decode(contractId),
-      ]),
-      options,
-    );
-  }
-
   /**
    * Compile contract
    * @returns bytecode
@@ -217,22 +133,28 @@ 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;
   }
 
-  protected _handleCallError(
-    { returnType, returnValue }: {
-      returnType: ContractCallReturnType;
-      returnValue: Encoded.ContractBytearray;
-    },
-    transaction: string,
-  ): void {
+  #getCallResult<Fn extends MethodNames<M>>(
+    { returnType, returnValue, log }: ContractCallObject,
+    fnName: Fn,
+    transaction: Encoded.Transaction | undefined,
+    options: Parameters<Contract<M>['$decodeEvents']>[1],
+  ): GetCallResultByHashReturnType<M, Fn> {
     let message: string;
     switch (returnType) {
-      case 'ok': return;
+      case 'ok': {
+        const fnAci = this.#getFunctionAci(fnName);
+        return {
+          decodedResult: this._calldata.decode(this._name, fnAci.name, returnValue),
+          decodedEvents: this.$decodeEvents(log, options),
+        };
+      }
       case 'revert':
         message = this._calldata.decodeFateString(returnValue);
         break;
@@ -245,30 +167,43 @@ class Contract<M extends ContractMethodsBase> {
     throw new NodeInvocationError(message, transaction);
   }
 
-  protected async _sendAndProcess(
+  async #sendAndProcess<Fn extends MethodNames<M>>(
     tx: Encoded.Transaction,
-    options: any,
-  ): Promise<SendAndProcessReturnType> {
-    options = { ...this.$options, ...options };
-    const txData = await send(tx, options);
-    const result = {
+    fnName: Fn,
+    options: SendTransactionOptions & Parameters<Contract<M>['$getCallResultByTxHash']>[2],
+  ): Promise<SendAndProcessReturnType & Partial<GetCallResultByHashReturnType<M, Fn>>> {
+    const txData = await sendTransaction(tx, { ...this.$options, ...options });
+    return {
       hash: txData.hash,
       tx: unpackTx<Tag.ContractCallTx | Tag.ContractCreateTx>(txData.rawTx),
       txData,
       rawTx: txData.rawTx,
+      ...txData.blockHeight != null && (
+        await this.$getCallResultByTxHash(txData.hash, fnName, options)
+      ),
+    };
+  }
+
+  async $getCallResultByTxHash<Fn extends MethodNames<M>>(
+    hash: Encoded.TxHash,
+    fnName: Fn,
+    options?: Parameters<Contract<M>['$decodeEvents']>[1],
+  ): Promise<GetCallResultByHashReturnType<M, Fn> & { result: ContractCallObject }> {
+    const { callInfo } = await this.$options.onNode.getTransactionInfoByHash(hash);
+    if (callInfo == null) {
+      throw new ContractError(`callInfo is not available for transaction ${hash}`);
+    }
+    const callInfoTyped = callInfo as ContractCallObject;
+    return {
+      ...this.#getCallResult(callInfoTyped, fnName, undefined, options),
+      result: callInfoTyped,
     };
-    if (txData.blockHeight == null) return result;
-    const { callInfo } = await this.$options.onNode.getTransactionInfoByHash(txData.hash);
-    Object.assign(result.txData, callInfo); // TODO: don't duplicate data in result
-    // @ts-expect-error TODO api should be updated to match types
-    this._handleCallError(callInfo, tx);
-    return { ...result, result: callInfo as TransformNodeType<ContractCallObject> };
   }
 
   async _estimateGas<Fn extends MethodNames<M>>(
     name: Fn,
     params: MethodParameters<M, Fn>,
-    options: object = {},
+    options: Omit<Parameters<Contract<M>['$call']>[2], 'callStatic'> = {},
   ): Promise<number> {
     const { result } = await this.$call(name, params, { ...options, callStatic: true });
     if (result == null) throw new UnexpectedTsError();
@@ -285,29 +220,41 @@ 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;
-    const tx = await _buildTx(Tag.ContractCreateTx, {
+    if (this.$options.bytecode == null) throw new IllegalArgumentError('Can\'t deploy without bytecode');
+    const tx = await buildTxAsync({
       ...opt,
+      tag: Tag.ContractCreateTx,
       gasLimit: opt.gasLimit ?? await this._estimateGas('init', params, opt),
       callData: this._calldata.encode(this._name, 'init', params),
       code: this.$options.bytecode,
       ownerId,
     });
     this.$options.address = buildContractIdByContractTx(tx);
-    const { hash, ...other } = await this._sendAndProcess(tx, opt);
+    const { hash, ...other } = await this.#sendAndProcess(
+      tx,
+      'init',
+      { ...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,14 +266,18 @@ class Contract<M extends ContractMethodsBase> {
    * @param name - Function name
    * @returns function ACI
    */
-  protected _getFunctionACI(name: string): Partial<FunctionACI> {
-    const fn = this._aci.encodedAci.contract.functions.find(
+  #getFunctionAci(name: string): FunctionAci {
+    const fn = this.#aciContract.functions.find(
       (f: { name: string }) => f.name === name,
     );
     if (fn != null) {
       return fn;
     }
-    if (name === 'init') return { payable: false };
+    if (name === 'init') {
+      return {
+        arguments: [], name: 'init', payable: false, returns: 'unit', stateful: true,
+      };
+    }
     throw new NoSuchContractFunctionError(`Function ${name} doesn't exist in contract`);
   }
 
@@ -340,25 +291,29 @@ class Contract<M extends ContractMethodsBase> {
   async $call<Fn extends MethodNames<M>>(
     fn: Fn,
     params: MethodParameters<M, Fn>,
-    options: object = {},
-  ): Promise<{
-      decodedResult?: any;
-      decodedEvents?: ReturnType<Contract<M>['$decodeEvents']>;
-    } & SendAndProcessReturnType> {
-    const opt = { ...this.$options, ...options };
-    const fnACI = this._getFunctionACI(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>>> {
+    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) {
+      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)
       );
@@ -367,51 +322,53 @@ 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');
-        tx = await _buildTx(
-          Tag.ContractCreateTx,
-          { ...txOpt, code: this.$options.bytecode, ownerId: callerId },
-        );
+        tx = await buildTxAsync({
+          ...txOpt, tag: Tag.ContractCreateTx, code: this.$options.bytecode, ownerId: callerId,
+        });
       } else {
         if (contractId == null) throw new MissingContractAddressError('Can\'t dry-run contract without address');
-        tx = await _buildTx(Tag.ContractCallTx, { ...txOpt, callerId, contractId });
+        tx = await buildTxAsync({
+          ...txOpt, tag: Tag.ContractCallTx, callerId, contractId,
+        });
       }
 
-      const { callObj, ...dryRunOther } = await txDryRun(tx, callerId, opt);
-      if (callObj == null) throw new UnexpectedTsError();
-      this._handleCallError({
-        returnType: callObj.returnType as ContractCallReturnType,
-        returnValue: callObj.returnValue as Encoded.ContractBytearray,
-      }, tx);
-      res = { ...dryRunOther, tx: unpackTx(tx), result: callObj };
-    } else {
-      if (contractId == null) throw new MissingContractAddressError('Can\'t call contract without address');
-      const tx = await _buildTx(Tag.ContractCallTx, {
-        ...opt,
-        gasLimit: opt.gasLimit ?? await this._estimateGas(fn, params, opt),
-        callerId,
-        contractId,
-        callData,
-      });
-      res = await this._sendAndProcess(tx, opt);
-    }
-    if (opt.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);
+      const { callObj, ...dryRunOther } = await txDryRun(tx, callerId, { ...opt, top });
+      if (callObj == null) {
+        throw new InternalError(`callObj is not available for transaction ${tx}`);
+      }
+      const callInfoTyped = callObj as ContractCallObject;
+      return {
+        ...dryRunOther,
+        ...this.#getCallResult(callInfoTyped, fn, tx, opt),
+        tx: unpackTx(tx),
+        result: callInfoTyped,
+        rawTx: tx,
+        hash: buildTxHash(tx),
+        txData: undefined as any,
+      };
     }
-    return res;
+
+    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 buildTxAsync({
+      ...opt,
+      tag: Tag.ContractCallTx,
+      gasLimit: opt.gasLimit ?? await this._estimateGas(fn, params, opt),
+      callerId,
+      contractId,
+      callData,
+    });
+    if (opt.onAccount == null) throw new IllegalArgumentError('Can\'t call contract on chain without account');
+    return this.#sendAndProcess(tx, fn, { ...opt, onAccount: opt.onAccount });
   }
 
   /**
@@ -422,12 +379,10 @@ class Contract<M extends ContractMethodsBase> {
    * @throws {@link MissingEventDefinitionError}
    * @throws {@link AmbiguousEventDefinitionError}
    */
-  protected _getContractNameByEvent(
+  #getContractNameByEvent(
     ctAddress: Encoded.ContractAddress,
     nameHash: BigInt,
-    { contractAddressToName }: {
-      contractAddressToName?: { [key: Encoded.ContractAddress]: string };
-    },
+    { contractAddressToName }: GetContractNameByEventOptions,
   ): string {
     const addressToName = { ...this.$options.contractAddressToName, ...contractAddressToName };
     if (addressToName[ctAddress] != null) return addressToName[ctAddress];
@@ -435,9 +390,11 @@ class Contract<M extends ContractMethodsBase> {
     // TODO: consider using a third-party library
     const isEqual = (a: any, b: any): boolean => JSON.stringify(a) === JSON.stringify(b);
 
-    const matchedEvents = [this._aci.encodedAci, ...this._aci.externalEncodedAci]
-      .filter(({ contract }) => contract?.event)
-      .map(({ contract }) => [contract.name, contract.event.variant])
+    const contracts = this._aci
+      .map(({ contract }) => contract)
+      .filter((contract) => contract?.event) as ContractAci[];
+    const matchedEvents = contracts
+      .map((contract) => [contract.name, contract.event.variant])
       .map(([name, events]) => events.map((event: {}) => (
         [name, Object.keys(event)[0], Object.values(event)[0]]
       )))
@@ -459,15 +416,14 @@ class Contract<M extends ContractMethodsBase> {
    */
   $decodeEvents(
     events: Event[],
-    { omitUnknown, ...opt }: { omitUnknown?: boolean } &
-    Parameters<Contract<M>['_getContractNameByEvent']>[2] = {},
+    { omitUnknown, ...opt }: { omitUnknown?: boolean } & GetContractNameByEventOptions = {},
   ): DecodedEvent[] {
     return events
       .map((event) => {
         const topics = event.topics.map((t: string | number) => BigInt(t));
         let contractName;
         try {
-          contractName = this._getContractNameByEvent(event.address, topics[0], opt);
+          contractName = this.#getContractNameByEvent(event.address, topics[0], opt);
         } catch (error) {
           if ((omitUnknown ?? false) && error instanceof MissingEventDefinitionError) return null;
           throw error;
@@ -489,10 +445,11 @@ class Contract<M extends ContractMethodsBase> {
     {
       onCompiler,
       onNode,
-      sourceCode,
       bytecode,
       aci,
       address,
+      sourceCodePath,
+      sourceCode,
       fileSystem,
       validateBytecode,
       ...otherOptions
@@ -502,9 +459,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 +487,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');
     }
 
@@ -543,36 +506,33 @@ class Contract<M extends ContractMethodsBase> {
 
   _aci: Aci;
 
+  #aciContract: ContractAci;
+
   _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]) {
     this._aci = aci;
-    this._name = aci.encodedAci.contract.name;
-    this._calldata = new Calldata([aci.encodedAci, ...aci.externalEncodedAci]);
-    this.$options = { callStatic: false, ...otherOptions };
+    const aciLast = aci[aci.length - 1];
+    if (aciLast.contract == null) {
+      throw new IllegalArgumentError(`The last 'aci' item should have 'contract' key, got ${Object.keys(aciLast)} keys instead`);
+    }
+    this.#aciContract = aciLast.contract;
+    this._name = this.#aciContract.name;
+    this._calldata = new Calldata(aci);
+    this.$options = otherOptions;
 
     /**
      * Generate proto function based on contract function using Contract ACI schema
@@ -590,8 +550,8 @@ class Contract<M extends ContractMethodsBase> {
      */
     Object.assign(
       this,
-      Object.fromEntries(this._aci.encodedAci.contract.functions
-        .map(({ name, arguments: aciArgs, stateful }: FunctionACI) => {
+      Object.fromEntries(this.#aciContract.functions
+        .map(({ name, arguments: aciArgs, stateful }: FunctionAci) => {
           const callStatic = name !== 'init' && !stateful;
           return [
             name,