@hashgraphonline/standards-sdk 0.0.95 → 0.0.97

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

@@ -1,796 +1,198 @@
-var __defProp = Object.defineProperty;
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
-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);
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 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 __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var _options;
-import { assertPrivate } from "./standards-sdk.es49.js";
-import { defineProperties } from "./standards-sdk.es52.js";
-const _gaurd = {};
-function n(value, width) {
-  let signed = false;
-  if (width < 0) {
-    signed = true;
-    width *= -1;
-  }
-  return new Typed(_gaurd, `${signed ? "" : "u"}int${width}`, value, { signed, width });
-}
-function b(value, size) {
-  return new Typed(_gaurd, `bytes${size ? size : ""}`, value, { size });
-}
-const _typedSymbol = Symbol.for("_ethers_typed");
-const _Typed = class _Typed {
-  /**
-   *  @_ignore:
-   */
-  constructor(gaurd, type, value, options) {
-    /**
-     *  The type, as a Solidity-compatible type.
-     */
-    __publicField(this, "type");
-    /**
-     *  The actual value.
-     */
-    __publicField(this, "value");
-    __privateAdd(this, _options);
-    /**
-     *  @_ignore:
-     */
-    __publicField(this, "_typedSymbol");
-    if (options == null) {
-      options = null;
-    }
-    assertPrivate(_gaurd, gaurd, "Typed");
-    defineProperties(this, { _typedSymbol, type, value });
-    __privateSet(this, _options, options);
-    this.format();
-  }
-  /**
-   *  Format the type as a Human-Readable type.
-   */
-  format() {
-    if (this.type === "array") {
-      throw new Error("");
-    } else if (this.type === "dynamicArray") {
-      throw new Error("");
-    } else if (this.type === "tuple") {
-      return `tuple(${this.value.map((v) => v.format()).join(",")})`;
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _AbiCoder_instances, getCoder_fn;
+import { Writer, Reader } from "./standards-sdk.es57.js";
+import { AddressCoder } from "./standards-sdk.es58.js";
+import { ArrayCoder } from "./standards-sdk.es59.js";
+import { BooleanCoder } from "./standards-sdk.es60.js";
+import { BytesCoder } from "./standards-sdk.es61.js";
+import { FixedBytesCoder } from "./standards-sdk.es62.js";
+import { NullCoder } from "./standards-sdk.es63.js";
+import { NumberCoder } from "./standards-sdk.es64.js";
+import { StringCoder } from "./standards-sdk.es65.js";
+import { TupleCoder } from "./standards-sdk.es66.js";
+import { ParamType } from "./standards-sdk.es67.js";
+import { assertArgument, assertArgumentCount, makeError } from "./standards-sdk.es68.js";
+import { getBytes, hexlify } from "./standards-sdk.es69.js";
+import { getAddress } from "./standards-sdk.es70.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 this.type;
   }
-  /**
-   *  The default value returned by this type.
-   */
-  defaultValue() {
-    return 0;
-  }
-  /**
-   *  The minimum value for numeric types.
-   */
-  minValue() {
-    return 0;
+  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);
   }
   /**
-   *  The maximum value for numeric types.
+   *  Get the default values for the given %%types%%.
+   *
+   *  For example, a ``uint`` is by default ``0`` and ``bool``
+   *  is by default ``false``.
    */
-  maxValue() {
-    return 0;
+  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();
   }
   /**
-   *  Returns ``true`` and provides a type guard is this is a [[TypedBigInt]].
+   *  Encode the %%values%% as the %%types%% into ABI data.
+   *
+   *  @returns DataHexstring
    */
-  isBigInt() {
-    return !!this.type.match(/^u?int[0-9]+$/);
+  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;
   }
   /**
-   *  Returns ``true`` and provides a type guard is this is a [[TypedData]].
+   *  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.
    */
-  isData() {
-    return this.type.startsWith("bytes");
+  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));
   }
-  /**
-   *  Returns ``true`` and provides a type guard is this is a [[TypedString]].
-   */
-  isString() {
-    return this.type === "string";
+  static _setDefaultMaxInflation(value) {
+    assertArgument(typeof value === "number" && Number.isInteger(value), "invalid defaultMaxInflation factor", "value", value);
+    defaultMaxInflation = value;
   }
   /**
-   *  Returns the tuple name, if this is a tuple. Throws otherwise.
-   */
-  get tupleName() {
-    if (this.type !== "tuple") {
-      throw TypeError("not a tuple");
-    }
-    return __privateGet(this, _options);
-  }
-  // Returns the length of this type as an array
-  // - `null` indicates the length is unforced, it could be dynamic
-  // - `-1` indicates the length is dynamic
-  // - any other value indicates it is a static array and is its length
-  /**
-   *  Returns the length of the array type or ``-1`` if it is dynamic.
+   *  Returns the shared singleton instance of a default [[AbiCoder]].
    *
-   *  Throws if the type is not an array.
+   *  On the first call, the instance is created internally.
    */
-  get arrayLength() {
-    if (this.type !== "array") {
-      throw TypeError("not an array");
+  static defaultAbiCoder() {
+    if (defaultCoder == null) {
+      defaultCoder = new _AbiCoder();
     }
-    if (__privateGet(this, _options) === true) {
-      return -1;
-    }
-    if (__privateGet(this, _options) === false) {
-      return this.value.length;
-    }
-    return null;
-  }
-  /**
-   *  Returns a new **Typed** of %%type%% with the %%value%%.
-   */
-  static from(type, value) {
-    return new _Typed(_gaurd, type, value);
-  }
-  /**
-   *  Return a new ``uint8`` type for %%v%%.
-   */
-  static uint8(v) {
-    return n(v, 8);
+    return defaultCoder;
   }
   /**
-   *  Return a new ``uint16`` type for %%v%%.
+   *  Returns an ethers-compatible [[CallExceptionError]] Error for the given
+   *  result %%data%% for the [[CallExceptionAction]] %%action%% against
+   *  the Transaction %%tx%%.
    */
-  static uint16(v) {
-    return n(v, 16);
-  }
-  /**
-   *  Return a new ``uint24`` type for %%v%%.
-   */
-  static uint24(v) {
-    return n(v, 24);
-  }
-  /**
-   *  Return a new ``uint32`` type for %%v%%.
-   */
-  static uint32(v) {
-    return n(v, 32);
-  }
-  /**
-   *  Return a new ``uint40`` type for %%v%%.
-   */
-  static uint40(v) {
-    return n(v, 40);
-  }
-  /**
-   *  Return a new ``uint48`` type for %%v%%.
-   */
-  static uint48(v) {
-    return n(v, 48);
-  }
-  /**
-   *  Return a new ``uint56`` type for %%v%%.
-   */
-  static uint56(v) {
-    return n(v, 56);
-  }
-  /**
-   *  Return a new ``uint64`` type for %%v%%.
-   */
-  static uint64(v) {
-    return n(v, 64);
-  }
-  /**
-   *  Return a new ``uint72`` type for %%v%%.
-   */
-  static uint72(v) {
-    return n(v, 72);
-  }
-  /**
-   *  Return a new ``uint80`` type for %%v%%.
-   */
-  static uint80(v) {
-    return n(v, 80);
-  }
-  /**
-   *  Return a new ``uint88`` type for %%v%%.
-   */
-  static uint88(v) {
-    return n(v, 88);
-  }
-  /**
-   *  Return a new ``uint96`` type for %%v%%.
-   */
-  static uint96(v) {
-    return n(v, 96);
-  }
-  /**
-   *  Return a new ``uint104`` type for %%v%%.
-   */
-  static uint104(v) {
-    return n(v, 104);
-  }
-  /**
-   *  Return a new ``uint112`` type for %%v%%.
-   */
-  static uint112(v) {
-    return n(v, 112);
-  }
-  /**
-   *  Return a new ``uint120`` type for %%v%%.
-   */
-  static uint120(v) {
-    return n(v, 120);
-  }
-  /**
-   *  Return a new ``uint128`` type for %%v%%.
-   */
-  static uint128(v) {
-    return n(v, 128);
-  }
-  /**
-   *  Return a new ``uint136`` type for %%v%%.
-   */
-  static uint136(v) {
-    return n(v, 136);
-  }
-  /**
-   *  Return a new ``uint144`` type for %%v%%.
-   */
-  static uint144(v) {
-    return n(v, 144);
-  }
-  /**
-   *  Return a new ``uint152`` type for %%v%%.
-   */
-  static uint152(v) {
-    return n(v, 152);
-  }
-  /**
-   *  Return a new ``uint160`` type for %%v%%.
-   */
-  static uint160(v) {
-    return n(v, 160);
-  }
-  /**
-   *  Return a new ``uint168`` type for %%v%%.
-   */
-  static uint168(v) {
-    return n(v, 168);
-  }
-  /**
-   *  Return a new ``uint176`` type for %%v%%.
-   */
-  static uint176(v) {
-    return n(v, 176);
-  }
-  /**
-   *  Return a new ``uint184`` type for %%v%%.
-   */
-  static uint184(v) {
-    return n(v, 184);
-  }
-  /**
-   *  Return a new ``uint192`` type for %%v%%.
-   */
-  static uint192(v) {
-    return n(v, 192);
-  }
-  /**
-   *  Return a new ``uint200`` type for %%v%%.
-   */
-  static uint200(v) {
-    return n(v, 200);
-  }
-  /**
-   *  Return a new ``uint208`` type for %%v%%.
-   */
-  static uint208(v) {
-    return n(v, 208);
-  }
-  /**
-   *  Return a new ``uint216`` type for %%v%%.
-   */
-  static uint216(v) {
-    return n(v, 216);
-  }
-  /**
-   *  Return a new ``uint224`` type for %%v%%.
-   */
-  static uint224(v) {
-    return n(v, 224);
-  }
-  /**
-   *  Return a new ``uint232`` type for %%v%%.
-   */
-  static uint232(v) {
-    return n(v, 232);
-  }
-  /**
-   *  Return a new ``uint240`` type for %%v%%.
-   */
-  static uint240(v) {
-    return n(v, 240);
-  }
-  /**
-   *  Return a new ``uint248`` type for %%v%%.
-   */
-  static uint248(v) {
-    return n(v, 248);
-  }
-  /**
-   *  Return a new ``uint256`` type for %%v%%.
-   */
-  static uint256(v) {
-    return n(v, 256);
-  }
-  /**
-   *  Return a new ``uint256`` type for %%v%%.
-   */
-  static uint(v) {
-    return n(v, 256);
-  }
-  /**
-   *  Return a new ``int8`` type for %%v%%.
-   */
-  static int8(v) {
-    return n(v, -8);
-  }
-  /**
-   *  Return a new ``int16`` type for %%v%%.
-   */
-  static int16(v) {
-    return n(v, -16);
-  }
-  /**
-   *  Return a new ``int24`` type for %%v%%.
-   */
-  static int24(v) {
-    return n(v, -24);
-  }
-  /**
-   *  Return a new ``int32`` type for %%v%%.
-   */
-  static int32(v) {
-    return n(v, -32);
-  }
-  /**
-   *  Return a new ``int40`` type for %%v%%.
-   */
-  static int40(v) {
-    return n(v, -40);
-  }
-  /**
-   *  Return a new ``int48`` type for %%v%%.
-   */
-  static int48(v) {
-    return n(v, -48);
-  }
-  /**
-   *  Return a new ``int56`` type for %%v%%.
-   */
-  static int56(v) {
-    return n(v, -56);
-  }
-  /**
-   *  Return a new ``int64`` type for %%v%%.
-   */
-  static int64(v) {
-    return n(v, -64);
-  }
-  /**
-   *  Return a new ``int72`` type for %%v%%.
-   */
-  static int72(v) {
-    return n(v, -72);
-  }
-  /**
-   *  Return a new ``int80`` type for %%v%%.
-   */
-  static int80(v) {
-    return n(v, -80);
-  }
-  /**
-   *  Return a new ``int88`` type for %%v%%.
-   */
-  static int88(v) {
-    return n(v, -88);
-  }
-  /**
-   *  Return a new ``int96`` type for %%v%%.
-   */
-  static int96(v) {
-    return n(v, -96);
-  }
-  /**
-   *  Return a new ``int104`` type for %%v%%.
-   */
-  static int104(v) {
-    return n(v, -104);
-  }
-  /**
-   *  Return a new ``int112`` type for %%v%%.
-   */
-  static int112(v) {
-    return n(v, -112);
-  }
-  /**
-   *  Return a new ``int120`` type for %%v%%.
-   */
-  static int120(v) {
-    return n(v, -120);
-  }
-  /**
-   *  Return a new ``int128`` type for %%v%%.
-   */
-  static int128(v) {
-    return n(v, -128);
-  }
-  /**
-   *  Return a new ``int136`` type for %%v%%.
-   */
-  static int136(v) {
-    return n(v, -136);
-  }
-  /**
-   *  Return a new ``int144`` type for %%v%%.
-   */
-  static int144(v) {
-    return n(v, -144);
-  }
-  /**
-   *  Return a new ``int52`` type for %%v%%.
-   */
-  static int152(v) {
-    return n(v, -152);
-  }
-  /**
-   *  Return a new ``int160`` type for %%v%%.
-   */
-  static int160(v) {
-    return n(v, -160);
-  }
-  /**
-   *  Return a new ``int168`` type for %%v%%.
-   */
-  static int168(v) {
-    return n(v, -168);
-  }
-  /**
-   *  Return a new ``int176`` type for %%v%%.
-   */
-  static int176(v) {
-    return n(v, -176);
-  }
-  /**
-   *  Return a new ``int184`` type for %%v%%.
-   */
-  static int184(v) {
-    return n(v, -184);
-  }
-  /**
-   *  Return a new ``int92`` type for %%v%%.
-   */
-  static int192(v) {
-    return n(v, -192);
-  }
-  /**
-   *  Return a new ``int200`` type for %%v%%.
-   */
-  static int200(v) {
-    return n(v, -200);
-  }
-  /**
-   *  Return a new ``int208`` type for %%v%%.
-   */
-  static int208(v) {
-    return n(v, -208);
-  }
-  /**
-   *  Return a new ``int216`` type for %%v%%.
-   */
-  static int216(v) {
-    return n(v, -216);
-  }
-  /**
-   *  Return a new ``int224`` type for %%v%%.
-   */
-  static int224(v) {
-    return n(v, -224);
-  }
-  /**
-   *  Return a new ``int232`` type for %%v%%.
-   */
-  static int232(v) {
-    return n(v, -232);
-  }
-  /**
-   *  Return a new ``int240`` type for %%v%%.
-   */
-  static int240(v) {
-    return n(v, -240);
-  }
-  /**
-   *  Return a new ``int248`` type for %%v%%.
-   */
-  static int248(v) {
-    return n(v, -248);
-  }
-  /**
-   *  Return a new ``int256`` type for %%v%%.
-   */
-  static int256(v) {
-    return n(v, -256);
-  }
-  /**
-   *  Return a new ``int256`` type for %%v%%.
-   */
-  static int(v) {
-    return n(v, -256);
-  }
-  /**
-   *  Return a new ``bytes1`` type for %%v%%.
-   */
-  static bytes1(v) {
-    return b(v, 1);
-  }
-  /**
-   *  Return a new ``bytes2`` type for %%v%%.
-   */
-  static bytes2(v) {
-    return b(v, 2);
-  }
-  /**
-   *  Return a new ``bytes3`` type for %%v%%.
-   */
-  static bytes3(v) {
-    return b(v, 3);
-  }
-  /**
-   *  Return a new ``bytes4`` type for %%v%%.
-   */
-  static bytes4(v) {
-    return b(v, 4);
-  }
-  /**
-   *  Return a new ``bytes5`` type for %%v%%.
-   */
-  static bytes5(v) {
-    return b(v, 5);
-  }
-  /**
-   *  Return a new ``bytes6`` type for %%v%%.
-   */
-  static bytes6(v) {
-    return b(v, 6);
-  }
-  /**
-   *  Return a new ``bytes7`` type for %%v%%.
-   */
-  static bytes7(v) {
-    return b(v, 7);
-  }
-  /**
-   *  Return a new ``bytes8`` type for %%v%%.
-   */
-  static bytes8(v) {
-    return b(v, 8);
-  }
-  /**
-   *  Return a new ``bytes9`` type for %%v%%.
-   */
-  static bytes9(v) {
-    return b(v, 9);
-  }
-  /**
-   *  Return a new ``bytes10`` type for %%v%%.
-   */
-  static bytes10(v) {
-    return b(v, 10);
-  }
-  /**
-   *  Return a new ``bytes11`` type for %%v%%.
-   */
-  static bytes11(v) {
-    return b(v, 11);
-  }
-  /**
-   *  Return a new ``bytes12`` type for %%v%%.
-   */
-  static bytes12(v) {
-    return b(v, 12);
-  }
-  /**
-   *  Return a new ``bytes13`` type for %%v%%.
-   */
-  static bytes13(v) {
-    return b(v, 13);
-  }
-  /**
-   *  Return a new ``bytes14`` type for %%v%%.
-   */
-  static bytes14(v) {
-    return b(v, 14);
-  }
-  /**
-   *  Return a new ``bytes15`` type for %%v%%.
-   */
-  static bytes15(v) {
-    return b(v, 15);
-  }
-  /**
-   *  Return a new ``bytes16`` type for %%v%%.
-   */
-  static bytes16(v) {
-    return b(v, 16);
-  }
-  /**
-   *  Return a new ``bytes17`` type for %%v%%.
-   */
-  static bytes17(v) {
-    return b(v, 17);
-  }
-  /**
-   *  Return a new ``bytes18`` type for %%v%%.
-   */
-  static bytes18(v) {
-    return b(v, 18);
-  }
-  /**
-   *  Return a new ``bytes19`` type for %%v%%.
-   */
-  static bytes19(v) {
-    return b(v, 19);
-  }
-  /**
-   *  Return a new ``bytes20`` type for %%v%%.
-   */
-  static bytes20(v) {
-    return b(v, 20);
-  }
-  /**
-   *  Return a new ``bytes21`` type for %%v%%.
-   */
-  static bytes21(v) {
-    return b(v, 21);
-  }
-  /**
-   *  Return a new ``bytes22`` type for %%v%%.
-   */
-  static bytes22(v) {
-    return b(v, 22);
-  }
-  /**
-   *  Return a new ``bytes23`` type for %%v%%.
-   */
-  static bytes23(v) {
-    return b(v, 23);
-  }
-  /**
-   *  Return a new ``bytes24`` type for %%v%%.
-   */
-  static bytes24(v) {
-    return b(v, 24);
-  }
-  /**
-   *  Return a new ``bytes25`` type for %%v%%.
-   */
-  static bytes25(v) {
-    return b(v, 25);
-  }
-  /**
-   *  Return a new ``bytes26`` type for %%v%%.
-   */
-  static bytes26(v) {
-    return b(v, 26);
-  }
-  /**
-   *  Return a new ``bytes27`` type for %%v%%.
-   */
-  static bytes27(v) {
-    return b(v, 27);
-  }
-  /**
-   *  Return a new ``bytes28`` type for %%v%%.
-   */
-  static bytes28(v) {
-    return b(v, 28);
-  }
-  /**
-   *  Return a new ``bytes29`` type for %%v%%.
-   */
-  static bytes29(v) {
-    return b(v, 29);
-  }
-  /**
-   *  Return a new ``bytes30`` type for %%v%%.
-   */
-  static bytes30(v) {
-    return b(v, 30);
-  }
-  /**
-   *  Return a new ``bytes31`` type for %%v%%.
-   */
-  static bytes31(v) {
-    return b(v, 31);
-  }
-  /**
-   *  Return a new ``bytes32`` type for %%v%%.
-   */
-  static bytes32(v) {
-    return b(v, 32);
-  }
-  /**
-   *  Return a new ``address`` type for %%v%%.
-   */
-  static address(v) {
-    return new _Typed(_gaurd, "address", v);
-  }
-  /**
-   *  Return a new ``bool`` type for %%v%%.
-   */
-  static bool(v) {
-    return new _Typed(_gaurd, "bool", !!v);
-  }
-  /**
-   *  Return a new ``bytes`` type for %%v%%.
-   */
-  static bytes(v) {
-    return new _Typed(_gaurd, "bytes", v);
-  }
-  /**
-   *  Return a new ``string`` type for %%v%%.
-   */
-  static string(v) {
-    return new _Typed(_gaurd, "string", v);
-  }
-  /**
-   *  Return a new ``array`` type for %%v%%, allowing %%dynamic%% length.
-   */
-  static array(v, dynamic) {
-    throw new Error("not implemented yet");
-  }
-  /**
-   *  Return a new ``tuple`` type for %%v%%, with the optional %%name%%.
-   */
-  static tuple(v, name) {
-    throw new Error("not implemented yet");
-  }
-  /**
-   *  Return a new ``uint8`` type for %%v%%.
-   */
-  static overrides(v) {
-    return new _Typed(_gaurd, "overrides", Object.assign({}, v));
-  }
-  /**
-   *  Returns true only if %%value%% is a [[Typed]] instance.
-   */
-  static isTyped(value) {
-    return value && typeof value === "object" && "_typedSymbol" in value && value._typedSymbol === _typedSymbol;
-  }
-  /**
-   *  If the value is a [[Typed]] instance, validates the underlying value
-   *  and returns it, otherwise returns value directly.
-   *
-   *  This is useful for functions that with to accept either a [[Typed]]
-   *  object or values.
-   */
-  static dereference(value, type) {
-    if (_Typed.isTyped(value)) {
-      if (value.type !== type) {
-        throw new Error(`invalid type: expecetd ${type}, got ${value.type}`);
-      }
-      return value.value;
-    }
-    return value;
+  static getBuiltinCallException(action, tx, data) {
+    return getBuiltinCallException(action, tx, data, _AbiCoder.defaultAbiCoder());
   }
 };
-_options = new WeakMap();
-let Typed = _Typed;
+_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 {
-  Typed
+  AbiCoder
 };
 //# sourceMappingURL=standards-sdk.es56.js.map