@hashgraphonline/standards-sdk 0.0.79 → 0.0.80

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es95.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]}
+{"version":3,"file":"standards-sdk.es95.js","sources":["../../node_modules/ethers/lib.esm/hash/id.js"],"sourcesContent":["import { keccak256 } from \"../crypto/index.js\";\nimport { toUtf8Bytes } from \"../utils/index.js\";\n/**\n *  A simple hashing function which operates on UTF-8 strings to\n *  compute an 32-byte identifier.\n *\n *  This simply computes the [UTF-8 bytes](toUtf8Bytes) and computes\n *  the [[keccak256]].\n *\n *  @example:\n *    id(\"hello world\")\n *    //_result:\n */\nexport function id(value) {\n    return keccak256(toUtf8Bytes(value));\n}\n//# sourceMappingURL=id.js.map"],"names":[],"mappings":";;AAaO,SAAS,GAAG,OAAO;AACtB,SAAO,UAAU,YAAY,KAAK,CAAC;AACvC;","x_google_ignoreList":[0]}

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

@@ -1,441 +1,162 @@
-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 __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _names, _data, _dataLength, _Writer_instances, writeData_fn, _data2, _offset, _bytesRead, _parent, _maxInflation, _Reader_instances, incrementBytesRead_fn, peekBytes_fn;
-import { getNumber, toBigInt, toNumber, toBeArray } from "./standards-sdk.es109.js";
-import { assert, assertArgument } from "./standards-sdk.es93.js";
-import { concat, getBytesCopy, hexlify } from "./standards-sdk.es94.js";
-import { defineProperties } from "./standards-sdk.es107.js";
-const WordSize = 32;
-const Padding = new Uint8Array(WordSize);
-const passProperties = ["then"];
-const _guard = {};
-const resultNames = /* @__PURE__ */ new WeakMap();
-function getNames(result) {
-  return resultNames.get(result);
-}
-function setNames(result, names) {
-  resultNames.set(result, names);
-}
-function throwError(name, error) {
-  const wrapped = new Error(`deferred error during ABI decoding triggered accessing ${name}`);
-  wrapped.error = error;
-  throw wrapped;
-}
-function toObject(names, items, deep) {
-  if (names.indexOf(null) >= 0) {
-    return items.map((item, index) => {
-      if (item instanceof Result) {
-        return toObject(getNames(item), item, deep);
-      }
-      return item;
-    });
+import { assertArgument, assert } from "./standards-sdk.es91.js";
+const BN_0 = BigInt(0);
+const BN_1 = BigInt(1);
+const maxValue = 9007199254740991;
+function fromTwos(_value, _width) {
+  const value = getUint(_value, "value");
+  const width = BigInt(getNumber(_width, "width"));
+  assert(value >> width === BN_0, "overflow", "NUMERIC_FAULT", {
+    operation: "fromTwos",
+    fault: "overflow",
+    value: _value
+  });
+  if (value >> width - BN_1) {
+    const mask2 = (BN_1 << width) - BN_1;
+    return -((~value & mask2) + BN_1);
   }
-  return names.reduce((accum, name, index) => {
-    let item = items.getValue(name);
-    if (!(name in accum)) {
-      if (deep && item instanceof Result) {
-        item = toObject(getNames(item), item, deep);
-      }
-      accum[name] = item;
-    }
-    return accum;
-  }, {});
+  return value;
 }
-const _Result = class _Result extends Array {
-  /**
-   *  @private
-   */
-  constructor(...args) {
-    const guard = args[0];
-    let items = args[1];
-    let names = (args[2] || []).slice();
-    let wrap = true;
-    if (guard !== _guard) {
-      items = args;
-      names = [];
-      wrap = false;
-    }
-    super(items.length);
-    // No longer used; but cannot be removed as it will remove the
-    // #private field from the .d.ts which may break backwards
-    // compatibility
-    __privateAdd(this, _names);
-    items.forEach((item, index) => {
-      this[index] = item;
+function toTwos(_value, _width) {
+  let value = getBigInt(_value, "value");
+  const width = BigInt(getNumber(_width, "width"));
+  const limit = BN_1 << width - BN_1;
+  if (value < BN_0) {
+    value = -value;
+    assert(value <= limit, "too low", "NUMERIC_FAULT", {
+      operation: "toTwos",
+      fault: "overflow",
+      value: _value
     });
-    const nameCounts = names.reduce((accum, name) => {
-      if (typeof name === "string") {
-        accum.set(name, (accum.get(name) || 0) + 1);
-      }
-      return accum;
-    }, /* @__PURE__ */ new Map());
-    setNames(this, Object.freeze(items.map((item, index) => {
-      const name = names[index];
-      if (name != null && nameCounts.get(name) === 1) {
-        return name;
-      }
-      return null;
-    })));
-    __privateSet(this, _names, []);
-    if (__privateGet(this, _names) == null) {
-      void __privateGet(this, _names);
-    }
-    if (!wrap) {
-      return;
-    }
-    Object.freeze(this);
-    const proxy = new Proxy(this, {
-      get: (target, prop, receiver) => {
-        if (typeof prop === "string") {
-          if (prop.match(/^[0-9]+$/)) {
-            const index = getNumber(prop, "%index");
-            if (index < 0 || index >= this.length) {
-              throw new RangeError("out of result range");
-            }
-            const item = target[index];
-            if (item instanceof Error) {
-              throwError(`index ${index}`, item);
-            }
-            return item;
-          }
-          if (passProperties.indexOf(prop) >= 0) {
-            return Reflect.get(target, prop, receiver);
-          }
-          const value = target[prop];
-          if (value instanceof Function) {
-            return function(...args2) {
-              return value.apply(this === receiver ? target : this, args2);
-            };
-          } else if (!(prop in target)) {
-            return target.getValue.apply(this === receiver ? target : this, [prop]);
-          }
-        }
-        return Reflect.get(target, prop, receiver);
-      }
-    });
-    setNames(proxy, getNames(this));
-    return proxy;
-  }
-  /**
-   *  Returns the Result as a normal Array. If %%deep%%, any children
-   *  which are Result objects are also converted to a normal Array.
-   *
-   *  This will throw if there are any outstanding deferred
-   *  errors.
-   */
-  toArray(deep) {
-    const result = [];
-    this.forEach((item, index) => {
-      if (item instanceof Error) {
-        throwError(`index ${index}`, item);
-      }
-      if (deep && item instanceof _Result) {
-        item = item.toArray(deep);
-      }
-      result.push(item);
+    const mask2 = (BN_1 << width) - BN_1;
+    return (~value & mask2) + BN_1;
+  } else {
+    assert(value < limit, "too high", "NUMERIC_FAULT", {
+      operation: "toTwos",
+      fault: "overflow",
+      value: _value
     });
-    return result;
-  }
-  /**
-   *  Returns the Result as an Object with each name-value pair. If
-   *  %%deep%%, any children which are Result objects are also
-   *  converted to an Object.
-   *
-   *  This will throw if any value is unnamed, or if there are
-   *  any outstanding deferred errors.
-   */
-  toObject(deep) {
-    const names = getNames(this);
-    return names.reduce((accum, name, index) => {
-      assert(name != null, `value at index ${index} unnamed`, "UNSUPPORTED_OPERATION", {
-        operation: "toObject()"
-      });
-      return toObject(names, this, deep);
-    }, {});
   }
-  /**
-   *  @_ignore
-   */
-  slice(start, end) {
-    if (start == null) {
-      start = 0;
-    }
-    if (start < 0) {
-      start += this.length;
-      if (start < 0) {
-        start = 0;
-      }
-    }
-    if (end == null) {
-      end = this.length;
-    }
-    if (end < 0) {
-      end += this.length;
-      if (end < 0) {
-        end = 0;
+  return value;
+}
+function mask(_value, _bits) {
+  const value = getUint(_value, "value");
+  const bits = BigInt(getNumber(_bits, "bits"));
+  return value & (BN_1 << bits) - BN_1;
+}
+function getBigInt(value, name) {
+  switch (typeof value) {
+    case "bigint":
+      return value;
+    case "number":
+      assertArgument(Number.isInteger(value), "underflow", name || "value", value);
+      assertArgument(value >= -9007199254740991 && value <= maxValue, "overflow", name || "value", value);
+      return BigInt(value);
+    case "string":
+      try {
+        if (value === "") {
+          throw new Error("empty string");
+        }
+        if (value[0] === "-" && value[1] !== "-") {
+          return -BigInt(value.substring(1));
+        }
+        return BigInt(value);
+      } catch (e) {
+        assertArgument(false, `invalid BigNumberish string: ${e.message}`, name || "value", value);
       }
-    }
-    if (end > this.length) {
-      end = this.length;
-    }
-    const _names2 = getNames(this);
-    const result = [], names = [];
-    for (let i = start; i < end; i++) {
-      result.push(this[i]);
-      names.push(_names2[i]);
-    }
-    return new _Result(_guard, result, names);
   }
-  /**
-   *  @_ignore
-   */
-  filter(callback, thisArg) {
-    const _names2 = getNames(this);
-    const result = [], names = [];
-    for (let i = 0; i < this.length; i++) {
-      const item = this[i];
-      if (item instanceof Error) {
-        throwError(`index ${i}`, item);
-      }
-      if (callback.call(thisArg, item, i, this)) {
-        result.push(item);
-        names.push(_names2[i]);
-      }
+  assertArgument(false, "invalid BigNumberish value", name || "value", value);
+}
+function getUint(value, name) {
+  const result = getBigInt(value, name);
+  assert(result >= BN_0, "unsigned value cannot be negative", "NUMERIC_FAULT", {
+    fault: "overflow",
+    operation: "getUint",
+    value
+  });
+  return result;
+}
+const Nibbles = "0123456789abcdef";
+function toBigInt(value) {
+  if (value instanceof Uint8Array) {
+    let result = "0x0";
+    for (const v of value) {
+      result += Nibbles[v >> 4];
+      result += Nibbles[v & 15];
     }
-    return new _Result(_guard, result, names);
+    return BigInt(result);
   }
-  /**
-   *  @_ignore
-   */
-  map(callback, thisArg) {
-    const result = [];
-    for (let i = 0; i < this.length; i++) {
-      const item = this[i];
-      if (item instanceof Error) {
-        throwError(`index ${i}`, item);
+  return getBigInt(value);
+}
+function getNumber(value, name) {
+  switch (typeof value) {
+    case "bigint":
+      assertArgument(value >= -9007199254740991 && value <= maxValue, "overflow", name || "value", value);
+      return Number(value);
+    case "number":
+      assertArgument(Number.isInteger(value), "underflow", name || "value", value);
+      assertArgument(value >= -9007199254740991 && value <= maxValue, "overflow", name || "value", value);
+      return value;
+    case "string":
+      try {
+        if (value === "") {
+          throw new Error("empty string");
+        }
+        return getNumber(BigInt(value), name);
+      } catch (e) {
+        assertArgument(false, `invalid numeric string: ${e.message}`, name || "value", value);
       }
-      result.push(callback.call(thisArg, item, i, this));
-    }
-    return result;
-  }
-  /**
-   *  Returns the value for %%name%%.
-   *
-   *  Since it is possible to have a key whose name conflicts with
-   *  a method on a [[Result]] or its superclass Array, or any
-   *  JavaScript keyword, this ensures all named values are still
-   *  accessible by name.
-   */
-  getValue(name) {
-    const index = getNames(this).indexOf(name);
-    if (index === -1) {
-      return void 0;
-    }
-    const value = this[index];
-    if (value instanceof Error) {
-      throwError(`property ${JSON.stringify(name)}`, value.error);
-    }
-    return value;
-  }
-  /**
-   *  Creates a new [[Result]] for %%items%% with each entry
-   *  also accessible by its corresponding name in %%keys%%.
-   */
-  static fromItems(items, keys) {
-    return new _Result(_guard, items, keys);
-  }
-};
-_names = new WeakMap();
-let Result = _Result;
-function getValue(value) {
-  let bytes = toBeArray(value);
-  assert(bytes.length <= WordSize, "value out-of-bounds", "BUFFER_OVERRUN", { buffer: bytes, length: WordSize, offset: bytes.length });
-  if (bytes.length !== WordSize) {
-    bytes = getBytesCopy(concat([Padding.slice(bytes.length % WordSize), bytes]));
   }
-  return bytes;
+  assertArgument(false, "invalid numeric value", name || "value", value);
 }
-class Coder {
-  constructor(name, type, localName, dynamic) {
-    // The coder name:
-    //   - address, uint256, tuple, array, etc.
-    __publicField(this, "name");
-    // The fully expanded type, including composite types:
-    //   - address, uint256, tuple(address,bytes), uint256[3][4][],  etc.
-    __publicField(this, "type");
-    // The localName bound in the signature, in this example it is "baz":
-    //   - tuple(address foo, uint bar) baz
-    __publicField(this, "localName");
-    // Whether this type is dynamic:
-    //  - Dynamic: bytes, string, address[], tuple(boolean[]), etc.
-    //  - Not Dynamic: address, uint256, boolean[3], tuple(address, uint8)
-    __publicField(this, "dynamic");
-    defineProperties(this, { name, type, localName, dynamic }, {
-      name: "string",
-      type: "string",
-      localName: "string",
-      dynamic: "boolean"
-    });
-  }
-  _throwError(message, value) {
-    assertArgument(false, message, this.localName, value);
-  }
+function toNumber(value) {
+  return getNumber(toBigInt(value));
 }
-class Writer {
-  constructor() {
-    __privateAdd(this, _Writer_instances);
-    // An array of WordSize lengthed objects to concatenation
-    __privateAdd(this, _data);
-    __privateAdd(this, _dataLength);
-    __privateSet(this, _data, []);
-    __privateSet(this, _dataLength, 0);
-  }
-  get data() {
-    return concat(__privateGet(this, _data));
-  }
-  get length() {
-    return __privateGet(this, _dataLength);
-  }
-  appendWriter(writer) {
-    return __privateMethod(this, _Writer_instances, writeData_fn).call(this, getBytesCopy(writer.data));
-  }
-  // Arrayish item; pad on the right to *nearest* WordSize
-  writeBytes(value) {
-    let bytes = getBytesCopy(value);
-    const paddingOffset = bytes.length % WordSize;
-    if (paddingOffset) {
-      bytes = getBytesCopy(concat([bytes, Padding.slice(paddingOffset)]));
+function toBeHex(_value, _width) {
+  const value = getUint(_value, "value");
+  let result = value.toString(16);
+  if (_width == null) {
+    if (result.length % 2) {
+      result = "0" + result;
+    }
+  } else {
+    const width = getNumber(_width, "width");
+    assert(width * 2 >= result.length, `value exceeds width (${width} bytes)`, "NUMERIC_FAULT", {
+      operation: "toBeHex",
+      fault: "overflow",
+      value: _value
+    });
+    while (result.length < width * 2) {
+      result = "0" + result;
     }
-    return __privateMethod(this, _Writer_instances, writeData_fn).call(this, bytes);
-  }
-  // Numeric item; pad on the left *to* WordSize
-  writeValue(value) {
-    return __privateMethod(this, _Writer_instances, writeData_fn).call(this, getValue(value));
-  }
-  // Inserts a numeric place-holder, returning a callback that can
-  // be used to asjust the value later
-  writeUpdatableValue() {
-    const offset = __privateGet(this, _data).length;
-    __privateGet(this, _data).push(Padding);
-    __privateSet(this, _dataLength, __privateGet(this, _dataLength) + WordSize);
-    return (value) => {
-      __privateGet(this, _data)[offset] = getValue(value);
-    };
   }
+  return "0x" + result;
 }
-_data = new WeakMap();
-_dataLength = new WeakMap();
-_Writer_instances = new WeakSet();
-writeData_fn = function(data) {
-  __privateGet(this, _data).push(data);
-  __privateSet(this, _dataLength, __privateGet(this, _dataLength) + data.length);
-  return data.length;
-};
-const _Reader = class _Reader {
-  constructor(data, allowLoose, maxInflation) {
-    __privateAdd(this, _Reader_instances);
-    // Allows incomplete unpadded data to be read; otherwise an error
-    // is raised if attempting to overrun the buffer. This is required
-    // to deal with an old Solidity bug, in which event data for
-    // external (not public thoguh) was tightly packed.
-    __publicField(this, "allowLoose");
-    __privateAdd(this, _data2);
-    __privateAdd(this, _offset);
-    __privateAdd(this, _bytesRead);
-    __privateAdd(this, _parent);
-    __privateAdd(this, _maxInflation);
-    defineProperties(this, { allowLoose: !!allowLoose });
-    __privateSet(this, _data2, getBytesCopy(data));
-    __privateSet(this, _bytesRead, 0);
-    __privateSet(this, _parent, null);
-    __privateSet(this, _maxInflation, maxInflation != null ? maxInflation : 1024);
-    __privateSet(this, _offset, 0);
-  }
-  get data() {
-    return hexlify(__privateGet(this, _data2));
-  }
-  get dataLength() {
-    return __privateGet(this, _data2).length;
-  }
-  get consumed() {
-    return __privateGet(this, _offset);
-  }
-  get bytes() {
-    return new Uint8Array(__privateGet(this, _data2));
-  }
-  // Create a sub-reader with the same underlying data, but offset
-  subReader(offset) {
-    const reader = new _Reader(__privateGet(this, _data2).slice(__privateGet(this, _offset) + offset), this.allowLoose, __privateGet(this, _maxInflation));
-    __privateSet(reader, _parent, this);
-    return reader;
-  }
-  // Read bytes
-  readBytes(length, loose) {
-    let bytes = __privateMethod(this, _Reader_instances, peekBytes_fn).call(this, 0, length, !!loose);
-    __privateMethod(this, _Reader_instances, incrementBytesRead_fn).call(this, length);
-    __privateSet(this, _offset, __privateGet(this, _offset) + bytes.length);
-    return bytes.slice(0, length);
+function toBeArray(_value) {
+  const value = getUint(_value, "value");
+  if (value === BN_0) {
+    return new Uint8Array([]);
   }
-  // Read a numeric values
-  readValue() {
-    return toBigInt(this.readBytes(WordSize));
+  let hex = value.toString(16);
+  if (hex.length % 2) {
+    hex = "0" + hex;
   }
-  readIndex() {
-    return toNumber(this.readBytes(WordSize));
+  const result = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < result.length; i++) {
+    const offset = i * 2;
+    result[i] = parseInt(hex.substring(offset, offset + 2), 16);
   }
-};
-_data2 = new WeakMap();
-_offset = new WeakMap();
-_bytesRead = new WeakMap();
-_parent = new WeakMap();
-_maxInflation = new WeakMap();
-_Reader_instances = new WeakSet();
-incrementBytesRead_fn = function(count) {
-  var _a;
-  if (__privateGet(this, _parent)) {
-    return __privateMethod(_a = __privateGet(this, _parent), _Reader_instances, incrementBytesRead_fn).call(_a, count);
-  }
-  __privateSet(this, _bytesRead, __privateGet(this, _bytesRead) + count);
-  assert(__privateGet(this, _maxInflation) < 1 || __privateGet(this, _bytesRead) <= __privateGet(this, _maxInflation) * this.dataLength, `compressed ABI data exceeds inflation ratio of ${__privateGet(this, _maxInflation)} ( see: https://github.com/ethers-io/ethers.js/issues/4537 )`, "BUFFER_OVERRUN", {
-    buffer: getBytesCopy(__privateGet(this, _data2)),
-    offset: __privateGet(this, _offset),
-    length: count,
-    info: {
-      bytesRead: __privateGet(this, _bytesRead),
-      dataLength: this.dataLength
-    }
-  });
-};
-peekBytes_fn = function(offset, length, loose) {
-  let alignedLength = Math.ceil(length / WordSize) * WordSize;
-  if (__privateGet(this, _offset) + alignedLength > __privateGet(this, _data2).length) {
-    if (this.allowLoose && loose && __privateGet(this, _offset) + length <= __privateGet(this, _data2).length) {
-      alignedLength = length;
-    } else {
-      assert(false, "data out-of-bounds", "BUFFER_OVERRUN", {
-        buffer: getBytesCopy(__privateGet(this, _data2)),
-        length: __privateGet(this, _data2).length,
-        offset: __privateGet(this, _offset) + alignedLength
-      });
-    }
-  }
-  return __privateGet(this, _data2).slice(__privateGet(this, _offset), __privateGet(this, _offset) + alignedLength);
-};
-let Reader = _Reader;
+  return result;
+}
 export {
-  Coder,
-  Reader,
-  Result,
-  WordSize,
-  Writer
+  fromTwos,
+  getBigInt,
+  getNumber,
+  getUint,
+  mask,
+  toBeArray,
+  toBeHex,
+  toBigInt,
+  toNumber,
+  toTwos
 };
 //# sourceMappingURL=standards-sdk.es96.js.map