@aeternity/aepp-sdk 10.0.0 → 12.0.0

package/es/contract/Compiler.mjs

@@ -0,0 +1,67 @@
+/*
+ * 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 { Compiler as CompilerApi } from "../apis/compiler/index.mjs";
+import { genErrorFormatterPolicy, genVersionCheckPolicy } from "../utils/autorest.mjs";
+
+/**
+ * Contract Compiler
+ *
+ * This class include api call's related to contract compiler functionality.
+ * @example Compiler('COMPILER_URL')
+ */
+export default class Compiler extends CompilerApi {
+  /**
+   * @param compilerUrl - Url for compiler API
+   * @param options - Options
+   * @param options.ignoreVersion - Don't check compiler version
+   */
+  constructor(compilerUrl) {
+    let {
+      ignoreVersion
+    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super(compilerUrl, {
+      allowInsecureConnection: true,
+      additionalPolicies: [genErrorFormatterPolicy(body => {
+        let message = '';
+
+        if ('reason' in body) {
+          message += ' ' + body.reason + (body.parameter != null ? ` in ${body.parameter}` : '') + ( // TODO: revising after improving documentation https://github.com/aeternity/aesophia_http/issues/78
+          body.info != null ? ` (${JSON.stringify(body.info)})` : '');
+        }
+
+        if (Array.isArray(body)) {
+          message += '\n' + body.map(e => `${e.type}:${e.pos.line}:${e.pos.col}: ${e.message}${e.context != null ? `(${e.context})` : ''}`).map(e => e.trim()) // TODO: remove after fixing https://github.com/aeternity/aesophia_http/issues/80
+          .join('\n');
+        }
+
+        return message;
+      })]
+    });
+
+    if (ignoreVersion !== true) {
+      const versionPromise = this.aPIVersion().then(_ref => {
+        let {
+          apiVersion
+        } = _ref;
+        return apiVersion;
+      });
+      this.pipeline.addPolicy(genVersionCheckPolicy('compiler', '/api-version', versionPromise, '6.1.0', '7.0.0'));
+    }
+  }
+
+}
+//# sourceMappingURL=Compiler.mjs.map

package/es/contract/Compiler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Compiler.mjs","names":["Compiler","CompilerApi","genErrorFormatterPolicy","genVersionCheckPolicy","constructor","compilerUrl","ignoreVersion","allowInsecureConnection","additionalPolicies","body","message","reason","parameter","info","JSON","stringify","Array","isArray","map","e","type","pos","line","col","context","trim","join","versionPromise","aPIVersion","then","apiVersion","pipeline","addPolicy"],"sources":["../../src/contract/Compiler.ts"],"sourcesContent":["/*\n * ISC License (ISC)\n * Copyright (c) 2022 aeternity developers\n *\n *  Permission to use, copy, modify, and/or distribute this software for any\n *  purpose with or without fee is hereby granted, provided that the above\n *  copyright notice and this permission notice appear in all copies.\n *\n *  THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\n *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\n *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\n *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\n *  PERFORMANCE OF THIS SOFTWARE.\n */\nimport { Compiler as CompilerApi, ErrorModel, CompilerError } from '../apis/compiler'\nimport { genErrorFormatterPolicy, genVersionCheckPolicy } from '../utils/autorest'\n\ntype GeneralCompilerError = ErrorModel & {\n  info?: object\n  parameter?: string\n}\n\n/**\n * Contract Compiler\n *\n * This class include api call's related to contract compiler functionality.\n * @example Compiler('COMPILER_URL')\n */\nexport default class Compiler extends CompilerApi {\n  /**\n   * @param compilerUrl - Url for compiler API\n   * @param options - Options\n   * @param options.ignoreVersion - Don't check compiler version\n   */\n  constructor (compilerUrl: string, { ignoreVersion }: { ignoreVersion?: boolean } = {}) {\n    super(compilerUrl, {\n      allowInsecureConnection: true,\n      additionalPolicies: [\n        genErrorFormatterPolicy((body: GeneralCompilerError | CompilerError[]) => {\n          let message = ''\n          if ('reason' in body) {\n            message += ' ' + body.reason +\n              (body.parameter != null ? ` in ${body.parameter}` : '') +\n              // TODO: revising after improving documentation https://github.com/aeternity/aesophia_http/issues/78\n              (body.info != null ? ` (${JSON.stringify(body.info)})` : '')\n          }\n          if (Array.isArray(body)) {\n            message += '\\n' + body\n              .map(e => `${e.type}:${e.pos.line}:${e.pos.col}: ${e.message}${e.context != null ? `(${e.context})` : ''}`)\n              .map(e => e.trim()) // TODO: remove after fixing https://github.com/aeternity/aesophia_http/issues/80\n              .join('\\n')\n          }\n          return message\n        })\n      ]\n    })\n    if (ignoreVersion !== true) {\n      const versionPromise = this.aPIVersion().then(({ apiVersion }) => apiVersion)\n      this.pipeline.addPolicy(\n        genVersionCheckPolicy('compiler', '/api-version', versionPromise, '6.1.0', '7.0.0')\n      )\n    }\n  }\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;SACSA,QAAQ,IAAIC,W;SACZC,uB,EAAyBC,qB;;AAOlC;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,MAAMH,QAAN,SAAuBC,WAAvB,CAAmC;EAChD;AACF;AACA;AACA;AACA;EACEG,WAAW,CAAEC,WAAF,EAA4E;IAAA,IAArD;MAAEC;IAAF,CAAqD,uEAAJ,EAAI;IACrF,MAAMD,WAAN,EAAmB;MACjBE,uBAAuB,EAAE,IADR;MAEjBC,kBAAkB,EAAE,CAClBN,uBAAuB,CAAEO,IAAD,IAAkD;QACxE,IAAIC,OAAO,GAAG,EAAd;;QACA,IAAI,YAAYD,IAAhB,EAAsB;UACpBC,OAAO,IAAI,MAAMD,IAAI,CAACE,MAAX,IACRF,IAAI,CAACG,SAAL,IAAkB,IAAlB,GAA0B,OAAMH,IAAI,CAACG,SAAU,EAA/C,GAAmD,EAD3C,MAET;UACCH,IAAI,CAACI,IAAL,IAAa,IAAb,GAAqB,KAAIC,IAAI,CAACC,SAAL,CAAeN,IAAI,CAACI,IAApB,CAA0B,GAAnD,GAAwD,EAHhD,CAAX;QAID;;QACD,IAAIG,KAAK,CAACC,OAAN,CAAcR,IAAd,CAAJ,EAAyB;UACvBC,OAAO,IAAI,OAAOD,IAAI,CACnBS,GADe,CACXC,CAAC,IAAK,GAAEA,CAAC,CAACC,IAAK,IAAGD,CAAC,CAACE,GAAF,CAAMC,IAAK,IAAGH,CAAC,CAACE,GAAF,CAAME,GAAI,KAAIJ,CAAC,CAACT,OAAQ,GAAES,CAAC,CAACK,OAAF,IAAa,IAAb,GAAqB,IAAGL,CAAC,CAACK,OAAQ,GAAlC,GAAuC,EAAG,EADzF,EAEfN,GAFe,CAEXC,CAAC,IAAIA,CAAC,CAACM,IAAF,EAFM,EAEI;UAFJ,CAGfC,IAHe,CAGV,IAHU,CAAlB;QAID;;QACD,OAAOhB,OAAP;MACD,CAfsB,CADL;IAFH,CAAnB;;IAqBA,IAAIJ,aAAa,KAAK,IAAtB,EAA4B;MAC1B,MAAMqB,cAAc,GAAG,KAAKC,UAAL,GAAkBC,IAAlB,CAAuB;QAAA,IAAC;UAAEC;QAAF,CAAD;QAAA,OAAoBA,UAApB;MAAA,CAAvB,CAAvB;MACA,KAAKC,QAAL,CAAcC,SAAd,CACE7B,qBAAqB,CAAC,UAAD,EAAa,cAAb,EAA6BwB,cAA7B,EAA6C,OAA7C,EAAsD,OAAtD,CADvB;IAGD;EACF;;AAlC+C"}

package/es/contract/aci.d.ts

@@ -0,0 +1,125 @@
+import { AensName } from '../tx/builder/schema';
+import { send } from '../spend';
+import { EncodedData } from '../utils/encoder';
+import { Aci as BaseAci } from '../apis/compiler';
+import Compiler from './Compiler';
+import Node from '../Node';
+import AccountBase from '../account/Base';
+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[];
+}
+interface Event {
+    address: EncodedData<'ct'>;
+    data: string;
+    topics: Array<string | number>;
+}
+interface DecodedEvent {
+    name: string;
+    args: unknown;
+    contract: {
+        name: string;
+        address: EncodedData<'ct'>;
+    };
+}
+declare type TxData = Awaited<ReturnType<typeof send>>;
+export interface ContractInstance {
+    _aci: Aci;
+    _name: string;
+    calldata: any;
+    source?: string;
+    bytecode?: EncodedData<'cb'>;
+    deployInfo: {
+        address?: EncodedData<'ct'>;
+        result?: {
+            callerId: string;
+            callerNonce: string;
+            contractId: string;
+            gasPrice: bigint;
+            gasUsed: number;
+            height: number;
+            log: any[];
+            returnType: string;
+            returnValue: string;
+        };
+        owner?: EncodedData<'ak'>;
+        transaction?: string;
+        rawTx?: string;
+        txData?: TxData;
+    };
+    options: any;
+    compile: (options?: {}) => Promise<EncodedData<'cb'>>;
+    _estimateGas: (name: string, params: any[], options: object) => Promise<number>;
+    deploy: (params?: any[], options?: object) => Promise<any>;
+    call: (fn: string, params?: any[], options?: {}) => Promise<{
+        hash: string;
+        tx: any;
+        txData: TxData;
+        rawTx: string;
+        result: {
+            callerId: EncodedData<'ak'>;
+            callerNonce: number;
+            contractId: EncodedData<'ct'>;
+            gasPrice: number;
+            gasUsed: number;
+            height: number;
+            log: any[];
+            returnType: string;
+            returnValue: string;
+        };
+        decodedResult: any;
+        decodedEvents: DecodedEvent[];
+    }>;
+    decodeEvents: (events: Event[], options?: {
+        omitUnknown?: boolean;
+        contractAddressToName?: any;
+    }) => DecodedEvent[];
+    methods: any;
+}
+/**
+ * Generate contract ACI object with predefined js methods for contract usage - can be used for
+ * creating a reference to already deployed contracts
+ * @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)`
+ * Then sdk decide to make on-chain or static call(dry-run API) transaction based on function is
+ * stateful or not
+ */
+export default function getContractInstance({ onAccount, onCompiler, onNode, source, bytecode, aci: _aci, contractAddress, fileSystem, validateBytecode, ...otherOptions }: {
+    onAccount: AccountBase;
+    onCompiler: Compiler;
+    onNode: Node;
+    source?: string;
+    bytecode?: EncodedData<'cb'>;
+    aci?: Aci;
+    contractAddress?: EncodedData<'ct'> | AensName;
+    fileSystem?: Record<string, string>;
+    validateBytecode?: boolean;
+    [key: string]: any;
+}): Promise<ContractInstance>;
+export {};

package/es/contract/aci.mjs

@@ -0,0 +1,496 @@
+/*
+* 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, 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
+ * @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)`
+ * 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(_ref) {
+  let {
+    onAccount,
+    onCompiler,
+    onNode,
+    source,
+    bytecode,
+    aci: _aci,
+    contractAddress,
+    fileSystem = {},
+    validateBytecode,
+    ...otherOptions
+  } = _ref;
+
+  if (_aci == null && source != null) {
+    // TODO: should be fixed when the compiledAci interface gets updated
+    _aci = await onCompiler.generateACI({
+      code: source,
+      options: {
+        fileSystem
+      }
+    });
+  }
+
+  if (_aci == null) throw new MissingContractDefError();
+
+  if (contractAddress != null) {
+    contractAddress = await resolveName(contractAddress, 'contract_pubkey', {
+      resolveByNode: true,
+      onNode
+    });
+  }
+
+  if (contractAddress == null && source == null && bytecode == null) {
+    throw new MissingContractAddressError('Can\'t create instance by ACI without address');
+  }
+
+  if (contractAddress != null) {
+    const contract = await getContract(contractAddress, {
+      onNode
+    });
+    if (contract.active == null) throw new InactiveContractError(contractAddress);
+  }
+
+  const instance = {
+    _aci,
+    _name: _aci.encodedAci.contract.name,
+    calldata: new Calldata([_aci.encodedAci, ..._aci.externalEncodedAci]),
+    source,
+    bytecode,
+    deployInfo: {
+      address: contractAddress
+    },
+    options: {
+      onAccount,
+      onCompiler,
+      onNode,
+      amount: AMOUNT,
+      callStatic: false,
+      fileSystem,
+      ...otherOptions
+    },
+    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 != 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(() => true, () => false) : bytecode === onChanBytecode;
+    if (!isValid) throw new BytecodeMismatchError(source != null ? 'source' : 'bytecode');
+  }
+  /**
+   * Compile contract
+   * @returns bytecode
+   */
+
+
+  instance.compile = async function () {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    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
+      }
+    })).bytecode;
+    return instance.bytecode;
+  };
+
+  const sendAndProcess = async (tx, options) => {
+    options = { ...instance.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;
+    const {
+      callInfo
+    } = 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
+
+    handleCallError(callInfo, tx);
+    return { ...result,
+      result: callInfo
+    };
+  };
+
+  const handleCallError = (_ref2, transaction) => {
+    let {
+      returnType,
+      returnValue
+    } = _ref2;
+    let message;
+
+    switch (returnType) {
+      case 'ok':
+        return;
+
+      case 'revert':
+        message = instance.calldata.decodeFateString(returnValue);
+        break;
+
+      case 'error':
+        message = decode(returnValue).toString();
+        break;
+    }
+
+    throw new NodeInvocationError(message, transaction);
+  };
+
+  instance._estimateGas = async (name, params, options) => {
+    const {
+      result: {
+        gasUsed
+      }
+    } = await instance.call(name, params, { ...options,
+      callStatic: true
+    }); // taken from https://github.com/aeternity/aepp-sdk-js/issues/1286#issuecomment-977814771
+
+    return Math.floor(gasUsed * 1.25);
+  };
+  /**
+   * Deploy contract
+   * @param params - Contract init function arguments array
+   * @param options - Options
+   * @returns deploy info
+   */
+
+
+  instance.deploy = async function () {
+    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 == 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,
+      onNode
+    });
+    const contractId = buildContractIdByContractTx(tx);
+    const {
+      hash,
+      rawTx,
+      result,
+      txData
+    } = await sendAndProcess(tx, opt);
+    instance.deployInfo = Object.freeze({
+      result,
+      owner: ownerId,
+      transaction: hash,
+      rawTx,
+      txData,
+      address: contractId
+    });
+    return instance.deployInfo;
+  };
+  /**
+   * Get function schema from contract ACI object
+   * @param name - Function name
+   * @returns function ACI
+   */
+
+
+  function getFunctionACI(name) {
+    const fn = instance._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
+   * @param fn - Function name
+   * @param params - Array of function arguments
+   * @param options - Array of function arguments
+   * @returns CallResult
+   */
+
+
+  instance.call = async function (fn) {
+    let params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const opt = { ...instance.options,
+      ...options
+    };
+    const fnACI = getFunctionACI(fn);
+    const contractId = instance.deployInfo.address;
+    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 === true) {
+      var _opt$gasLimit2;
+
+      if (typeof opt.top === 'number') {
+        opt.top = (await getKeyBlock(opt.top, {
+          onNode
+        })).hash;
+      }
+
+      const txOpt = { ...opt,
+        onNode,
+        gasLimit: (_opt$gasLimit2 = opt.gasLimit) !== null && _opt$gasLimit2 !== void 0 ? _opt$gasLimit2 : GAS_MAX,
+        callData
+      };
+
+      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
+      }) : _buildTx(TX_TYPE.contractCall, { ...txOpt,
+        callerId,
+        contractId
+      }));
+      const {
+        callObj,
+        ...dryRunOther
+      } = await txDryRun(tx, callerId, {
+        onNode,
+        ...opt
+      });
+      if (callObj == null) throw new UnexpectedTsError();
+      handleCallError({
+        returnType: callObj.returnType,
+        returnValue: callObj.returnValue
+      }, tx);
+      res = { ...dryRunOther,
+        tx: unpackTx(tx),
+        result: callObj
+      };
+    } else {
+      var _opt$gasLimit3;
+
+      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
+      });
+      res = await sendAndProcess(tx, opt);
+    }
+
+    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 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, _ref3) {
+    let {
+      contractAddressToName
+    } = _ref3;
+    const addressToName = { ...instance.options.contractAddressToName,
+      ...contractAddressToName
+    };
+    if (addressToName[address] != null) return addressToName[address];
+    const matchedEvents = [instance._aci.encodedAci, ...instance._aci.externalEncodedAci].filter(_ref4 => {
+      let {
+        contract
+      } = _ref4;
+      return contract === null || contract === void 0 ? void 0 : contract.event;
+    }).map(_ref5 => {
+      let {
+        contract
+      } = _ref5;
+      return [contract.name, contract.event.variant];
+    }).map(_ref6 => {
+      let [name, events] = _ref6;
+      return events.map(event => [name, Object.keys(event)[0]]);
+    }).flat().filter(_ref7 => {
+      let [, eventName] = _ref7;
+      return BigInt('0x' + hash(eventName).toString('hex')) === nameHash;
+    });
+
+    switch (matchedEvents.length) {
+      case 0:
+        throw new MissingEventDefinitionError(nameHash.toString(), address);
+
+      case 1:
+        return matchedEvents[0][0];
+
+      default:
+        throw new AmbiguousEventDefinitionError(address, matchedEvents);
+    }
+  }
+  /**
+   * Decode Events
+   * @param events - Array of encoded events (callRes.result.log)
+   * @param options - Options
+   * @returns DecodedEvents
+   */
+
+
+  instance.decodeEvents = function (events) {
+    let {
+      omitUnknown,
+      ...opt
+    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return events.map(event => {
+      const topics = event.topics.map(t => BigInt(t));
+      let contractName;
+
+      try {
+        contractName = getContractNameByEvent(event.address, topics[0], opt);
+      } catch (error) {
+        if ((omitUnknown !== null && omitUnknown !== void 0 ? omitUnknown : false) && error instanceof MissingEventDefinitionError) return null;
+        throw error;
+      }
+
+      const decoded = instance.calldata.decodeEvent(contractName, event.data, topics);
+      const [name, args] = Object.entries(decoded)[0];
+      return {
+        name,
+        args,
+        contract: {
+          name: contractName,
+          address: event.address
+        }
+      };
+    }).filter(e => e != null);
+  };
+  /**
+   * Generate proto function based on contract function using Contract ACI schema
+   * All function can be called like:
+   * ```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:
+   * ```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.encodedAci.contract.functions.map(_ref8 => {
+    let {
+      name,
+      arguments: aciArgs,
+      stateful
+    } = _ref8;
+
+    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 await instance.deploy(args, {
+        callStatic,
+        ...options
+      });
+      return await instance.call(name, args, {
+        callStatic,
+        ...options
+      });
+    };
+
+    return [name, Object.assign(genHandler(name === 'init' ? false : !stateful), {
+      get: genHandler(true),
+      send: genHandler(false)
+    })];
+  }));
+  return instance;
+}
+//# sourceMappingURL=aci.mjs.map