@aeternity/aepp-sdk 11.0.1 → 12.0.0

package/es/contract/aci.mjs

@@ -1,174 +1,184 @@
 /*
- * ISC License (ISC)
- * Copyright (c) 2018 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.
- */
-
-/**
- * ContractACI module
- *
- * @module @aeternity/aepp-sdk/es/contract/aci
- * @export getContractInstance
- */
+* 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.
+*/
+// @ts-expect-error TODO remove
 import _aeternityAeppCalldata from '@aeternity/aepp-calldata';
 const {
   Encoder: Calldata
 } = _aeternityAeppCalldata;
-import { DRY_RUN_ACCOUNT, GAS_MAX } from "../tx/builder/schema.mjs";
-import TxObject from "../tx/tx-object.mjs";
-import { decode } from "../tx/builder/helpers.mjs";
-import { MissingContractDefError, MissingContractAddressError, InactiveContractError, BytecodeMismatchError, InternalError, DuplicateContractError, MissingFunctionNameError, InvalidMethodInvocationError, NotPayableFunctionError, TypeError, NodeInvocationError, IllegalArgumentError, NoSuchContractFunctionError, MissingEventDefinitionError, AmbiguousEventDefinitionError } from "../utils/errors.mjs";
-import { hash } from "../utils/crypto-ts.mjs";
+import { DRY_RUN_ACCOUNT, GAS_MAX, TX_TYPE, AMOUNT } from "../tx/builder/schema.mjs";
+import { buildContractIdByContractTx, unpackTx } from "../tx/builder/index.mjs";
+import { _buildTx } from "../tx/index.mjs";
+import { send } from "../spend.mjs";
+import { decode } from "../utils/encoder.mjs";
+import { MissingContractDefError, MissingContractAddressError, InactiveContractError, BytecodeMismatchError, DuplicateContractError, MissingFunctionNameError, InvalidMethodInvocationError, NotPayableFunctionError, TypeError, NodeInvocationError, IllegalArgumentError, NoSuchContractFunctionError, MissingEventDefinitionError, AmbiguousEventDefinitionError, UnexpectedTsError } from "../utils/errors.mjs";
+import { hash } from "../utils/crypto.mjs";
+import { getAccount, getContract, getContractByteCode, getKeyBlock, resolveName, txDryRun } from "../chain.mjs";
+
 /**
  * Generate contract ACI object with predefined js methods for contract usage - can be used for
  * creating a reference to already deployed contracts
- * @alias module:@aeternity/aepp-sdk/es/contract/aci
- * @param {Object} [options={}] Options object
- * @param {String} [options.source] Contract source code
- * @param {String} [options.bytecode] Contract bytecode
- * @param {Object} [options.aci] Contract ACI
- * @param {String} [options.contractAddress] Contract address
- * @param {Object} [options.filesystem] Contact source external namespaces map
- * @param {Boolean} [options.validateBytecode] Compare source code with on-chain version
- * @return {ContractInstance} JS Contract API
+ * @param options - Options object
+ * @returns JS Contract API
  * @example
+ * ```js
  * const contractIns = await aeSdk.getContractInstance({ source })
  * await contractIns.deploy([321]) or await contractIns.methods.init(321)
  * const callResult = await contractIns.call('setState', [123]) or
  * await contractIns.methods.setState.send(123, options)
  * const staticCallResult = await contractIns.call('setState', [123], { callStatic: true }) or
  * await contractIns.methods.setState.get(123, options)
- * Also you can call contract like: await contractIns.methods.setState(123, options)
+ * ```
+ * Also you can call contract like: `await contractIns.methods.setState(123, options)`
  * Then sdk decide to make on-chain or static call(dry-run API) transaction based on function is
  * stateful or not
  */
-
-export default async function getContractInstance() {
-  var _this = this;
-
+export default async function getContractInstance(_ref) {
   let {
+    onAccount,
+    onCompiler,
+    onNode,
     source,
     bytecode,
     aci: _aci,
     contractAddress,
-    filesystem = {},
+    fileSystem = {},
     validateBytecode,
     ...otherOptions
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  } = _ref;
 
-  if (!_aci && source) {
-    _aci = await this.compilerApi.generateACI({
+  if (_aci == null && source != null) {
+    // TODO: should be fixed when the compiledAci interface gets updated
+    _aci = await onCompiler.generateACI({
       code: source,
       options: {
-        filesystem
+        fileSystem
       }
     });
   }
 
-  if (!_aci) throw new MissingContractDefError();
-  contractAddress = contractAddress && (await this.resolveName(contractAddress, 'contract_pubkey', {
-    resolveByNode: true
-  }));
+  if (_aci == null) throw new MissingContractDefError();
+
+  if (contractAddress != null) {
+    contractAddress = await resolveName(contractAddress, 'contract_pubkey', {
+      resolveByNode: true,
+      onNode
+    });
+  }
 
-  if (!contractAddress && !source && !bytecode) {
+  if (contractAddress == null && source == null && bytecode == null) {
     throw new MissingContractAddressError('Can\'t create instance by ACI without address');
   }
 
-  if (contractAddress) {
-    const contract = await this.getContract(contractAddress);
-    if (!contract.active) throw new InactiveContractError(contractAddress);
+  if (contractAddress != null) {
+    const contract = await getContract(contractAddress, {
+      onNode
+    });
+    if (contract.active == null) throw new InactiveContractError(contractAddress);
   }
 
   const instance = {
     _aci,
-    _name: _aci.encoded_aci.contract.name,
-    calldata: new Calldata([_aci.encoded_aci, ..._aci.external_encoded_aci]),
+    _name: _aci.encodedAci.contract.name,
+    calldata: new Calldata([_aci.encodedAci, ..._aci.externalEncodedAci]),
     source,
     bytecode,
     deployInfo: {
       address: contractAddress
     },
-    options: { ...this.Ae.defaults,
+    options: {
+      onAccount,
+      onCompiler,
+      onNode,
+      amount: AMOUNT,
       callStatic: false,
-      filesystem,
+      fileSystem,
       ...otherOptions
     },
-    compilerVersion: this.compilerVersion
+    compile: async function (_options) {},
+    _estimateGas: async function (_name, _params, _options) {},
+    deploy: async function (_params, _options) {},
+    call: async function (_fn, _params, _options) {},
+
+    decodeEvents(_events, options) {},
+
+    methods: undefined
   };
 
-  if (validateBytecode) {
-    if (!contractAddress) throw new MissingContractAddressError('Can\'t validate bytecode without contract address');
-    const onChanBytecode = (await this.getContractByteCode(contractAddress)).bytecode;
-    const isValid = source ? await this.compilerApi.validateByteCode({
+  if (validateBytecode != null) {
+    if (contractAddress == null) throw new MissingContractAddressError('Can\'t validate bytecode without contract address');
+    const onChanBytecode = (await getContractByteCode(contractAddress, {
+      onNode
+    })).bytecode;
+    const isValid = source != null ? await onCompiler.validateByteCode({
       bytecode: onChanBytecode,
       source,
       options: instance.options
-    }).then(res => Object.entries(res).length === 0, () => false) : bytecode === onChanBytecode;
-    if (!isValid) throw new BytecodeMismatchError(source ? 'source' : 'bytecode');
+    }).then(() => true, () => false) : bytecode === onChanBytecode;
+    if (!isValid) throw new BytecodeMismatchError(source != null ? 'source' : 'bytecode');
   }
   /**
    * Compile contract
-   * @alias module:@aeternity/aepp-sdk/es/contract/aci
-   * @rtype () => ContractInstance: Object
-   * @return {String} bytecode bytecode
+   * @returns bytecode
    */
 
 
   instance.compile = async function () {
     let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    if (instance.bytecode) throw new IllegalArgumentError('Contract already compiled');
-    if (!instance.source) throw new IllegalArgumentError('Can\'t compile without source code');
-    const {
-      bytecode
-    } = await _this.compilerApi.compileContract({
+    if (instance.bytecode != null) throw new IllegalArgumentError('Contract already compiled');
+    if (instance.source == null) throw new IllegalArgumentError('Can\'t compile without source code');
+    instance.bytecode = (await onCompiler.compileContract({
       code: instance.source,
       options: { ...instance.options,
         ...options
       }
-    });
-    instance.bytecode = bytecode;
+    })).bytecode;
     return instance.bytecode;
   };
 
   const sendAndProcess = async (tx, options) => {
-    const txData = await this.send(tx, options);
+    options = { ...instance.options,
+      ...options
+    };
+    const txData = await send(tx, options);
     const result = {
       hash: txData.hash,
-      tx: TxObject({
-        tx: txData.rawTx
-      }),
+      tx: unpackTx(txData.rawTx),
       txData,
       rawTx: txData.rawTx
     };
-    if (options.waitMined === false) return result;
+    if (txData.blockHeight == null) return result;
     const {
       callInfo
-    } = await this.api.getTransactionInfoByHash(txData.hash);
+    } = await 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
 
-    await handleCallError(callInfo);
+    handleCallError(callInfo, tx);
     return { ...result,
       result: callInfo
     };
   };
 
-  const handleCallError = _ref => {
+  const handleCallError = (_ref2, transaction) => {
     let {
       returnType,
       returnValue
-    } = _ref;
-    let message; // TODO: ensure that it works correctly https://github.com/aeternity/aepp-calldata-js/issues/88
+    } = _ref2;
+    let message;
 
     switch (returnType) {
       case 'ok':
@@ -181,12 +191,9 @@ export default async function getContractInstance() {
       case 'error':
         message = decode(returnValue).toString();
         break;
-
-      default:
-        throw new InternalError(`Unknown returnType: ${returnType}`);
     }
 
-    throw new NodeInvocationError(message);
+    throw new NodeInvocationError(message, transaction);
   };
 
   instance._estimateGas = async (name, params, options) => {
@@ -202,35 +209,33 @@ export default async function getContractInstance() {
   };
   /**
    * Deploy contract
-   * @alias module:@aeternity/aepp-sdk/es/contract/aci
-   * @rtype (init: Array, options: Object) => ContractInstance: Object
-   * @param {Array} params Contract init function arguments array
-   * @param {Object} [options] options
-   * @return {Object} deploy info
+   * @param params - Contract init function arguments array
+   * @param options - Options
+   * @returns deploy info
    */
 
 
   instance.deploy = async function () {
-    var _opt$gas;
+    var _opt$gasLimit;
 
     let params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
     let options = arguments.length > 1 ? arguments[1] : undefined;
     const opt = { ...instance.options,
       ...options
     };
-    if (!instance.bytecode) await instance.compile(opt);
-    if (opt.callStatic) return instance.call('init', params, opt);
-    if (instance.deployInfo.address) throw new DuplicateContractError();
-    const ownerId = await _this.address(opt);
-    const {
-      tx,
-      contractId
-    } = await _this.contractCreateTx({ ...opt,
-      gas: (_opt$gas = opt.gas) !== null && _opt$gas !== void 0 ? _opt$gas : await instance._estimateGas('init', params, opt),
+    if (instance.bytecode == null) await instance.compile(opt); // @ts-expect-error
+
+    if (opt.callStatic === true) return await instance.call('init', params, opt);
+    if (instance.deployInfo.address != null) throw new DuplicateContractError();
+    const ownerId = await opt.onAccount.address(options);
+    const tx = await _buildTx(TX_TYPE.contractCreate, { ...opt,
+      gasLimit: (_opt$gasLimit = opt.gasLimit) !== null && _opt$gasLimit !== void 0 ? _opt$gasLimit : await instance._estimateGas('init', params, opt),
       callData: instance.calldata.encode(instance._name, 'init', params),
       code: instance.bytecode,
-      ownerId
+      ownerId,
+      onNode
     });
+    const contractId = buildContractIdByContractTx(tx);
     const {
       hash,
       rawTx,
@@ -249,15 +254,18 @@ export default async function getContractInstance() {
   };
   /**
    * Get function schema from contract ACI object
-   * @param {String} name Function name
-   * @return {Object} function ACI
+   * @param name - Function name
+   * @returns function ACI
    */
 
 
   function getFunctionACI(name) {
-    const fn = instance._aci.encoded_aci.contract.functions.find(f => f.name === name);
+    const fn = instance._aci.encodedAci.contract.functions.find(f => f.name === name);
+
+    if (fn != null) {
+      return fn;
+    }
 
-    if (fn) return fn;
     if (name === 'init') return {
       payable: false
     };
@@ -265,13 +273,10 @@ export default async function getContractInstance() {
   }
   /**
    * Call contract function
-   * @alias module:@aeternity/aepp-sdk/es/contract/aci
-   * @rtype (init: Array, options: Object = { callStatic: false }) => CallResult: Object
-   * @param {String} fn Function name
-   * @param {Array} params Array of function arguments
-   * @param {Object} [options={}] Array of function arguments
-   * @param {Boolean} [options.callStatic=false] Static function call
-   * @return {Object} CallResult
+   * @param fn - Function name
+   * @param params - Array of function arguments
+   * @param options - Array of function arguments
+   * @returns CallResult
    */
 
 
@@ -283,53 +288,67 @@ export default async function getContractInstance() {
     };
     const fnACI = getFunctionACI(fn);
     const contractId = instance.deployInfo.address;
-    if (!fn) throw new MissingFunctionNameError();
-    if (fn === 'init' && !opt.callStatic) throw new InvalidMethodInvocationError('"init" can be called only via dryRun');
-    if (!contractId && fn !== 'init') throw new InvalidMethodInvocationError('You need to deploy contract before calling!');
-    if (fn !== 'init' && opt.amount > 0 && fnACI.payable === false) throw new NotPayableFunctionError(`You try to pay "${opt.amount}" to function "${fn}" which is not payable. Only payable function can accept coins`);
-    const callerId = await _this.address(opt).catch(error => {
-      if (opt.callStatic) return DRY_RUN_ACCOUNT.pub;else throw error;
+    if (fn == null) throw new MissingFunctionNameError();
+    if (fn === 'init' && opt.callStatic === false) throw new InvalidMethodInvocationError('"init" can be called only via dryRun');
+    if (contractId == null && fn !== 'init') throw new InvalidMethodInvocationError('You need to deploy contract before calling!');
+    if (fn !== 'init' && opt.amount > 0 && fnACI.payable === false) throw new NotPayableFunctionError(opt.amount, fn);
+    const callerId = await Promise.resolve().then(() => opt.onAccount.address(opt)).catch(error => {
+      if (opt.callStatic === true) return DRY_RUN_ACCOUNT.pub;else throw error;
     });
     const callData = instance.calldata.encode(instance._name, fn, params);
     let res;
 
-    if (opt.callStatic) {
-      var _opt$gas2, _opt$nonce;
+    if (opt.callStatic === true) {
+      var _opt$gasLimit2;
 
       if (typeof opt.top === 'number') {
-        opt.top = (await _this.getKeyBlock(opt.top)).hash;
+        opt.top = (await getKeyBlock(opt.top, {
+          onNode
+        })).hash;
       }
 
       const txOpt = { ...opt,
-        gas: (_opt$gas2 = opt.gas) !== null && _opt$gas2 !== void 0 ? _opt$gas2 : GAS_MAX,
-        callData,
-        nonce: (_opt$nonce = opt.nonce) !== null && _opt$nonce !== void 0 ? _opt$nonce : opt.top && (await _this.getAccount(callerId, {
-          hash: opt.top
-        })).nonce + 1
+        onNode,
+        gasLimit: (_opt$gasLimit2 = opt.gasLimit) !== null && _opt$gasLimit2 !== void 0 ? _opt$gasLimit2 : GAS_MAX,
+        callData
       };
-      const tx = fn === 'init' ? (await _this.contractCreateTx({ ...txOpt,
+
+      if (opt.nonce == null && opt.top != null) {
+        opt.nonce = (await getAccount(callerId, {
+          hash: opt.top,
+          onNode
+        })).nonce + 1;
+      }
+
+      const tx = await (fn === 'init' ? _buildTx(TX_TYPE.contractCreate, { ...txOpt,
         code: instance.bytecode,
         ownerId: callerId
-      })).tx : await _this.contractCallTx({ ...txOpt,
+      }) : _buildTx(TX_TYPE.contractCall, { ...txOpt,
         callerId,
         contractId
-      });
+      }));
       const {
         callObj,
         ...dryRunOther
-      } = await _this.txDryRun(tx, callerId, opt);
-      await handleCallError(callObj);
+      } = await txDryRun(tx, callerId, {
+        onNode,
+        ...opt
+      });
+      if (callObj == null) throw new UnexpectedTsError();
+      handleCallError({
+        returnType: callObj.returnType,
+        returnValue: callObj.returnValue
+      }, tx);
       res = { ...dryRunOther,
-        tx: TxObject({
-          tx
-        }),
+        tx: unpackTx(tx),
         result: callObj
       };
     } else {
-      var _opt$gas3;
+      var _opt$gasLimit3;
 
-      const tx = await _this.contractCallTx({ ...opt,
-        gas: (_opt$gas3 = opt.gas) !== null && _opt$gas3 !== void 0 ? _opt$gas3 : await instance._estimateGas(fn, params, opt),
+      const tx = await _buildTx(TX_TYPE.contractCall, { ...opt,
+        onNode,
+        gasLimit: (_opt$gasLimit3 = opt.gasLimit) !== null && _opt$gasLimit3 !== void 0 ? _opt$gasLimit3 : await instance._estimateGas(fn, params, opt),
         callerId,
         contractId,
         callData
@@ -337,53 +356,52 @@ export default async function getContractInstance() {
       res = await sendAndProcess(tx, opt);
     }
 
-    if (opt.waitMined || opt.callStatic) {
-      res.decodedResult = fnACI.returns && fnACI.returns !== 'unit' && fn !== 'init' && instance.calldata.decode(instance._name, fn, res.result.returnValue);
+    if (opt.callStatic === true || res.txData.blockHeight != null) {
+      res.decodedResult = fnACI.returns != null && fnACI.returns !== 'unit' && fn !== 'init' && instance.calldata.decode(instance._name, fn, res.result.returnValue);
       res.decodedEvents = instance.decodeEvents(res.result.log, opt);
     }
 
     return res;
   };
   /**
-   * @param {String} address Contract address that emitted event
-   * @param {BigInt} nameHash Hash of emitted event name
-   * @param {Object} [options]
-   * @param {Object} [options.contractAddressToName] Map of contract addresses to their names
-   * @return {String} Contract name
-   * @throws {MissingEventDefinitionError}
-   * @throws {AmbiguousEventDefinitionError}
+   * @param address - Contract address that emitted event
+   * @param nameHash - Hash of emitted event name
+   * @param options - Options
+   * @returns Contract name
+   * @throws {@link MissingEventDefinitionError}
+   * @throws {@link AmbiguousEventDefinitionError}
    */
 
 
-  function getContractNameByEvent(address, nameHash, _ref2) {
+  function getContractNameByEvent(address, nameHash, _ref3) {
     let {
       contractAddressToName
-    } = _ref2;
+    } = _ref3;
     const addressToName = { ...instance.options.contractAddressToName,
       ...contractAddressToName
     };
-    if (addressToName[address]) return addressToName[address];
-    const matchedEvents = [instance._aci.encoded_aci, ...instance._aci.external_encoded_aci].filter(_ref3 => {
+    if (addressToName[address] != null) return addressToName[address];
+    const matchedEvents = [instance._aci.encodedAci, ...instance._aci.externalEncodedAci].filter(_ref4 => {
       let {
         contract
-      } = _ref3;
+      } = _ref4;
       return contract === null || contract === void 0 ? void 0 : contract.event;
-    }).map(_ref4 => {
+    }).map(_ref5 => {
       let {
         contract
-      } = _ref4;
+      } = _ref5;
       return [contract.name, contract.event.variant];
-    }).map(_ref5 => {
-      let [name, events] = _ref5;
+    }).map(_ref6 => {
+      let [name, events] = _ref6;
       return events.map(event => [name, Object.keys(event)[0]]);
-    }).flat().filter(_ref6 => {
-      let [, eventName] = _ref6;
+    }).flat().filter(_ref7 => {
+      let [, eventName] = _ref7;
       return BigInt('0x' + hash(eventName).toString('hex')) === nameHash;
     });
 
     switch (matchedEvents.length) {
       case 0:
-        throw new MissingEventDefinitionError(nameHash, address);
+        throw new MissingEventDefinitionError(nameHash.toString(), address);
 
       case 1:
         return matchedEvents[0][0];
@@ -394,13 +412,9 @@ export default async function getContractInstance() {
   }
   /**
    * Decode Events
-   * @alias module:@aeternity/aepp-sdk/es/contract/aci
-   * @rtype (events: Array) => DecodedEvents: Array
-   * @param {Array} events Array of encoded events (callRes.result.log)
-   * @param {Object} [options]
-   * @param {Boolean} [options.omitUnknown] Omit events that can't be decoded in case ACI is not
-   * complete
-   * @return {Object} DecodedEvents
+   * @param events - Array of encoded events (callRes.result.log)
+   * @param options - Options
+   * @returns DecodedEvents
    */
 
 
@@ -416,7 +430,7 @@ export default async function getContractInstance() {
       try {
         contractName = getContractNameByEvent(event.address, topics[0], opt);
       } catch (error) {
-        if (omitUnknown && error instanceof MissingEventDefinitionError) return null;
+        if ((omitUnknown !== null && omitUnknown !== void 0 ? omitUnknown : false) && error instanceof MissingEventDefinitionError) return null;
         throw error;
       }
 
@@ -430,38 +444,43 @@ export default async function getContractInstance() {
           address: event.address
         }
       };
-    }).filter(e => e);
+    }).filter(e => e != null);
   };
   /**
    * Generate proto function based on contract function using Contract ACI schema
    * All function can be called like:
-   * 'await contract.methods.testFunction()' -> then sdk will decide to use dry-run or send tx
+   * ```js
+   * await contract.methods.testFunction()
+   * ```
+   * then sdk will decide to use dry-run or send tx
    * on-chain base on if function stateful or not.
-   * Also you can manually do that:
-   * `await contract.methods.testFunction.get()` -> use call-static(dry-run)
-   * `await contract.methods.testFunction.send()` -> send tx on-chain
+   * Also, you can manually do that:
+   * ```js
+   * await contract.methods.testFunction.get() // use call-static (dry-run)
+   * await contract.methods.testFunction.send() // send tx on-chain
+   * ```
    */
 
 
-  instance.methods = Object.fromEntries(instance._aci.encoded_aci.contract.functions.map(_ref7 => {
+  instance.methods = Object.fromEntries(instance._aci.encodedAci.contract.functions.map(_ref8 => {
     let {
       name,
       arguments: aciArgs,
       stateful
-    } = _ref7;
+    } = _ref8;
 
-    const genHandler = callStatic => function () {
+    const genHandler = callStatic => async function () {
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
         args[_key] = arguments[_key];
       }
 
       const options = args.length === aciArgs.length + 1 ? args.pop() : {};
       if (typeof options !== 'object') throw new TypeError(`Options should be an object: ${options}`);
-      if (name === 'init') return instance.deploy(args, {
+      if (name === 'init') return await instance.deploy(args, {
         callStatic,
         ...options
       });
-      return instance.call(name, args, {
+      return await instance.call(name, args, {
         callStatic,
         ...options
       });