@hashgraphonline/standards-sdk 0.0.57 → 0.0.58

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

@@ -1,441 +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 __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.es106.js";
-import { assert, assertArgument } from "./standards-sdk.es90.js";
-import { concat, getBytesCopy, hexlify } from "./standards-sdk.es91.js";
-import { defineProperties } from "./standards-sdk.es104.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);
+var _AbiCoder_instances, getCoder_fn;
+import { Writer, Reader } from "./standards-sdk.es94.js";
+import { AddressCoder } from "./standards-sdk.es95.js";
+import { ArrayCoder } from "./standards-sdk.es96.js";
+import { BooleanCoder } from "./standards-sdk.es97.js";
+import { BytesCoder } from "./standards-sdk.es98.js";
+import { FixedBytesCoder } from "./standards-sdk.es99.js";
+import { NullCoder } from "./standards-sdk.es100.js";
+import { NumberCoder } from "./standards-sdk.es101.js";
+import { StringCoder } from "./standards-sdk.es102.js";
+import { TupleCoder } from "./standards-sdk.es103.js";
+import { ParamType } from "./standards-sdk.es104.js";
+import { assertArgument, assertArgumentCount, makeError } from "./standards-sdk.es90.js";
+import { getBytes, hexlify } from "./standards-sdk.es91.js";
+import { getAddress } from "./standards-sdk.es88.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)";
       }
-      return item;
-    });
-  }
-  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);
+    } 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)";
       }
-      accum[name] = item;
-    }
-    return accum;
-  }, {});
+    } else {
+      message += " (unknown custom error)";
+    }
+  }
+  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 _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;
-    });
-    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;
+const _AbiCoder = class _AbiCoder {
+  constructor() {
+    __privateAdd(this, _AbiCoder_instances);
   }
   /**
-   *  Returns the Result as a normal Array. If %%deep%%, any children
-   *  which are Result objects are also converted to a normal Array.
+   *  Get the default values for the given %%types%%.
    *
-   *  This will throw if there are any outstanding deferred
-   *  errors.
+   *  For example, a ``uint`` is by default ``0`` and ``bool``
+   *  is by default ``false``.
    */
-  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);
-    });
-    return result;
+  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 the Result as an Object with each name-value pair. If
-   *  %%deep%%, any children which are Result objects are also
-   *  converted to an Object.
+   *  Encode the %%values%% as the %%types%% into ABI data.
    *
-   *  This will throw if any value is unnamed, or if there are
-   *  any outstanding deferred errors.
+   *  @returns DataHexstring
    */
-  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);
-    }, {});
+  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;
   }
   /**
-   *  @_ignore
+   *  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.
    */
-  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;
-      }
-    }
-    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);
+  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));
   }
-  /**
-   *  @_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]);
-      }
-    }
-    return new _Result(_guard, result, names);
+  static _setDefaultMaxInflation(value) {
+    assertArgument(typeof value === "number" && Number.isInteger(value), "invalid defaultMaxInflation factor", "value", value);
+    defaultMaxInflation = value;
   }
   /**
-   *  @_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);
-      }
-      result.push(callback.call(thisArg, item, i, this));
-    }
-    return result;
-  }
-  /**
-   *  Returns the value for %%name%%.
+   *  Returns the shared singleton instance of a default [[AbiCoder]].
    *
-   *  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.
+   *  On the first call, the instance is created internally.
    */
-  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);
+  static defaultAbiCoder() {
+    if (defaultCoder == null) {
+      defaultCoder = new _AbiCoder();
     }
-    return value;
+    return defaultCoder;
   }
   /**
-   *  Creates a new [[Result]] for %%items%% with each entry
-   *  also accessible by its corresponding name in %%keys%%.
+   *  Returns an ethers-compatible [[CallExceptionError]] Error for the given
+   *  result %%data%% for the [[CallExceptionAction]] %%action%% against
+   *  the Transaction %%tx%%.
    */
-  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;
-}
-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);
-  }
-}
-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);
+  static getBuiltinCallException(action, tx, data) {
+    return getBuiltinCallException(action, tx, data, _AbiCoder.defaultAbiCoder());
   }
-  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)]));
-    }
-    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);
-    };
-  }
-}
-_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);
-  }
-  // Read a numeric values
-  readValue() {
-    return toBigInt(this.readBytes(WordSize));
-  }
-  readIndex() {
-    return toNumber(this.readBytes(WordSize));
-  }
-};
-_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);
+_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 Reader = _Reader;
+let AbiCoder = _AbiCoder;
 export {
-  Coder,
-  Reader,
-  Result,
-  WordSize,
-  Writer
+  AbiCoder
 };
 //# sourceMappingURL=standards-sdk.es93.js.map