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

package/es/contract/Contract.mjs

@@ -1,24 +1,9 @@
-import _buffer from "buffer";
-const {
-  Buffer: _Buffer
-} = _buffer;
-/*
-* 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.
-*/
-
+import _classPrivateFieldSet from "@babel/runtime-corejs3/helpers/classPrivateFieldSet";
+import _classPrivateFieldGet from "@babel/runtime-corejs3/helpers/classPrivateFieldGet";
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 /**
  * Contract module - routines to interact with the æternity contract
  *
@@ -32,15 +17,16 @@ const {
 } = _aeternityAeppCalldata;
 import { DRY_RUN_ACCOUNT } from "../tx/builder/schema.mjs";
 import { Tag } from "../tx/builder/constants.mjs";
-import { buildContractIdByContractTx, unpackTx } from "../tx/builder/index.mjs";
-import { _buildTx } from "../tx/index.mjs";
-import { send } from "../spend.mjs";
+import { buildContractIdByContractTx, unpackTx, buildTxAsync, buildTxHash } from "../tx/builder/index.mjs";
 import { decode } from "../utils/encoder.mjs";
-import { MissingContractDefError, MissingContractAddressError, InactiveContractError, BytecodeMismatchError, DuplicateContractError, MissingFunctionNameError, InvalidMethodInvocationError, NotPayableFunctionError, TypeError, NodeInvocationError, IllegalArgumentError, NoSuchContractFunctionError, MissingEventDefinitionError, AmbiguousEventDefinitionError, UnexpectedTsError, InternalError, NoWalletConnectedError } from "../utils/errors.mjs";
+import { MissingContractDefError, MissingContractAddressError, InactiveContractError, BytecodeMismatchError, DuplicateContractError, MissingFunctionNameError, InvalidMethodInvocationError, NotPayableFunctionError, TypeError as _TypeError, NodeInvocationError, IllegalArgumentError, NoSuchContractFunctionError, MissingEventDefinitionError, AmbiguousEventDefinitionError, UnexpectedTsError, InternalError, NoWalletConnectedError, ContractError } from "../utils/errors.mjs";
 import { hash as calcHash } from "../utils/crypto.mjs";
-import { getAccount, getContract, getContractByteCode, getKeyBlock, resolveName, txDryRun } from "../chain.mjs";
-import { concatBuffers } from "../utils/other.mjs";
-import { isNameValid, produceNameId } from "../tx/builder/helpers.mjs";
+import { getAccount, getContract, getContractByteCode, resolveName, txDryRun, sendTransaction } from "../chain.mjs";
+var _getCallResult = /*#__PURE__*/new WeakSet();
+var _sendAndProcess = /*#__PURE__*/new WeakSet();
+var _getFunctionAci = /*#__PURE__*/new WeakSet();
+var _getContractNameByEvent = /*#__PURE__*/new WeakSet();
+var _aciContract = /*#__PURE__*/new WeakMap();
 /**
  * Generate contract ACI object with predefined js methods for contract usage - can be used for
  * creating a reference to already deployed contracts
@@ -59,54 +45,6 @@ import { isNameValid, produceNameId } from "../tx/builder/helpers.mjs";
  * stateful or not
  */
 class Contract {
-  /**
-   * 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() {
-    let ids = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-    let _options = arguments.length > 1 ? arguments[1] : undefined;
-    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
@@ -114,56 +52,21 @@ class Contract {
   async $compile() {
     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;
+    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;
   }
-  _handleCallError(_ref, transaction) {
-    let {
-      returnType,
-      returnValue
-    } = _ref;
-    let message;
-    switch (returnType) {
-      case 'ok':
-        return;
-      case 'revert':
-        message = this._calldata.decodeFateString(returnValue);
-        break;
-      case 'error':
-        message = decode(returnValue).toString();
-        break;
-      default:
-        throw new InternalError(`Unknown return type: ${returnType}`);
-    }
-    throw new NodeInvocationError(message, transaction);
-  }
-  async _sendAndProcess(tx, options) {
-    options = {
-      ...this.$options,
-      ...options
-    };
-    const txData = await send(tx, options);
-    const result = {
-      hash: txData.hash,
-      tx: unpackTx(txData.rawTx),
-      txData,
-      rawTx: txData.rawTx
-    };
-    if (txData.blockHeight == null) return result;
+  async $getCallResultByTxHash(hash, fnName, options) {
     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);
+    } = await this.$options.onNode.getTransactionInfoByHash(hash);
+    if (callInfo == null) {
+      throw new ContractError(`callInfo is not available for transaction ${hash}`);
+    }
+    const callInfoTyped = callInfo;
     return {
-      ...result,
-      result: callInfo
+      ..._classPrivateMethodGet(this, _getCallResult, _getCallResult2).call(this, callInfoTyped, fnName, undefined, options),
+      result: callInfoTyped
     };
   }
   async _estimateGas(name, params) {
@@ -189,17 +92,26 @@ class Contract {
    * @returns deploy info
    */
   async $deploy(params, options) {
-    var _opt$gasLimit;
-    const opt = {
+    var _opt$gasLimit, _other$result;
+    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 = opt.gasLimit) !== null && _opt$gasLimit !== void 0 ? _opt$gasLimit : await this._estimateGas('init', params, opt),
       callData: this._calldata.encode(this._name, 'init', params),
       code: this.$options.bytecode,
@@ -209,9 +121,15 @@ class Contract {
     const {
       hash,
       ...other
-    } = await this._sendAndProcess(tx, opt);
+    } = await _classPrivateMethodGet(this, _sendAndProcess, _sendAndProcess2).call(this, tx, 'init', {
+      ...opt,
+      onAccount: opt.onAccount
+    });
     return {
       ...other,
+      ...(((_other$result = other.result) === null || _other$result === void 0 ? void 0 : _other$result.log) != null && {
+        decodedEvents: this.$decodeEvents(other.result.log, opt)
+      }),
       owner: ownerId,
       transaction: hash,
       address: this.$options.address
@@ -223,16 +141,6 @@ class Contract {
    * @param name - Function name
    * @returns function ACI
    */
-  _getFunctionACI(name) {
-    const fn = this._aci.encodedAci.contract.functions.find(f => f.name === name);
-    if (fn != null) {
-      return fn;
-    }
-    if (name === 'init') return {
-      payable: false
-    };
-    throw new NoSuchContractFunctionError(`Function ${name} doesn't exist in contract`);
-  }
 
   /**
    * Call contract function
@@ -242,58 +150,63 @@ class Contract {
    * @returns CallResult
    */
   async $call(fn, params) {
+    var _opt$gasLimit2;
     let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    const opt = {
+    const {
+      callStatic,
+      top,
+      ...opt
+    } = {
       ...this.$options,
       ...options
     };
-    const fnACI = this._getFunctionACI(fn);
+    const fnAci = _classPrivateMethodGet(this, _getFunctionAci, _getFunctionAci2).call(this, 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 && (error instanceof TypeError && error.message === 'Account should be an address (ak-prefixed string), or instance of AccountBase, got undefined instead' || error instanceof NoWalletConnectedError);
+      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);
       if (!useFallbackAccount) throw error;
       callerId = DRY_RUN_ACCOUNT.pub;
     }
     const callData = this._calldata.encode(this._name, fn, params);
-    let res;
-    if (opt.callStatic === true) {
-      if (typeof opt.top === 'number') {
-        opt.top = (await getKeyBlock(opt.top, {
+    if (callStatic === true) {
+      if (opt.nonce == null && top != null) {
+        const topKey = typeof top === 'number' ? 'height' : 'hash';
+        opt.nonce = (await getAccount(callerId, {
+          [topKey]: top,
           onNode
-        })).hash;
+        })).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, {
+        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, {
+        tx = await buildTxAsync({
           ...txOpt,
+          tag: Tag.ContractCallTx,
           callerId,
           contractId
         });
@@ -301,34 +214,39 @@ class Contract {
       const {
         callObj,
         ...dryRunOther
-      } = await txDryRun(tx, callerId, opt);
-      if (callObj == null) throw new UnexpectedTsError();
-      this._handleCallError({
-        returnType: callObj.returnType,
-        returnValue: callObj.returnValue
-      }, tx);
-      res = {
+      } = await txDryRun(tx, callerId, {
+        ...opt,
+        top
+      });
+      if (callObj == null) {
+        throw new InternalError(`callObj is not available for transaction ${tx}`);
+      }
+      const callInfoTyped = callObj;
+      return {
         ...dryRunOther,
+        ..._classPrivateMethodGet(this, _getCallResult, _getCallResult2).call(this, callInfoTyped, fn, tx, opt),
         tx: unpackTx(tx),
-        result: callObj
+        result: callInfoTyped,
+        rawTx: tx,
+        hash: buildTxHash(tx),
+        txData: undefined
       };
-    } else {
-      var _opt$gasLimit2;
-      if (contractId == null) throw new MissingContractAddressError('Can\'t call contract without address');
-      const tx = await _buildTx(Tag.ContractCallTx, {
-        ...opt,
-        gasLimit: (_opt$gasLimit2 = opt.gasLimit) !== null && _opt$gasLimit2 !== void 0 ? _opt$gasLimit2 : 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);
     }
-    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$gasLimit2 = opt.gasLimit) !== null && _opt$gasLimit2 !== void 0 ? _opt$gasLimit2 : 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 _classPrivateMethodGet(this, _sendAndProcess, _sendAndProcess2).call(this, tx, fn, {
+      ...opt,
+      onAccount: opt.onAccount
+    });
   }
 
   /**
@@ -339,47 +257,6 @@ class Contract {
    * @throws {@link MissingEventDefinitionError}
    * @throws {@link AmbiguousEventDefinitionError}
    */
-  _getContractNameByEvent(ctAddress, nameHash, _ref2) {
-    let {
-      contractAddressToName
-    } = _ref2;
-    const addressToName = {
-      ...this.$options.contractAddressToName,
-      ...contractAddressToName
-    };
-    if (addressToName[ctAddress] != null) return addressToName[ctAddress];
-
-    // TODO: consider using a third-party library
-    const isEqual = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-    const matchedEvents = [this._aci.encodedAci, ...this._aci.externalEncodedAci].filter(_ref3 => {
-      let {
-        contract
-      } = _ref3;
-      return contract === null || contract === void 0 ? void 0 : contract.event;
-    }).map(_ref4 => {
-      let {
-        contract
-      } = _ref4;
-      return [contract.name, contract.event.variant];
-    }).map(_ref5 => {
-      let [name, events] = _ref5;
-      return events.map(event => [name, Object.keys(event)[0], Object.values(event)[0]]);
-    }).flat().filter(_ref6 => {
-      let [, eventName] = _ref6;
-      return BigInt(`0x${calcHash(eventName).toString('hex')}`) === nameHash;
-    }).filter((_ref7, idx, arr) => {
-      let [,, type] = _ref7;
-      return !arr.slice(0, idx).some(el => isEqual(el[2], type));
-    });
-    switch (matchedEvents.length) {
-      case 0:
-        throw new MissingEventDefinitionError(nameHash.toString(), ctAddress);
-      case 1:
-        return matchedEvents[0][0];
-      default:
-        throw new AmbiguousEventDefinitionError(ctAddress, matchedEvents);
-    }
-  }
 
   /**
    * Decode Events
@@ -396,7 +273,7 @@ class Contract {
       const topics = event.topics.map(t => BigInt(t));
       let contractName;
       try {
-        contractName = this._getContractNameByEvent(event.address, topics[0], opt);
+        contractName = _classPrivateMethodGet(this, _getContractNameByEvent, _getContractNameByEvent2).call(this, event.address, topics[0], opt);
       } catch (error) {
         if ((omitUnknown !== null && omitUnknown !== void 0 ? omitUnknown : false) && error instanceof MissingEventDefinitionError) return null;
         throw error;
@@ -413,26 +290,28 @@ class Contract {
       };
     }).filter(e => e != null);
   }
-  static async initialize(_ref8) {
+  static async initialize(_ref) {
     let {
       onCompiler,
       onNode,
-      sourceCode,
       bytecode,
       aci,
       address,
+      sourceCodePath,
+      sourceCode,
       fileSystem,
       validateBytecode,
       ...otherOptions
-    } = _ref8;
-    if (aci == null && sourceCode != null) {
-      // TODO: should be fixed when the compiledAci interface gets updated
-      aci = await onCompiler.generateACI({
-        code: sourceCode,
-        options: {
-          fileSystem
-        }
-      });
+    } = _ref;
+    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) {
+        var _bytecode;
+        aci = res.aci;
+        (_bytecode = bytecode) !== null && _bytecode !== void 0 ? _bytecode : bytecode = res.bytecode;
+      }
     }
     if (aci == null) throw new MissingContractDefError();
     if (address != null) {
@@ -450,18 +329,16 @@ class Contract {
       });
       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 = 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');
     }
     return new ContractWithMethods({
@@ -475,19 +352,29 @@ class Contract {
       ...otherOptions
     });
   }
-  constructor(_ref9) {
+  constructor(_ref2) {
     var _this = this;
     let {
       aci,
       ...otherOptions
-    } = _ref9;
+    } = _ref2;
+    _classPrivateMethodInitSpec(this, _getContractNameByEvent);
+    _classPrivateMethodInitSpec(this, _getFunctionAci);
+    _classPrivateMethodInitSpec(this, _sendAndProcess);
+    _classPrivateMethodInitSpec(this, _getCallResult);
+    _classPrivateFieldInitSpec(this, _aciContract, {
+      writable: true,
+      value: void 0
+    });
     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`);
+    }
+    _classPrivateFieldSet(this, _aciContract, aciLast.contract);
+    this._name = _classPrivateFieldGet(this, _aciContract).name;
+    this._calldata = new Calldata(aci);
+    this.$options = otherOptions;
 
     /**
      * Generate proto function based on contract function using Contract ACI schema
@@ -503,19 +390,19 @@ class Contract {
      * await contract.testFunction({ callStatic: false }) // send tx on-chain
      * ```
      */
-    Object.assign(this, Object.fromEntries(this._aci.encodedAci.contract.functions.map(_ref10 => {
+    Object.assign(this, Object.fromEntries(_classPrivateFieldGet(this, _aciContract).functions.map(_ref3 => {
       let {
         name,
         arguments: aciArgs,
         stateful
-      } = _ref10;
+      } = _ref3;
       const callStatic = name !== 'init' && !stateful;
       return [name, 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 (typeof options !== 'object') throw new _TypeError(`Options should be an object: ${options}`);
         if (name === 'init') return _this.$deploy(args, {
           callStatic,
           ...options
@@ -528,6 +415,99 @@ class Contract {
     })));
   }
 }
+function _getCallResult2(_ref4, fnName, transaction, options) {
+  let {
+    returnType,
+    returnValue,
+    log
+  } = _ref4;
+  let message;
+  switch (returnType) {
+    case 'ok':
+      {
+        const fnAci = _classPrivateMethodGet(this, _getFunctionAci, _getFunctionAci2).call(this, fnName);
+        return {
+          decodedResult: this._calldata.decode(this._name, fnAci.name, returnValue),
+          decodedEvents: this.$decodeEvents(log, options)
+        };
+      }
+    case 'revert':
+      message = this._calldata.decodeFateString(returnValue);
+      break;
+    case 'error':
+      message = decode(returnValue).toString();
+      break;
+    default:
+      throw new InternalError(`Unknown return type: ${returnType}`);
+  }
+  throw new NodeInvocationError(message, transaction);
+}
+async function _sendAndProcess2(tx, fnName, options) {
+  const txData = await sendTransaction(tx, {
+    ...this.$options,
+    ...options
+  });
+  return {
+    hash: txData.hash,
+    tx: unpackTx(txData.rawTx),
+    txData,
+    rawTx: txData.rawTx,
+    ...(txData.blockHeight != null && (await this.$getCallResultByTxHash(txData.hash, fnName, options)))
+  };
+}
+function _getFunctionAci2(name) {
+  const fn = _classPrivateFieldGet(this, _aciContract).functions.find(f => f.name === name);
+  if (fn != null) {
+    return fn;
+  }
+  if (name === 'init') {
+    return {
+      arguments: [],
+      name: 'init',
+      payable: false,
+      returns: 'unit',
+      stateful: true
+    };
+  }
+  throw new NoSuchContractFunctionError(`Function ${name} doesn't exist in contract`);
+}
+function _getContractNameByEvent2(ctAddress, nameHash, _ref5) {
+  let {
+    contractAddressToName
+  } = _ref5;
+  const addressToName = {
+    ...this.$options.contractAddressToName,
+    ...contractAddressToName
+  };
+  if (addressToName[ctAddress] != null) return addressToName[ctAddress];
+
+  // TODO: consider using a third-party library
+  const isEqual = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+  const contracts = this._aci.map(_ref6 => {
+    let {
+      contract
+    } = _ref6;
+    return contract;
+  }).filter(contract => contract === null || contract === void 0 ? void 0 : contract.event);
+  const matchedEvents = contracts.map(contract => [contract.name, contract.event.variant]).map(_ref7 => {
+    let [name, events] = _ref7;
+    return events.map(event => [name, Object.keys(event)[0], Object.values(event)[0]]);
+  }).flat().filter(_ref8 => {
+    let [, eventName] = _ref8;
+    return BigInt(`0x${calcHash(eventName).toString('hex')}`) === nameHash;
+  }).filter((_ref9, idx, arr) => {
+    let [,, type] = _ref9;
+    return !arr.slice(0, idx).some(el => isEqual(el[2], type));
+  });
+  switch (matchedEvents.length) {
+    case 0:
+      throw new MissingEventDefinitionError(nameHash.toString(), ctAddress);
+    case 1:
+      return matchedEvents[0][0];
+    default:
+      throw new AmbiguousEventDefinitionError(ctAddress, matchedEvents);
+  }
+}
 // eslint-disable-next-line @typescript-eslint/no-redeclare
 const ContractWithMethods = Contract;
 export default ContractWithMethods;