@hashgraphonline/standards-sdk 0.0.97 → 0.0.99

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

@@ -1,13 +1,441 @@
-import isAbsoluteURL from "./standards-sdk.es100.js";
-import combineURLs from "./standards-sdk.es101.js";
-function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
-  let isRelativeUrl = !isAbsoluteURL(requestedURL);
-  if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) {
-    return combineURLs(baseURL, requestedURL);
+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.es99.js";
+import { assert, assertArgument } from "./standards-sdk.es94.js";
+import { concat, getBytesCopy, hexlify } from "./standards-sdk.es95.js";
+import { defineProperties } from "./standards-sdk.es97.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;
+    });
   }
-  return requestedURL;
+  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;
+  }, {});
 }
+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;
+  }
+  /**
+   *  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);
+    });
+    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;
+      }
+    }
+    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]);
+      }
+    }
+    return new _Result(_guard, result, names);
+  }
+  /**
+   *  @_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%%.
+   *
+   *  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;
+}
+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);
+  }
+  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);
+};
+let Reader = _Reader;
 export {
-  buildFullPath as default
+  Coder,
+  Reader,
+  Result,
+  WordSize,
+  Writer
 };
 //# sourceMappingURL=standards-sdk.es83.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es83.js","sources":["../../node_modules/axios/lib/core/buildFullPath.js"],"sourcesContent":["'use strict';\n\nimport isAbsoluteURL from '../helpers/isAbsoluteURL.js';\nimport combineURLs from '../helpers/combineURLs.js';\n\n/**\n * Creates a new URL by combining the baseURL with the requestedURL,\n * only when the requestedURL is not already an absolute URL.\n * If the requestURL is absolute, this function returns the requestedURL untouched.\n *\n * @param {string} baseURL The base URL\n * @param {string} requestedURL Absolute or relative URL to combine\n *\n * @returns {string} The combined full path\n */\nexport default function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {\n  let isRelativeUrl = !isAbsoluteURL(requestedURL);\n  if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) {\n    return combineURLs(baseURL, requestedURL);\n  }\n  return requestedURL;\n}\n"],"names":[],"mappings":";;AAee,SAAS,cAAc,SAAS,cAAc,mBAAmB;AAC9E,MAAI,gBAAgB,CAAC,cAAc,YAAY;AAC/C,MAAI,YAAY,iBAAiB,qBAAqB,QAAQ;AAC5D,WAAO,YAAY,SAAS,YAAY;AAAA,EAC5C;AACE,SAAO;AACT;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es83.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/abstract-coder.js"],"sourcesContent":["import { defineProperties, concat, getBytesCopy, getNumber, hexlify, toBeArray, toBigInt, toNumber, assert, assertArgument\n/*, isError*/\n } from \"../../utils/index.js\";\n/**\n * @_ignore:\n */\nexport const WordSize = 32;\nconst Padding = new Uint8Array(WordSize);\n// Properties used to immediate pass through to the underlying object\n// - `then` is used to detect if an object is a Promise for await\nconst passProperties = [\"then\"];\nconst _guard = {};\nconst resultNames = new WeakMap();\nfunction getNames(result) {\n    return resultNames.get(result);\n}\nfunction setNames(result, names) {\n    resultNames.set(result, names);\n}\nfunction throwError(name, error) {\n    const wrapped = new Error(`deferred error during ABI decoding triggered accessing ${name}`);\n    wrapped.error = error;\n    throw wrapped;\n}\nfunction toObject(names, items, deep) {\n    if (names.indexOf(null) >= 0) {\n        return items.map((item, index) => {\n            if (item instanceof Result) {\n                return toObject(getNames(item), item, deep);\n            }\n            return item;\n        });\n    }\n    return names.reduce((accum, name, index) => {\n        let item = items.getValue(name);\n        if (!(name in accum)) {\n            if (deep && item instanceof Result) {\n                item = toObject(getNames(item), item, deep);\n            }\n            accum[name] = item;\n        }\n        return accum;\n    }, {});\n}\n/**\n *  A [[Result]] is a sub-class of Array, which allows accessing any\n *  of its values either positionally by its index or, if keys are\n *  provided by its name.\n *\n *  @_docloc: api/abi\n */\nexport class Result extends Array {\n    // No longer used; but cannot be removed as it will remove the\n    // #private field from the .d.ts which may break backwards\n    // compatibility\n    #names;\n    /**\n     *  @private\n     */\n    constructor(...args) {\n        // To properly sub-class Array so the other built-in\n        // functions work, the constructor has to behave fairly\n        // well. So, in the event we are created via fromItems()\n        // we build the read-only Result object we want, but on\n        // any other input, we use the default constructor\n        // constructor(guard: any, items: Array<any>, keys?: Array<null | string>);\n        const guard = args[0];\n        let items = args[1];\n        let names = (args[2] || []).slice();\n        let wrap = true;\n        if (guard !== _guard) {\n            items = args;\n            names = [];\n            wrap = false;\n        }\n        // Can't just pass in ...items since an array of length 1\n        // is a special case in the super.\n        super(items.length);\n        items.forEach((item, index) => { this[index] = item; });\n        // Find all unique keys\n        const nameCounts = names.reduce((accum, name) => {\n            if (typeof (name) === \"string\") {\n                accum.set(name, (accum.get(name) || 0) + 1);\n            }\n            return accum;\n        }, (new Map()));\n        // Remove any key thats not unique\n        setNames(this, Object.freeze(items.map((item, index) => {\n            const name = names[index];\n            if (name != null && nameCounts.get(name) === 1) {\n                return name;\n            }\n            return null;\n        })));\n        // Dummy operations to prevent TypeScript from complaining\n        this.#names = [];\n        if (this.#names == null) {\n            void (this.#names);\n        }\n        if (!wrap) {\n            return;\n        }\n        // A wrapped Result is immutable\n        Object.freeze(this);\n        // Proxy indices and names so we can trap deferred errors\n        const proxy = new Proxy(this, {\n            get: (target, prop, receiver) => {\n                if (typeof (prop) === \"string\") {\n                    // Index accessor\n                    if (prop.match(/^[0-9]+$/)) {\n                        const index = getNumber(prop, \"%index\");\n                        if (index < 0 || index >= this.length) {\n                            throw new RangeError(\"out of result range\");\n                        }\n                        const item = target[index];\n                        if (item instanceof Error) {\n                            throwError(`index ${index}`, item);\n                        }\n                        return item;\n                    }\n                    // Pass important checks (like `then` for Promise) through\n                    if (passProperties.indexOf(prop) >= 0) {\n                        return Reflect.get(target, prop, receiver);\n                    }\n                    const value = target[prop];\n                    if (value instanceof Function) {\n                        // Make sure functions work with private variables\n                        // See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy#no_private_property_forwarding\n                        return function (...args) {\n                            return value.apply((this === receiver) ? target : this, args);\n                        };\n                    }\n                    else if (!(prop in target)) {\n                        // Possible name accessor\n                        return target.getValue.apply((this === receiver) ? target : this, [prop]);\n                    }\n                }\n                return Reflect.get(target, prop, receiver);\n            }\n        });\n        setNames(proxy, getNames(this));\n        return proxy;\n    }\n    /**\n     *  Returns the Result as a normal Array. If %%deep%%, any children\n     *  which are Result objects are also converted to a normal Array.\n     *\n     *  This will throw if there are any outstanding deferred\n     *  errors.\n     */\n    toArray(deep) {\n        const result = [];\n        this.forEach((item, index) => {\n            if (item instanceof Error) {\n                throwError(`index ${index}`, item);\n            }\n            if (deep && item instanceof Result) {\n                item = item.toArray(deep);\n            }\n            result.push(item);\n        });\n        return result;\n    }\n    /**\n     *  Returns the Result as an Object with each name-value pair. If\n     *  %%deep%%, any children which are Result objects are also\n     *  converted to an Object.\n     *\n     *  This will throw if any value is unnamed, or if there are\n     *  any outstanding deferred errors.\n     */\n    toObject(deep) {\n        const names = getNames(this);\n        return names.reduce((accum, name, index) => {\n            assert(name != null, `value at index ${index} unnamed`, \"UNSUPPORTED_OPERATION\", {\n                operation: \"toObject()\"\n            });\n            return toObject(names, this, deep);\n        }, {});\n    }\n    /**\n     *  @_ignore\n     */\n    slice(start, end) {\n        if (start == null) {\n            start = 0;\n        }\n        if (start < 0) {\n            start += this.length;\n            if (start < 0) {\n                start = 0;\n            }\n        }\n        if (end == null) {\n            end = this.length;\n        }\n        if (end < 0) {\n            end += this.length;\n            if (end < 0) {\n                end = 0;\n            }\n        }\n        if (end > this.length) {\n            end = this.length;\n        }\n        const _names = getNames(this);\n        const result = [], names = [];\n        for (let i = start; i < end; i++) {\n            result.push(this[i]);\n            names.push(_names[i]);\n        }\n        return new Result(_guard, result, names);\n    }\n    /**\n     *  @_ignore\n     */\n    filter(callback, thisArg) {\n        const _names = getNames(this);\n        const result = [], names = [];\n        for (let i = 0; i < this.length; i++) {\n            const item = this[i];\n            if (item instanceof Error) {\n                throwError(`index ${i}`, item);\n            }\n            if (callback.call(thisArg, item, i, this)) {\n                result.push(item);\n                names.push(_names[i]);\n            }\n        }\n        return new Result(_guard, result, names);\n    }\n    /**\n     *  @_ignore\n     */\n    map(callback, thisArg) {\n        const result = [];\n        for (let i = 0; i < this.length; i++) {\n            const item = this[i];\n            if (item instanceof Error) {\n                throwError(`index ${i}`, item);\n            }\n            result.push(callback.call(thisArg, item, i, this));\n        }\n        return result;\n    }\n    /**\n     *  Returns the value for %%name%%.\n     *\n     *  Since it is possible to have a key whose name conflicts with\n     *  a method on a [[Result]] or its superclass Array, or any\n     *  JavaScript keyword, this ensures all named values are still\n     *  accessible by name.\n     */\n    getValue(name) {\n        const index = getNames(this).indexOf(name);\n        if (index === -1) {\n            return undefined;\n        }\n        const value = this[index];\n        if (value instanceof Error) {\n            throwError(`property ${JSON.stringify(name)}`, value.error);\n        }\n        return value;\n    }\n    /**\n     *  Creates a new [[Result]] for %%items%% with each entry\n     *  also accessible by its corresponding name in %%keys%%.\n     */\n    static fromItems(items, keys) {\n        return new Result(_guard, items, keys);\n    }\n}\n/**\n *  Returns all errors found in a [[Result]].\n *\n *  Since certain errors encountered when creating a [[Result]] do\n *  not impact the ability to continue parsing data, they are\n *  deferred until they are actually accessed. Hence a faulty string\n *  in an Event that is never used does not impact the program flow.\n *\n *  However, sometimes it may be useful to access, identify or\n *  validate correctness of a [[Result]].\n *\n *  @_docloc api/abi\n */\nexport function checkResultErrors(result) {\n    // Find the first error (if any)\n    const errors = [];\n    const checkErrors = function (path, object) {\n        if (!Array.isArray(object)) {\n            return;\n        }\n        for (let key in object) {\n            const childPath = path.slice();\n            childPath.push(key);\n            try {\n                checkErrors(childPath, object[key]);\n            }\n            catch (error) {\n                errors.push({ path: childPath, error: error });\n            }\n        }\n    };\n    checkErrors([], result);\n    return errors;\n}\nfunction getValue(value) {\n    let bytes = toBeArray(value);\n    assert(bytes.length <= WordSize, \"value out-of-bounds\", \"BUFFER_OVERRUN\", { buffer: bytes, length: WordSize, offset: bytes.length });\n    if (bytes.length !== WordSize) {\n        bytes = getBytesCopy(concat([Padding.slice(bytes.length % WordSize), bytes]));\n    }\n    return bytes;\n}\n/**\n *  @_ignore\n */\nexport class Coder {\n    // The coder name:\n    //   - address, uint256, tuple, array, etc.\n    name;\n    // The fully expanded type, including composite types:\n    //   - address, uint256, tuple(address,bytes), uint256[3][4][],  etc.\n    type;\n    // The localName bound in the signature, in this example it is \"baz\":\n    //   - tuple(address foo, uint bar) baz\n    localName;\n    // Whether this type is dynamic:\n    //  - Dynamic: bytes, string, address[], tuple(boolean[]), etc.\n    //  - Not Dynamic: address, uint256, boolean[3], tuple(address, uint8)\n    dynamic;\n    constructor(name, type, localName, dynamic) {\n        defineProperties(this, { name, type, localName, dynamic }, {\n            name: \"string\", type: \"string\", localName: \"string\", dynamic: \"boolean\"\n        });\n    }\n    _throwError(message, value) {\n        assertArgument(false, message, this.localName, value);\n    }\n}\n/**\n *  @_ignore\n */\nexport class Writer {\n    // An array of WordSize lengthed objects to concatenation\n    #data;\n    #dataLength;\n    constructor() {\n        this.#data = [];\n        this.#dataLength = 0;\n    }\n    get data() {\n        return concat(this.#data);\n    }\n    get length() { return this.#dataLength; }\n    #writeData(data) {\n        this.#data.push(data);\n        this.#dataLength += data.length;\n        return data.length;\n    }\n    appendWriter(writer) {\n        return this.#writeData(getBytesCopy(writer.data));\n    }\n    // Arrayish item; pad on the right to *nearest* WordSize\n    writeBytes(value) {\n        let bytes = getBytesCopy(value);\n        const paddingOffset = bytes.length % WordSize;\n        if (paddingOffset) {\n            bytes = getBytesCopy(concat([bytes, Padding.slice(paddingOffset)]));\n        }\n        return this.#writeData(bytes);\n    }\n    // Numeric item; pad on the left *to* WordSize\n    writeValue(value) {\n        return this.#writeData(getValue(value));\n    }\n    // Inserts a numeric place-holder, returning a callback that can\n    // be used to asjust the value later\n    writeUpdatableValue() {\n        const offset = this.#data.length;\n        this.#data.push(Padding);\n        this.#dataLength += WordSize;\n        return (value) => {\n            this.#data[offset] = getValue(value);\n        };\n    }\n}\n/**\n *  @_ignore\n */\nexport class Reader {\n    // Allows incomplete unpadded data to be read; otherwise an error\n    // is raised if attempting to overrun the buffer. This is required\n    // to deal with an old Solidity bug, in which event data for\n    // external (not public thoguh) was tightly packed.\n    allowLoose;\n    #data;\n    #offset;\n    #bytesRead;\n    #parent;\n    #maxInflation;\n    constructor(data, allowLoose, maxInflation) {\n        defineProperties(this, { allowLoose: !!allowLoose });\n        this.#data = getBytesCopy(data);\n        this.#bytesRead = 0;\n        this.#parent = null;\n        this.#maxInflation = (maxInflation != null) ? maxInflation : 1024;\n        this.#offset = 0;\n    }\n    get data() { return hexlify(this.#data); }\n    get dataLength() { return this.#data.length; }\n    get consumed() { return this.#offset; }\n    get bytes() { return new Uint8Array(this.#data); }\n    #incrementBytesRead(count) {\n        if (this.#parent) {\n            return this.#parent.#incrementBytesRead(count);\n        }\n        this.#bytesRead += count;\n        // Check for excessive inflation (see: #4537)\n        assert(this.#maxInflation < 1 || this.#bytesRead <= this.#maxInflation * this.dataLength, `compressed ABI data exceeds inflation ratio of ${this.#maxInflation} ( see: https:/\\/github.com/ethers-io/ethers.js/issues/4537 )`, \"BUFFER_OVERRUN\", {\n            buffer: getBytesCopy(this.#data), offset: this.#offset,\n            length: count, info: {\n                bytesRead: this.#bytesRead,\n                dataLength: this.dataLength\n            }\n        });\n    }\n    #peekBytes(offset, length, loose) {\n        let alignedLength = Math.ceil(length / WordSize) * WordSize;\n        if (this.#offset + alignedLength > this.#data.length) {\n            if (this.allowLoose && loose && this.#offset + length <= this.#data.length) {\n                alignedLength = length;\n            }\n            else {\n                assert(false, \"data out-of-bounds\", \"BUFFER_OVERRUN\", {\n                    buffer: getBytesCopy(this.#data),\n                    length: this.#data.length,\n                    offset: this.#offset + alignedLength\n                });\n            }\n        }\n        return this.#data.slice(this.#offset, this.#offset + alignedLength);\n    }\n    // Create a sub-reader with the same underlying data, but offset\n    subReader(offset) {\n        const reader = new Reader(this.#data.slice(this.#offset + offset), this.allowLoose, this.#maxInflation);\n        reader.#parent = this;\n        return reader;\n    }\n    // Read bytes\n    readBytes(length, loose) {\n        let bytes = this.#peekBytes(0, length, !!loose);\n        this.#incrementBytesRead(length);\n        this.#offset += bytes.length;\n        // @TODO: Make sure the length..end bytes are all 0?\n        return bytes.slice(0, length);\n    }\n    // Read a numeric values\n    readValue() {\n        return toBigInt(this.readBytes(WordSize));\n    }\n    readIndex() {\n        return toNumber(this.readBytes(WordSize));\n    }\n}\n//# sourceMappingURL=abstract-coder.js.map"],"names":["args","_names","_data"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -1,68 +1,28 @@
-import { VERSION } from "./standards-sdk.es45.js";
-import AxiosError from "./standards-sdk.es47.js";
-const validators = {};
-["object", "boolean", "number", "function", "string", "symbol"].forEach((type, i) => {
-  validators[type] = function validator2(thing) {
-    return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
-  };
-});
-const deprecatedWarnings = {};
-validators.transitional = function transitional(validator2, version, message) {
-  function formatMessage(opt, desc) {
-    return "[Axios v" + VERSION + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
+import { toBeHex } from "./standards-sdk.es99.js";
+import { Typed } from "./standards-sdk.es101.js";
+import { Coder } from "./standards-sdk.es83.js";
+import { getAddress } from "./standards-sdk.es96.js";
+class AddressCoder extends Coder {
+  constructor(localName) {
+    super("address", "address", localName, false);
   }
-  return (value, opt, opts) => {
-    if (validator2 === false) {
-      throw new AxiosError(
-        formatMessage(opt, " has been removed" + (version ? " in " + version : "")),
-        AxiosError.ERR_DEPRECATED
-      );
-    }
-    if (version && !deprecatedWarnings[opt]) {
-      deprecatedWarnings[opt] = true;
-      console.warn(
-        formatMessage(
-          opt,
-          " has been deprecated since v" + version + " and will be removed in the near future"
-        )
-      );
-    }
-    return validator2 ? validator2(value, opt, opts) : true;
-  };
-};
-validators.spelling = function spelling(correctSpelling) {
-  return (value, opt) => {
-    console.warn(`${opt} is likely a misspelling of ${correctSpelling}`);
-    return true;
-  };
-};
-function assertOptions(options, schema, allowUnknown) {
-  if (typeof options !== "object") {
-    throw new AxiosError("options must be an object", AxiosError.ERR_BAD_OPTION_VALUE);
+  defaultValue() {
+    return "0x0000000000000000000000000000000000000000";
   }
-  const keys = Object.keys(options);
-  let i = keys.length;
-  while (i-- > 0) {
-    const opt = keys[i];
-    const validator2 = schema[opt];
-    if (validator2) {
-      const value = options[opt];
-      const result = value === void 0 || validator2(value, opt, options);
-      if (result !== true) {
-        throw new AxiosError("option " + opt + " must be " + result, AxiosError.ERR_BAD_OPTION_VALUE);
-      }
-      continue;
-    }
-    if (allowUnknown !== true) {
-      throw new AxiosError("Unknown option " + opt, AxiosError.ERR_BAD_OPTION);
+  encode(writer, _value) {
+    let value = Typed.dereference(_value, "string");
+    try {
+      value = getAddress(value);
+    } catch (error) {
+      return this._throwError(error.message, _value);
     }
+    return writer.writeValue(value);
+  }
+  decode(reader) {
+    return getAddress(toBeHex(reader.readValue(), 20));
   }
 }
-const validator = {
-  assertOptions,
-  validators
-};
 export {
-  validator as default
+  AddressCoder
 };
 //# sourceMappingURL=standards-sdk.es84.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es84.js","sources":["../../node_modules/axios/lib/helpers/validator.js"],"sourcesContent":["'use strict';\n\nimport {VERSION} from '../env/data.js';\nimport AxiosError from '../core/AxiosError.js';\n\nconst validators = {};\n\n// eslint-disable-next-line func-names\n['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach((type, i) => {\n  validators[type] = function validator(thing) {\n    return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;\n  };\n});\n\nconst deprecatedWarnings = {};\n\n/**\n * Transitional option validator\n *\n * @param {function|boolean?} validator - set to false if the transitional option has been removed\n * @param {string?} version - deprecated version / removed since version\n * @param {string?} message - some message with additional info\n *\n * @returns {function}\n */\nvalidators.transitional = function transitional(validator, version, message) {\n  function formatMessage(opt, desc) {\n    return '[Axios v' + VERSION + '] Transitional option \\'' + opt + '\\'' + desc + (message ? '. ' + message : '');\n  }\n\n  // eslint-disable-next-line func-names\n  return (value, opt, opts) => {\n    if (validator === false) {\n      throw new AxiosError(\n        formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),\n        AxiosError.ERR_DEPRECATED\n      );\n    }\n\n    if (version && !deprecatedWarnings[opt]) {\n      deprecatedWarnings[opt] = true;\n      // eslint-disable-next-line no-console\n      console.warn(\n        formatMessage(\n          opt,\n          ' has been deprecated since v' + version + ' and will be removed in the near future'\n        )\n      );\n    }\n\n    return validator ? validator(value, opt, opts) : true;\n  };\n};\n\nvalidators.spelling = function spelling(correctSpelling) {\n  return (value, opt) => {\n    // eslint-disable-next-line no-console\n    console.warn(`${opt} is likely a misspelling of ${correctSpelling}`);\n    return true;\n  }\n};\n\n/**\n * Assert object's properties type\n *\n * @param {object} options\n * @param {object} schema\n * @param {boolean?} allowUnknown\n *\n * @returns {object}\n */\n\nfunction assertOptions(options, schema, allowUnknown) {\n  if (typeof options !== 'object') {\n    throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE);\n  }\n  const keys = Object.keys(options);\n  let i = keys.length;\n  while (i-- > 0) {\n    const opt = keys[i];\n    const validator = schema[opt];\n    if (validator) {\n      const value = options[opt];\n      const result = value === undefined || validator(value, opt, options);\n      if (result !== true) {\n        throw new AxiosError('option ' + opt + ' must be ' + result, AxiosError.ERR_BAD_OPTION_VALUE);\n      }\n      continue;\n    }\n    if (allowUnknown !== true) {\n      throw new AxiosError('Unknown option ' + opt, AxiosError.ERR_BAD_OPTION);\n    }\n  }\n}\n\nexport default {\n  assertOptions,\n  validators\n};\n"],"names":["validator"],"mappings":";;AAKA,MAAM,aAAa,CAAE;AAGrB,CAAC,UAAU,WAAW,UAAU,YAAY,UAAU,QAAQ,EAAE,QAAQ,CAAC,MAAM,MAAM;AACnF,aAAW,IAAI,IAAI,SAASA,WAAU,OAAO;AAC3C,WAAO,OAAO,UAAU,QAAQ,OAAO,IAAI,IAAI,OAAO,OAAO;AAAA,EAC9D;AACH,CAAC;AAED,MAAM,qBAAqB,CAAE;AAW7B,WAAW,eAAe,SAAS,aAAaA,YAAW,SAAS,SAAS;AAC3E,WAAS,cAAc,KAAK,MAAM;AAChC,WAAO,aAAa,UAAU,4BAA6B,MAAM,MAAO,QAAQ,UAAU,OAAO,UAAU;AAAA,EAC/G;AAGE,SAAO,CAAC,OAAO,KAAK,SAAS;AAC3B,QAAIA,eAAc,OAAO;AACvB,YAAM,IAAI;AAAA,QACR,cAAc,KAAK,uBAAuB,UAAU,SAAS,UAAU,GAAG;AAAA,QAC1E,WAAW;AAAA,MACZ;AAAA,IACP;AAEI,QAAI,WAAW,CAAC,mBAAmB,GAAG,GAAG;AACvC,yBAAmB,GAAG,IAAI;AAE1B,cAAQ;AAAA,QACN;AAAA,UACE;AAAA,UACA,iCAAiC,UAAU;AAAA,QACrD;AAAA,MACO;AAAA,IACP;AAEI,WAAOA,aAAYA,WAAU,OAAO,KAAK,IAAI,IAAI;AAAA,EAClD;AACH;AAEA,WAAW,WAAW,SAAS,SAAS,iBAAiB;AACvD,SAAO,CAAC,OAAO,QAAQ;AAErB,YAAQ,KAAK,GAAG,GAAG,+BAA+B,eAAe,EAAE;AACnE,WAAO;AAAA,EACX;AACA;AAYA,SAAS,cAAc,SAAS,QAAQ,cAAc;AACpD,MAAI,OAAO,YAAY,UAAU;AAC/B,UAAM,IAAI,WAAW,6BAA6B,WAAW,oBAAoB;AAAA,EACrF;AACE,QAAM,OAAO,OAAO,KAAK,OAAO;AAChC,MAAI,IAAI,KAAK;AACb,SAAO,MAAM,GAAG;AACd,UAAM,MAAM,KAAK,CAAC;AAClB,UAAMA,aAAY,OAAO,GAAG;AAC5B,QAAIA,YAAW;AACb,YAAM,QAAQ,QAAQ,GAAG;AACzB,YAAM,SAAS,UAAU,UAAaA,WAAU,OAAO,KAAK,OAAO;AACnE,UAAI,WAAW,MAAM;AACnB,cAAM,IAAI,WAAW,YAAY,MAAM,cAAc,QAAQ,WAAW,oBAAoB;AAAA,MACpG;AACM;AAAA,IACN;AACI,QAAI,iBAAiB,MAAM;AACzB,YAAM,IAAI,WAAW,oBAAoB,KAAK,WAAW,cAAc;AAAA,IAC7E;AAAA,EACA;AACA;AAEA,MAAe,YAAA;AAAA,EACb;AAAA,EACA;AACF;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es84.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/address.js"],"sourcesContent":["import { getAddress } from \"../../address/index.js\";\nimport { toBeHex } from \"../../utils/maths.js\";\nimport { Typed } from \"../typed.js\";\nimport { Coder } from \"./abstract-coder.js\";\n/**\n *  @_ignore\n */\nexport class AddressCoder extends Coder {\n    constructor(localName) {\n        super(\"address\", \"address\", localName, false);\n    }\n    defaultValue() {\n        return \"0x0000000000000000000000000000000000000000\";\n    }\n    encode(writer, _value) {\n        let value = Typed.dereference(_value, \"string\");\n        try {\n            value = getAddress(value);\n        }\n        catch (error) {\n            return this._throwError(error.message, _value);\n        }\n        return writer.writeValue(value);\n    }\n    decode(reader) {\n        return getAddress(toBeHex(reader.readValue(), 20));\n    }\n}\n//# sourceMappingURL=address.js.map"],"names":[],"mappings":";;;;AAOO,MAAM,qBAAqB,MAAM;AAAA,EACpC,YAAY,WAAW;AACnB,UAAM,WAAW,WAAW,WAAW,KAAK;AAAA,EACpD;AAAA,EACI,eAAe;AACX,WAAO;AAAA,EACf;AAAA,EACI,OAAO,QAAQ,QAAQ;AACnB,QAAI,QAAQ,MAAM,YAAY,QAAQ,QAAQ;AAC9C,QAAI;AACA,cAAQ,WAAW,KAAK;AAAA,IACpC,SACe,OAAO;AACV,aAAO,KAAK,YAAY,MAAM,SAAS,MAAM;AAAA,IACzD;AACQ,WAAO,OAAO,WAAW,KAAK;AAAA,EACtC;AAAA,EACI,OAAO,QAAQ;AACX,WAAO,WAAW,QAAQ,OAAO,UAAW,GAAE,EAAE,CAAC;AAAA,EACzD;AACA;","x_google_ignoreList":[0]}