@aeternity/aepp-sdk 13.0.0-alpha.1 → 13.0.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, BuildTxOptions } from '../tx';
-import { send, SendOptions } from '../spend';
+import {
+  buildContractIdByContractTx, unpackTx, buildTxAsync, BuildTxOptions, buildTxHash,
+} from '../tx/builder';
 import { decode, Encoded } from '../utils/encoder';
 import {
   MissingContractDefError,
@@ -47,28 +30,30 @@ import {
   UnexpectedTsError,
   InternalError,
   NoWalletConnectedError,
+  ContractError,
 } from '../utils/errors';
 import { hash as calcHash } from '../utils/crypto';
 import {
-  ContractCallObject as NodeContractCallObject, ContractCallReturnType, Event as NodeEvent,
+  ContractCallObject as NodeContractCallObject, Event as NodeEvent,
 } from '../apis/node';
 import CompilerBase, { Aci } from './compiler/Base';
 import Node, { TransformNodeType } from '../Node';
 import {
-  getAccount, getContract, getContractByteCode, 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';
 
-type FunctionAci = Aci['encodedAci']['contract']['functions'][0];
+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[];
 }
@@ -82,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;
 }
@@ -96,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
 };
 
@@ -117,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
@@ -135,84 +126,43 @@ 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
    */
   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');
     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;
+    if (this.$options.sourceCode != null) {
+      const { bytecode } = await this.$options.onCompiler
+        .compileBySourceCode(this.$options.sourceCode, this.$options.fileSystem);
+      this.$options.bytecode = bytecode;
+    }
+    if (this.$options.sourceCodePath != null) {
+      const { bytecode } = await this.$options.onCompiler.compile(this.$options.sourceCodePath);
+      this.$options.bytecode = bytecode;
+    }
+    if (this.$options.bytecode == null) {
+      throw new IllegalArgumentError('Can\'t compile without sourceCode and sourceCodePath');
+    }
     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;
@@ -225,29 +175,43 @@ class Contract<M extends ContractMethodsBase> {
     throw new NodeInvocationError(message, transaction);
   }
 
-  protected async _sendAndProcess(
+  async #sendAndProcess<Fn extends MethodNames<M>>(
     tx: Encoded.Transaction,
-    options: SendOptions,
-  ): Promise<SendAndProcessReturnType> {
-    const txData = await send(tx, { ...this.$options, ...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();
@@ -280,15 +244,20 @@ class Contract<M extends ContractMethodsBase> {
     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, {
+    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, onAccount: opt.onAccount });
+    const { hash, ...other } = await this.#sendAndProcess(
+      tx,
+      'init',
+      { ...opt, onAccount: opt.onAccount },
+    );
     return {
       ...other,
       ...other.result?.log != null && {
@@ -305,14 +274,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`);
   }
 
@@ -328,21 +301,18 @@ class Contract<M extends ContractMethodsBase> {
     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<SendTransactionOptions, 'onAccount' | 'onNode'>
     & Omit<Parameters<typeof txDryRun>[2], 'onNode'>
     & { onAccount?: AccountBase; onNode?: Node; callStatic?: boolean } = {},
-  ): Promise<{
-      decodedResult?: any;
-      decodedEvents?: ReturnType<Contract<M>['$decodeEvents']>;
-    } & SendAndProcessReturnType> {
+  ): Promise<SendAndProcessReturnType & Partial<GetCallResultByHashReturnType<M, Fn>>> {
     const { callStatic, top, ...opt } = { ...this.$options, ...options };
-    const fnACI = this._getFunctionACI(fn);
+    const fnAci = this.#getFunctionAci(fn);
     const contractId = this.$options.address;
     const { onNode } = opt;
 
     if (fn == null) throw new MissingFunctionNameError();
     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) {
+    if (fn !== 'init' && opt.amount != null && opt.amount > 0 && !fnAci.payable) {
       throw new NotPayableFunctionError(opt.amount, fn);
     }
 
@@ -360,7 +330,6 @@ class Contract<M extends ContractMethodsBase> {
     }
     const callData = this._calldata.encode(this._name, fn, params);
 
-    let res: any;
     if (callStatic === true) {
       if (opt.nonce == null && top != null) {
         const topKey = typeof top === 'number' ? 'height' : 'hash';
@@ -370,41 +339,44 @@ class Contract<M extends ContractMethodsBase> {
       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, top });
-      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 (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,
-        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');
-      res = await this._sendAndProcess(tx, { ...opt, onAccount: opt.onAccount });
-    }
-    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);
+      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 });
   }
 
   /**
@@ -415,12 +387,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];
@@ -428,9 +398,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]]
       )))
@@ -452,15 +424,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;
@@ -515,7 +486,7 @@ class Contract<M extends ContractMethodsBase> {
       ) as Encoded.ContractAddress;
     }
 
-    if (address == null && sourceCode == null && bytecode == null) {
+    if (address == null && sourceCode == null && sourceCodePath == null && bytecode == null) {
       throw new MissingContractAddressError('Can\'t create instance by ACI without address');
     }
 
@@ -532,17 +503,32 @@ class Contract<M extends ContractMethodsBase> {
       else if (sourceCode != null) {
         if (onCompiler == null) throw new IllegalArgumentError('Can\'t validate bytecode without compiler');
         isValid = await onCompiler.validateBySourceCode(onChanBytecode, sourceCode, fileSystem);
+      } else if (sourceCodePath != null) {
+        if (onCompiler == null) throw new IllegalArgumentError('Can\'t validate bytecode without compiler');
+        isValid = await onCompiler.validate(onChanBytecode, sourceCodePath);
+      }
+      if (!isValid) {
+        throw new BytecodeMismatchError((sourceCode ?? sourceCodePath) != null ? 'source code' : 'bytecode');
       }
-      if (!isValid) throw new BytecodeMismatchError(sourceCode != null ? 'source code' : 'bytecode');
     }
 
     return new ContractWithMethods<M>({
-      onCompiler, onNode, sourceCode, bytecode, aci, address, fileSystem, ...otherOptions,
+      onCompiler,
+      onNode,
+      sourceCode,
+      sourceCodePath,
+      bytecode,
+      aci,
+      address,
+      fileSystem,
+      ...otherOptions,
     });
   }
 
   _aci: Aci;
 
+  #aciContract: ContractAci;
+
   _name: string;
 
   _calldata: Calldata;
@@ -560,8 +546,13 @@ class Contract<M extends ContractMethodsBase> {
     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]);
+    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;
 
     /**
@@ -580,7 +571,7 @@ class Contract<M extends ContractMethodsBase> {
      */
     Object.assign(
       this,
-      Object.fromEntries(this._aci.encodedAci.contract.functions
+      Object.fromEntries(this.#aciContract.functions
         .map(({ name, arguments: aciArgs, stateful }: FunctionAci) => {
           const callStatic = name !== 'init' && !stateful;
           return [

package/src/contract/compiler/Base.ts

@@ -1,27 +1,23 @@
 import { Encoded } from '../../utils/encoder';
-import { Aci as BaseAci } from '../../apis/compiler';
 
 interface FunctionAci {
   arguments: any[];
   name: string;
   payable: boolean;
-  returns: string;
+  returns: any;
   stateful: boolean;
 }
 
-export interface Aci extends BaseAci {
-  encodedAci: {
-    contract: {
-      name: string;
-      event: any;
-      kind: string;
-      state: any;
-      type_defs: any[];
-      functions: FunctionAci[];
-    };
+export type Aci = Array<{
+  contract?: {
+    name: string;
+    event?: any;
+    functions: FunctionAci[];
+    kind: string; // known values: 'contract_main'
+    payable: boolean;
+    typedefs: any[];
   };
-  externalEncodedAci: any[];
-}
+}>;
 
 /**
  * A base class for all compiler implementations

package/src/contract/compiler/Cli.ts

@@ -71,24 +71,18 @@ export default class CompilerCli extends CompilerBase {
     aci: Aci;
   }> {
     await this.#ensureCompatibleVersion;
-    let bytecode;
-    let aciCli;
     try {
-      [bytecode, aciCli] = await Promise.all([
+      const [bytecode, aci] = await Promise.all([
         this.#run(path),
         this.#run('--create_json_aci', path).then((res) => JSON.parse(res)),
       ]);
+      return {
+        bytecode: bytecode.trimEnd() as Encoded.ContractBytearray,
+        aci: aci as Aci,
+      };
     } catch (error) {
       throw new CompilerError(error.message);
     }
-    const aci = {
-      encodedAci: aciCli[0],
-      externalEncodedAci: aciCli.slice(1),
-    };
-    return {
-      bytecode: bytecode.trimEnd() as Encoded.ContractBytearray,
-      aci: aci as Aci,
-    };
   }
 
   async compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<{