@hashgraphonline/standards-sdk 0.0.81 → 0.0.82

package/dist/es/standards-sdk.es4.js

@@ -1,6 +1,6 @@
 import { ContractId, AccountId } from "@hashgraph/sdk";
 import { Logger } from "./standards-sdk.es14.js";
-import { Interface } from "./standards-sdk.es21.js";
+import { Interface } from "./standards-sdk.es28.js";
 class MapCache {
   constructor() {
     this.cache = /* @__PURE__ */ new Map();

package/dist/es/standards-sdk.es40.js

@@ -1,32 +1,198 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { Typed } from "./standards-sdk.es51.js";
-import { Coder } from "./standards-sdk.es35.js";
-import { defineProperties } from "./standards-sdk.es49.js";
-import { getBytesCopy, hexlify } from "./standards-sdk.es47.js";
-class FixedBytesCoder extends Coder {
-  constructor(size, localName) {
-    let name = "bytes" + String(size);
-    super(name, name, localName, false);
-    __publicField(this, "size");
-    defineProperties(this, { size }, { size: "number" });
-  }
-  defaultValue() {
-    return "0x0000000000000000000000000000000000000000000000000000000000000000".substring(0, 2 + this.size * 2);
-  }
-  encode(writer, _value) {
-    let data = getBytesCopy(Typed.dereference(_value, this.type));
-    if (data.length !== this.size) {
-      this._throwError("incorrect data length", _value);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _AbiCoder_instances, getCoder_fn;
+import { Writer, Reader } from "./standards-sdk.es41.js";
+import { AddressCoder } from "./standards-sdk.es42.js";
+import { ArrayCoder } from "./standards-sdk.es43.js";
+import { BooleanCoder } from "./standards-sdk.es44.js";
+import { BytesCoder } from "./standards-sdk.es45.js";
+import { FixedBytesCoder } from "./standards-sdk.es46.js";
+import { NullCoder } from "./standards-sdk.es47.js";
+import { NumberCoder } from "./standards-sdk.es48.js";
+import { StringCoder } from "./standards-sdk.es49.js";
+import { TupleCoder } from "./standards-sdk.es50.js";
+import { ParamType } from "./standards-sdk.es51.js";
+import { assertArgument, assertArgumentCount, makeError } from "./standards-sdk.es37.js";
+import { getBytes, hexlify } from "./standards-sdk.es38.js";
+import { getAddress } from "./standards-sdk.es35.js";
+const PanicReasons = /* @__PURE__ */ new Map();
+PanicReasons.set(0, "GENERIC_PANIC");
+PanicReasons.set(1, "ASSERT_FALSE");
+PanicReasons.set(17, "OVERFLOW");
+PanicReasons.set(18, "DIVIDE_BY_ZERO");
+PanicReasons.set(33, "ENUM_RANGE_ERROR");
+PanicReasons.set(34, "BAD_STORAGE_DATA");
+PanicReasons.set(49, "STACK_UNDERFLOW");
+PanicReasons.set(50, "ARRAY_RANGE_ERROR");
+PanicReasons.set(65, "OUT_OF_MEMORY");
+PanicReasons.set(81, "UNINITIALIZED_FUNCTION_CALL");
+const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
+const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
+let defaultCoder = null;
+let defaultMaxInflation = 1024;
+function getBuiltinCallException(action, tx, data, abiCoder) {
+  let message = "missing revert data";
+  let reason = null;
+  const invocation = null;
+  let revert = null;
+  if (data) {
+    message = "execution reverted";
+    const bytes = getBytes(data);
+    data = hexlify(data);
+    if (bytes.length === 0) {
+      message += " (no data present; likely require(false) occurred";
+      reason = "require(false)";
+    } else if (bytes.length % 32 !== 4) {
+      message += " (could not decode reason; invalid data length)";
+    } else if (hexlify(bytes.slice(0, 4)) === "0x08c379a0") {
+      try {
+        reason = abiCoder.decode(["string"], bytes.slice(4))[0];
+        revert = {
+          signature: "Error(string)",
+          name: "Error",
+          args: [reason]
+        };
+        message += `: ${JSON.stringify(reason)}`;
+      } catch (error) {
+        message += " (could not decode reason; invalid string data)";
+      }
+    } else if (hexlify(bytes.slice(0, 4)) === "0x4e487b71") {
+      try {
+        const code = Number(abiCoder.decode(["uint256"], bytes.slice(4))[0]);
+        revert = {
+          signature: "Panic(uint256)",
+          name: "Panic",
+          args: [code]
+        };
+        reason = `Panic due to ${PanicReasons.get(code) || "UNKNOWN"}(${code})`;
+        message += `: ${reason}`;
+      } catch (error) {
+        message += " (could not decode panic code)";
+      }
+    } else {
+      message += " (unknown custom error)";
     }
-    return writer.writeBytes(data);
   }
-  decode(reader) {
-    return hexlify(reader.readBytes(this.size));
+  const transaction = {
+    to: tx.to ? getAddress(tx.to) : null,
+    data: tx.data || "0x"
+  };
+  if (tx.from) {
+    transaction.from = getAddress(tx.from);
   }
+  return makeError(message, "CALL_EXCEPTION", {
+    action,
+    data,
+    reason,
+    transaction,
+    invocation,
+    revert
+  });
 }
+const _AbiCoder = class _AbiCoder {
+  constructor() {
+    __privateAdd(this, _AbiCoder_instances);
+  }
+  /**
+   *  Get the default values for the given %%types%%.
+   *
+   *  For example, a ``uint`` is by default ``0`` and ``bool``
+   *  is by default ``false``.
+   */
+  getDefaultValue(types) {
+    const coders = types.map((type) => __privateMethod(this, _AbiCoder_instances, getCoder_fn).call(this, ParamType.from(type)));
+    const coder = new TupleCoder(coders, "_");
+    return coder.defaultValue();
+  }
+  /**
+   *  Encode the %%values%% as the %%types%% into ABI data.
+   *
+   *  @returns DataHexstring
+   */
+  encode(types, values) {
+    assertArgumentCount(values.length, types.length, "types/values length mismatch");
+    const coders = types.map((type) => __privateMethod(this, _AbiCoder_instances, getCoder_fn).call(this, ParamType.from(type)));
+    const coder = new TupleCoder(coders, "_");
+    const writer = new Writer();
+    coder.encode(writer, values);
+    return writer.data;
+  }
+  /**
+   *  Decode the ABI %%data%% as the %%types%% into values.
+   *
+   *  If %%loose%% decoding is enabled, then strict padding is
+   *  not enforced. Some older versions of Solidity incorrectly
+   *  padded event data emitted from ``external`` functions.
+   */
+  decode(types, data, loose) {
+    const coders = types.map((type) => __privateMethod(this, _AbiCoder_instances, getCoder_fn).call(this, ParamType.from(type)));
+    const coder = new TupleCoder(coders, "_");
+    return coder.decode(new Reader(data, loose, defaultMaxInflation));
+  }
+  static _setDefaultMaxInflation(value) {
+    assertArgument(typeof value === "number" && Number.isInteger(value), "invalid defaultMaxInflation factor", "value", value);
+    defaultMaxInflation = value;
+  }
+  /**
+   *  Returns the shared singleton instance of a default [[AbiCoder]].
+   *
+   *  On the first call, the instance is created internally.
+   */
+  static defaultAbiCoder() {
+    if (defaultCoder == null) {
+      defaultCoder = new _AbiCoder();
+    }
+    return defaultCoder;
+  }
+  /**
+   *  Returns an ethers-compatible [[CallExceptionError]] Error for the given
+   *  result %%data%% for the [[CallExceptionAction]] %%action%% against
+   *  the Transaction %%tx%%.
+   */
+  static getBuiltinCallException(action, tx, data) {
+    return getBuiltinCallException(action, tx, data, _AbiCoder.defaultAbiCoder());
+  }
+};
+_AbiCoder_instances = new WeakSet();
+getCoder_fn = function(param) {
+  if (param.isArray()) {
+    return new ArrayCoder(__privateMethod(this, _AbiCoder_instances, getCoder_fn).call(this, param.arrayChildren), param.arrayLength, param.name);
+  }
+  if (param.isTuple()) {
+    return new TupleCoder(param.components.map((c) => __privateMethod(this, _AbiCoder_instances, getCoder_fn).call(this, c)), param.name);
+  }
+  switch (param.baseType) {
+    case "address":
+      return new AddressCoder(param.name);
+    case "bool":
+      return new BooleanCoder(param.name);
+    case "string":
+      return new StringCoder(param.name);
+    case "bytes":
+      return new BytesCoder(param.name);
+    case "":
+      return new NullCoder(param.name);
+  }
+  let match = param.type.match(paramTypeNumber);
+  if (match) {
+    let size = parseInt(match[2] || "256");
+    assertArgument(size !== 0 && size <= 256 && size % 8 === 0, "invalid " + match[1] + " bit length", "param", param);
+    return new NumberCoder(size / 8, match[1] === "int", param.name);
+  }
+  match = param.type.match(paramTypeBytes);
+  if (match) {
+    let size = parseInt(match[1]);
+    assertArgument(size !== 0 && size <= 32, "invalid bytes length", "param", param);
+    return new FixedBytesCoder(size, param.name);
+  }
+  assertArgument(false, "invalid type", "type", param.type);
+};
+let AbiCoder = _AbiCoder;
 export {
-  FixedBytesCoder
+  AbiCoder
 };
 //# sourceMappingURL=standards-sdk.es40.js.map

package/dist/es/standards-sdk.es40.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es40.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/fixed-bytes.js"],"sourcesContent":["import { defineProperties, getBytesCopy, hexlify } from \"../../utils/index.js\";\nimport { Typed } from \"../typed.js\";\nimport { Coder } from \"./abstract-coder.js\";\n/**\n *  @_ignore\n */\nexport class FixedBytesCoder extends Coder {\n    size;\n    constructor(size, localName) {\n        let name = \"bytes\" + String(size);\n        super(name, name, localName, false);\n        defineProperties(this, { size }, { size: \"number\" });\n    }\n    defaultValue() {\n        return (\"0x0000000000000000000000000000000000000000000000000000000000000000\").substring(0, 2 + this.size * 2);\n    }\n    encode(writer, _value) {\n        let data = getBytesCopy(Typed.dereference(_value, this.type));\n        if (data.length !== this.size) {\n            this._throwError(\"incorrect data length\", _value);\n        }\n        return writer.writeBytes(data);\n    }\n    decode(reader) {\n        return hexlify(reader.readBytes(this.size));\n    }\n}\n//# sourceMappingURL=fixed-bytes.js.map"],"names":[],"mappings":";;;;;;;AAMO,MAAM,wBAAwB,MAAM;AAAA,EAEvC,YAAY,MAAM,WAAW;AACzB,QAAI,OAAO,UAAU,OAAO,IAAI;AAChC,UAAM,MAAM,MAAM,WAAW,KAAK;AAHtC;AAII,qBAAiB,MAAM,EAAE,KAAM,GAAE,EAAE,MAAM,UAAU;AAAA,EAC3D;AAAA,EACI,eAAe;AACX,WAAQ,qEAAsE,UAAU,GAAG,IAAI,KAAK,OAAO,CAAC;AAAA,EACpH;AAAA,EACI,OAAO,QAAQ,QAAQ;AACnB,QAAI,OAAO,aAAa,MAAM,YAAY,QAAQ,KAAK,IAAI,CAAC;AAC5D,QAAI,KAAK,WAAW,KAAK,MAAM;AAC3B,WAAK,YAAY,yBAAyB,MAAM;AAAA,IAC5D;AACQ,WAAO,OAAO,WAAW,IAAI;AAAA,EACrC;AAAA,EACI,OAAO,QAAQ;AACX,WAAO,QAAQ,OAAO,UAAU,KAAK,IAAI,CAAC;AAAA,EAClD;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es40.js","sources":["../../node_modules/ethers/lib.esm/abi/abi-coder.js"],"sourcesContent":["/**\n *  When sending values to or receiving values from a [[Contract]], the\n *  data is generally encoded using the [ABI standard](link-solc-abi).\n *\n *  The AbiCoder provides a utility to encode values to ABI data and\n *  decode values from ABI data.\n *\n *  Most of the time, developers should favour the [[Contract]] class,\n *  which further abstracts a lot of the finer details of ABI data.\n *\n *  @_section api/abi/abi-coder:ABI Encoding\n */\n// See: https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI\nimport { assertArgumentCount, assertArgument } from \"../utils/index.js\";\nimport { Reader, Writer } from \"./coders/abstract-coder.js\";\nimport { AddressCoder } from \"./coders/address.js\";\nimport { ArrayCoder } from \"./coders/array.js\";\nimport { BooleanCoder } from \"./coders/boolean.js\";\nimport { BytesCoder } from \"./coders/bytes.js\";\nimport { FixedBytesCoder } from \"./coders/fixed-bytes.js\";\nimport { NullCoder } from \"./coders/null.js\";\nimport { NumberCoder } from \"./coders/number.js\";\nimport { StringCoder } from \"./coders/string.js\";\nimport { TupleCoder } from \"./coders/tuple.js\";\nimport { ParamType } from \"./fragments.js\";\nimport { getAddress } from \"../address/index.js\";\nimport { getBytes, hexlify, makeError } from \"../utils/index.js\";\n// https://docs.soliditylang.org/en/v0.8.17/control-structures.html\nconst PanicReasons = new Map();\nPanicReasons.set(0x00, \"GENERIC_PANIC\");\nPanicReasons.set(0x01, \"ASSERT_FALSE\");\nPanicReasons.set(0x11, \"OVERFLOW\");\nPanicReasons.set(0x12, \"DIVIDE_BY_ZERO\");\nPanicReasons.set(0x21, \"ENUM_RANGE_ERROR\");\nPanicReasons.set(0x22, \"BAD_STORAGE_DATA\");\nPanicReasons.set(0x31, \"STACK_UNDERFLOW\");\nPanicReasons.set(0x32, \"ARRAY_RANGE_ERROR\");\nPanicReasons.set(0x41, \"OUT_OF_MEMORY\");\nPanicReasons.set(0x51, \"UNINITIALIZED_FUNCTION_CALL\");\nconst paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);\nconst paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);\nlet defaultCoder = null;\nlet defaultMaxInflation = 1024;\nfunction getBuiltinCallException(action, tx, data, abiCoder) {\n    let message = \"missing revert data\";\n    let reason = null;\n    const invocation = null;\n    let revert = null;\n    if (data) {\n        message = \"execution reverted\";\n        const bytes = getBytes(data);\n        data = hexlify(data);\n        if (bytes.length === 0) {\n            message += \" (no data present; likely require(false) occurred\";\n            reason = \"require(false)\";\n        }\n        else if (bytes.length % 32 !== 4) {\n            message += \" (could not decode reason; invalid data length)\";\n        }\n        else if (hexlify(bytes.slice(0, 4)) === \"0x08c379a0\") {\n            // Error(string)\n            try {\n                reason = abiCoder.decode([\"string\"], bytes.slice(4))[0];\n                revert = {\n                    signature: \"Error(string)\",\n                    name: \"Error\",\n                    args: [reason]\n                };\n                message += `: ${JSON.stringify(reason)}`;\n            }\n            catch (error) {\n                message += \" (could not decode reason; invalid string data)\";\n            }\n        }\n        else if (hexlify(bytes.slice(0, 4)) === \"0x4e487b71\") {\n            // Panic(uint256)\n            try {\n                const code = Number(abiCoder.decode([\"uint256\"], bytes.slice(4))[0]);\n                revert = {\n                    signature: \"Panic(uint256)\",\n                    name: \"Panic\",\n                    args: [code]\n                };\n                reason = `Panic due to ${PanicReasons.get(code) || \"UNKNOWN\"}(${code})`;\n                message += `: ${reason}`;\n            }\n            catch (error) {\n                message += \" (could not decode panic code)\";\n            }\n        }\n        else {\n            message += \" (unknown custom error)\";\n        }\n    }\n    const transaction = {\n        to: (tx.to ? getAddress(tx.to) : null),\n        data: (tx.data || \"0x\")\n    };\n    if (tx.from) {\n        transaction.from = getAddress(tx.from);\n    }\n    return makeError(message, \"CALL_EXCEPTION\", {\n        action, data, reason, transaction, invocation, revert\n    });\n}\n/**\n *  The **AbiCoder** is a low-level class responsible for encoding JavaScript\n *  values into binary data and decoding binary data into JavaScript values.\n */\nexport class AbiCoder {\n    #getCoder(param) {\n        if (param.isArray()) {\n            return new ArrayCoder(this.#getCoder(param.arrayChildren), param.arrayLength, param.name);\n        }\n        if (param.isTuple()) {\n            return new TupleCoder(param.components.map((c) => this.#getCoder(c)), param.name);\n        }\n        switch (param.baseType) {\n            case \"address\":\n                return new AddressCoder(param.name);\n            case \"bool\":\n                return new BooleanCoder(param.name);\n            case \"string\":\n                return new StringCoder(param.name);\n            case \"bytes\":\n                return new BytesCoder(param.name);\n            case \"\":\n                return new NullCoder(param.name);\n        }\n        // u?int[0-9]*\n        let match = param.type.match(paramTypeNumber);\n        if (match) {\n            let size = parseInt(match[2] || \"256\");\n            assertArgument(size !== 0 && size <= 256 && (size % 8) === 0, \"invalid \" + match[1] + \" bit length\", \"param\", param);\n            return new NumberCoder(size / 8, (match[1] === \"int\"), param.name);\n        }\n        // bytes[0-9]+\n        match = param.type.match(paramTypeBytes);\n        if (match) {\n            let size = parseInt(match[1]);\n            assertArgument(size !== 0 && size <= 32, \"invalid bytes length\", \"param\", param);\n            return new FixedBytesCoder(size, param.name);\n        }\n        assertArgument(false, \"invalid type\", \"type\", param.type);\n    }\n    /**\n     *  Get the default values for the given %%types%%.\n     *\n     *  For example, a ``uint`` is by default ``0`` and ``bool``\n     *  is by default ``false``.\n     */\n    getDefaultValue(types) {\n        const coders = types.map((type) => this.#getCoder(ParamType.from(type)));\n        const coder = new TupleCoder(coders, \"_\");\n        return coder.defaultValue();\n    }\n    /**\n     *  Encode the %%values%% as the %%types%% into ABI data.\n     *\n     *  @returns DataHexstring\n     */\n    encode(types, values) {\n        assertArgumentCount(values.length, types.length, \"types/values length mismatch\");\n        const coders = types.map((type) => this.#getCoder(ParamType.from(type)));\n        const coder = (new TupleCoder(coders, \"_\"));\n        const writer = new Writer();\n        coder.encode(writer, values);\n        return writer.data;\n    }\n    /**\n     *  Decode the ABI %%data%% as the %%types%% into values.\n     *\n     *  If %%loose%% decoding is enabled, then strict padding is\n     *  not enforced. Some older versions of Solidity incorrectly\n     *  padded event data emitted from ``external`` functions.\n     */\n    decode(types, data, loose) {\n        const coders = types.map((type) => this.#getCoder(ParamType.from(type)));\n        const coder = new TupleCoder(coders, \"_\");\n        return coder.decode(new Reader(data, loose, defaultMaxInflation));\n    }\n    static _setDefaultMaxInflation(value) {\n        assertArgument(typeof (value) === \"number\" && Number.isInteger(value), \"invalid defaultMaxInflation factor\", \"value\", value);\n        defaultMaxInflation = value;\n    }\n    /**\n     *  Returns the shared singleton instance of a default [[AbiCoder]].\n     *\n     *  On the first call, the instance is created internally.\n     */\n    static defaultAbiCoder() {\n        if (defaultCoder == null) {\n            defaultCoder = new AbiCoder();\n        }\n        return defaultCoder;\n    }\n    /**\n     *  Returns an ethers-compatible [[CallExceptionError]] Error for the given\n     *  result %%data%% for the [[CallExceptionAction]] %%action%% against\n     *  the Transaction %%tx%%.\n     */\n    static getBuiltinCallException(action, tx, data) {\n        return getBuiltinCallException(action, tx, data, AbiCoder.defaultAbiCoder());\n    }\n}\n//# sourceMappingURL=abi-coder.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}