@hashgraphonline/standards-sdk 0.0.106 → 0.0.107

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

@@ -1,177 +1,441 @@
-import { number, exists, bytes, output } from "./standards-sdk.es81.js";
-import { rotlSH, rotlSL, rotlBH, rotlBL, split } from "./standards-sdk.es82.js";
-import { wrapConstructor, Hash, u32, toBytes } from "./standards-sdk.es83.js";
-const [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];
-const _0n = /* @__PURE__ */ BigInt(0);
-const _1n = /* @__PURE__ */ BigInt(1);
-const _2n = /* @__PURE__ */ BigInt(2);
-const _7n = /* @__PURE__ */ BigInt(7);
-const _256n = /* @__PURE__ */ BigInt(256);
-const _0x71n = /* @__PURE__ */ BigInt(113);
-for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
-  [x, y] = [y, (2 * x + 3 * y) % 5];
-  SHA3_PI.push(2 * (5 * y + x));
-  SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
-  let t = _0n;
-  for (let j = 0; j < 7; j++) {
-    R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
-    if (R & _2n)
-      t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
-  }
-  _SHA3_IOTA.push(t);
+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.es61.js";
+import { assert, assertArgument } from "./standards-sdk.es57.js";
+import { concat, getBytesCopy, hexlify } from "./standards-sdk.es44.js";
+import { defineProperties } from "./standards-sdk.es59.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;
 }
-const [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
-const rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
-const rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
-function keccakP(s, rounds = 24) {
-  const B = new Uint32Array(5 * 2);
-  for (let round = 24 - rounds; round < 24; round++) {
-    for (let x = 0; x < 10; x++)
-      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
-    for (let x = 0; x < 10; x += 2) {
-      const idx1 = (x + 8) % 10;
-      const idx0 = (x + 2) % 10;
-      const B0 = B[idx0];
-      const B1 = B[idx0 + 1];
-      const Th = rotlH(B0, B1, 1) ^ B[idx1];
-      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
-      for (let y = 0; y < 50; y += 10) {
-        s[x + y] ^= Th;
-        s[x + y + 1] ^= Tl;
+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 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;
     }
-    let curH = s[2];
-    let curL = s[3];
-    for (let t = 0; t < 24; t++) {
-      const shift = SHA3_ROTL[t];
-      const Th = rotlH(curH, curL, shift);
-      const Tl = rotlL(curH, curL, shift);
-      const PI = SHA3_PI[t];
-      curH = s[PI];
-      curL = s[PI + 1];
-      s[PI] = Th;
-      s[PI + 1] = Tl;
-    }
-    for (let y = 0; y < 50; y += 10) {
-      for (let x = 0; x < 10; x++)
-        B[x] = s[y + x];
-      for (let x = 0; x < 10; x++)
-        s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
-    }
-    s[0] ^= SHA3_IOTA_H[round];
-    s[1] ^= SHA3_IOTA_L[round];
-  }
-  B.fill(0);
+    return accum;
+  }, {});
 }
-class Keccak extends Hash {
-  // NOTE: we accept arguments in bytes instead of bits here.
-  constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
-    super();
-    this.blockLen = blockLen;
-    this.suffix = suffix;
-    this.outputLen = outputLen;
-    this.enableXOF = enableXOF;
-    this.rounds = rounds;
-    this.pos = 0;
-    this.posOut = 0;
-    this.finished = false;
-    this.destroyed = false;
-    number(outputLen);
-    if (0 >= this.blockLen || this.blockLen >= 200)
-      throw new Error("Sha3 supports only keccak-f1600 function");
-    this.state = new Uint8Array(200);
-    this.state32 = u32(this.state);
-  }
-  keccak() {
-    keccakP(this.state32, this.rounds);
-    this.posOut = 0;
-    this.pos = 0;
-  }
-  update(data) {
-    exists(this);
-    const { blockLen, state } = this;
-    data = toBytes(data);
-    const len = data.length;
-    for (let pos = 0; pos < len; ) {
-      const take = Math.min(blockLen - this.pos, len - pos);
-      for (let i = 0; i < take; i++)
-        state[this.pos++] ^= data[pos++];
-      if (this.pos === blockLen)
-        this.keccak();
-    }
-    return this;
-  }
-  finish() {
-    if (this.finished)
+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;
-    this.finished = true;
-    const { state, suffix, pos, blockLen } = this;
-    state[pos] ^= suffix;
-    if ((suffix & 128) !== 0 && pos === blockLen - 1)
-      this.keccak();
-    state[blockLen - 1] ^= 128;
-    this.keccak();
-  }
-  writeInto(out) {
-    exists(this, false);
-    bytes(out);
-    this.finish();
-    const bufferOut = this.state;
-    const { blockLen } = this;
-    for (let pos = 0, len = out.length; pos < len; ) {
-      if (this.posOut >= blockLen)
-        this.keccak();
-      const take = Math.min(blockLen - this.posOut, len - pos);
-      out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
-      this.posOut += take;
-      pos += take;
-    }
-    return out;
-  }
-  xofInto(out) {
-    if (!this.enableXOF)
-      throw new Error("XOF is not possible for this instance");
-    return this.writeInto(out);
-  }
-  xof(bytes2) {
-    number(bytes2);
-    return this.xofInto(new Uint8Array(bytes2));
-  }
-  digestInto(out) {
-    output(out, this);
-    if (this.finished)
-      throw new Error("digest() was already called");
-    this.writeInto(out);
-    this.destroy();
-    return out;
-  }
-  digest() {
-    return this.digestInto(new Uint8Array(this.outputLen));
-  }
-  destroy() {
-    this.destroyed = true;
-    this.state.fill(0);
-  }
-  _cloneInto(to) {
-    const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
-    to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
-    to.state32.set(this.state32);
-    to.pos = this.pos;
-    to.posOut = this.posOut;
-    to.finished = this.finished;
-    to.rounds = rounds;
-    to.suffix = suffix;
-    to.outputLen = outputLen;
-    to.enableXOF = enableXOF;
-    to.destroyed = this.destroyed;
-    return to;
+    }
+    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;
 }
-const gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
-const keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
+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 {
-  Keccak,
-  keccakP,
-  keccak_256
+  Coder,
+  Reader,
+  Result,
+  WordSize,
+  Writer
 };
 //# sourceMappingURL=standards-sdk.es46.js.map