@hashgraphonline/standards-sdk 0.0.109 → 0.0.111

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

@@ -1 +0,0 @@
-{"version":3,"file":"standards-sdk.es113.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -1,177 +0,0 @@
-import { number, exists, bytes, output } from "./standards-sdk.es124.js";
-import { rotlSH, rotlSL, rotlBH, rotlBL, split } from "./standards-sdk.es125.js";
-import { wrapConstructor, Hash, u32, toBytes } from "./standards-sdk.es126.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);
-}
-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;
-      }
-    }
-    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);
-}
-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)
-      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;
-  }
-}
-const gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
-const keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
-export {
-  Keccak,
-  keccakP,
-  keccak_256
-};
-//# sourceMappingURL=standards-sdk.es114.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"standards-sdk.es114.js","sources":["../../node_modules/@noble/hashes/esm/sha3.js"],"sourcesContent":["import { bytes, exists, number, output } from './_assert.js';\nimport { rotlBH, rotlBL, rotlSH, rotlSL, split } from './_u64.js';\nimport { Hash, u32, toBytes, wrapConstructor, wrapXOFConstructorWithOpts, } from './utils.js';\n// SHA3 (keccak) is based on a new design: basically, the internal state is bigger than output size.\n// It's called a sponge function.\n// Various per round constants calculations\nconst [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nconst _2n = /* @__PURE__ */ BigInt(2);\nconst _7n = /* @__PURE__ */ BigInt(7);\nconst _256n = /* @__PURE__ */ BigInt(256);\nconst _0x71n = /* @__PURE__ */ BigInt(0x71);\nfor (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {\n    // Pi\n    [x, y] = [y, (2 * x + 3 * y) % 5];\n    SHA3_PI.push(2 * (5 * y + x));\n    // Rotational\n    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);\n    // Iota\n    let t = _0n;\n    for (let j = 0; j < 7; j++) {\n        R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;\n        if (R & _2n)\n            t ^= _1n << ((_1n << /* @__PURE__ */ BigInt(j)) - _1n);\n    }\n    _SHA3_IOTA.push(t);\n}\nconst [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);\n// Left rotation (without 0, 32, 64)\nconst rotlH = (h, l, s) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));\nconst rotlL = (h, l, s) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));\n// Same as keccakf1600, but allows to skip some rounds\nexport function keccakP(s, rounds = 24) {\n    const B = new Uint32Array(5 * 2);\n    // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)\n    for (let round = 24 - rounds; round < 24; round++) {\n        // Theta θ\n        for (let x = 0; x < 10; x++)\n            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];\n        for (let x = 0; x < 10; x += 2) {\n            const idx1 = (x + 8) % 10;\n            const idx0 = (x + 2) % 10;\n            const B0 = B[idx0];\n            const B1 = B[idx0 + 1];\n            const Th = rotlH(B0, B1, 1) ^ B[idx1];\n            const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];\n            for (let y = 0; y < 50; y += 10) {\n                s[x + y] ^= Th;\n                s[x + y + 1] ^= Tl;\n            }\n        }\n        // Rho (ρ) and Pi (π)\n        let curH = s[2];\n        let curL = s[3];\n        for (let t = 0; t < 24; t++) {\n            const shift = SHA3_ROTL[t];\n            const Th = rotlH(curH, curL, shift);\n            const Tl = rotlL(curH, curL, shift);\n            const PI = SHA3_PI[t];\n            curH = s[PI];\n            curL = s[PI + 1];\n            s[PI] = Th;\n            s[PI + 1] = Tl;\n        }\n        // Chi (χ)\n        for (let y = 0; y < 50; y += 10) {\n            for (let x = 0; x < 10; x++)\n                B[x] = s[y + x];\n            for (let x = 0; x < 10; x++)\n                s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];\n        }\n        // Iota (ι)\n        s[0] ^= SHA3_IOTA_H[round];\n        s[1] ^= SHA3_IOTA_L[round];\n    }\n    B.fill(0);\n}\nexport class Keccak extends Hash {\n    // NOTE: we accept arguments in bytes instead of bits here.\n    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {\n        super();\n        this.blockLen = blockLen;\n        this.suffix = suffix;\n        this.outputLen = outputLen;\n        this.enableXOF = enableXOF;\n        this.rounds = rounds;\n        this.pos = 0;\n        this.posOut = 0;\n        this.finished = false;\n        this.destroyed = false;\n        // Can be passed from user as dkLen\n        number(outputLen);\n        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes\n        if (0 >= this.blockLen || this.blockLen >= 200)\n            throw new Error('Sha3 supports only keccak-f1600 function');\n        this.state = new Uint8Array(200);\n        this.state32 = u32(this.state);\n    }\n    keccak() {\n        keccakP(this.state32, this.rounds);\n        this.posOut = 0;\n        this.pos = 0;\n    }\n    update(data) {\n        exists(this);\n        const { blockLen, state } = this;\n        data = toBytes(data);\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            for (let i = 0; i < take; i++)\n                state[this.pos++] ^= data[pos++];\n            if (this.pos === blockLen)\n                this.keccak();\n        }\n        return this;\n    }\n    finish() {\n        if (this.finished)\n            return;\n        this.finished = true;\n        const { state, suffix, pos, blockLen } = this;\n        // Do the padding\n        state[pos] ^= suffix;\n        if ((suffix & 0x80) !== 0 && pos === blockLen - 1)\n            this.keccak();\n        state[blockLen - 1] ^= 0x80;\n        this.keccak();\n    }\n    writeInto(out) {\n        exists(this, false);\n        bytes(out);\n        this.finish();\n        const bufferOut = this.state;\n        const { blockLen } = this;\n        for (let pos = 0, len = out.length; pos < len;) {\n            if (this.posOut >= blockLen)\n                this.keccak();\n            const take = Math.min(blockLen - this.posOut, len - pos);\n            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);\n            this.posOut += take;\n            pos += take;\n        }\n        return out;\n    }\n    xofInto(out) {\n        // Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF\n        if (!this.enableXOF)\n            throw new Error('XOF is not possible for this instance');\n        return this.writeInto(out);\n    }\n    xof(bytes) {\n        number(bytes);\n        return this.xofInto(new Uint8Array(bytes));\n    }\n    digestInto(out) {\n        output(out, this);\n        if (this.finished)\n            throw new Error('digest() was already called');\n        this.writeInto(out);\n        this.destroy();\n        return out;\n    }\n    digest() {\n        return this.digestInto(new Uint8Array(this.outputLen));\n    }\n    destroy() {\n        this.destroyed = true;\n        this.state.fill(0);\n    }\n    _cloneInto(to) {\n        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;\n        to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));\n        to.state32.set(this.state32);\n        to.pos = this.pos;\n        to.posOut = this.posOut;\n        to.finished = this.finished;\n        to.rounds = rounds;\n        // Suffix can change in cSHAKE\n        to.suffix = suffix;\n        to.outputLen = outputLen;\n        to.enableXOF = enableXOF;\n        to.destroyed = this.destroyed;\n        return to;\n    }\n}\nconst gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));\nexport const sha3_224 = /* @__PURE__ */ gen(0x06, 144, 224 / 8);\n/**\n * SHA3-256 hash function\n * @param message - that would be hashed\n */\nexport const sha3_256 = /* @__PURE__ */ gen(0x06, 136, 256 / 8);\nexport const sha3_384 = /* @__PURE__ */ gen(0x06, 104, 384 / 8);\nexport const sha3_512 = /* @__PURE__ */ gen(0x06, 72, 512 / 8);\nexport const keccak_224 = /* @__PURE__ */ gen(0x01, 144, 224 / 8);\n/**\n * keccak-256 hash function. Different from SHA3-256.\n * @param message - that would be hashed\n */\nexport const keccak_256 = /* @__PURE__ */ gen(0x01, 136, 256 / 8);\nexport const keccak_384 = /* @__PURE__ */ gen(0x01, 104, 384 / 8);\nexport const keccak_512 = /* @__PURE__ */ gen(0x01, 72, 512 / 8);\nconst genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true));\nexport const shake128 = /* @__PURE__ */ genShake(0x1f, 168, 128 / 8);\nexport const shake256 = /* @__PURE__ */ genShake(0x1f, 136, 256 / 8);\n//# sourceMappingURL=sha3.js.map"],"names":["bytes"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -1,146 +0,0 @@
-import { getBytes } from "./standards-sdk.es106.js";
-import { assertArgument } from "./standards-sdk.es105.js";
-function errorFunc(reason, offset, bytes, output, badCodepoint) {
-  assertArgument(false, `invalid codepoint at offset ${offset}; ${reason}`, "bytes", bytes);
-}
-function ignoreFunc(reason, offset, bytes, output, badCodepoint) {
-  if (reason === "BAD_PREFIX" || reason === "UNEXPECTED_CONTINUE") {
-    let i = 0;
-    for (let o = offset + 1; o < bytes.length; o++) {
-      if (bytes[o] >> 6 !== 2) {
-        break;
-      }
-      i++;
-    }
-    return i;
-  }
-  if (reason === "OVERRUN") {
-    return bytes.length - offset - 1;
-  }
-  return 0;
-}
-function replaceFunc(reason, offset, bytes, output, badCodepoint) {
-  if (reason === "OVERLONG") {
-    assertArgument(typeof badCodepoint === "number", "invalid bad code point for replacement", "badCodepoint", badCodepoint);
-    output.push(badCodepoint);
-    return 0;
-  }
-  output.push(65533);
-  return ignoreFunc(reason, offset, bytes);
-}
-const Utf8ErrorFuncs = Object.freeze({
-  error: errorFunc,
-  ignore: ignoreFunc,
-  replace: replaceFunc
-});
-function getUtf8CodePoints(_bytes, onError) {
-  if (onError == null) {
-    onError = Utf8ErrorFuncs.error;
-  }
-  const bytes = getBytes(_bytes, "bytes");
-  const result = [];
-  let i = 0;
-  while (i < bytes.length) {
-    const c = bytes[i++];
-    if (c >> 7 === 0) {
-      result.push(c);
-      continue;
-    }
-    let extraLength = null;
-    let overlongMask = null;
-    if ((c & 224) === 192) {
-      extraLength = 1;
-      overlongMask = 127;
-    } else if ((c & 240) === 224) {
-      extraLength = 2;
-      overlongMask = 2047;
-    } else if ((c & 248) === 240) {
-      extraLength = 3;
-      overlongMask = 65535;
-    } else {
-      if ((c & 192) === 128) {
-        i += onError("UNEXPECTED_CONTINUE", i - 1, bytes, result);
-      } else {
-        i += onError("BAD_PREFIX", i - 1, bytes, result);
-      }
-      continue;
-    }
-    if (i - 1 + extraLength >= bytes.length) {
-      i += onError("OVERRUN", i - 1, bytes, result);
-      continue;
-    }
-    let res = c & (1 << 8 - extraLength - 1) - 1;
-    for (let j = 0; j < extraLength; j++) {
-      let nextChar = bytes[i];
-      if ((nextChar & 192) != 128) {
-        i += onError("MISSING_CONTINUE", i, bytes, result);
-        res = null;
-        break;
-      }
-      res = res << 6 | nextChar & 63;
-      i++;
-    }
-    if (res === null) {
-      continue;
-    }
-    if (res > 1114111) {
-      i += onError("OUT_OF_RANGE", i - 1 - extraLength, bytes, result, res);
-      continue;
-    }
-    if (res >= 55296 && res <= 57343) {
-      i += onError("UTF16_SURROGATE", i - 1 - extraLength, bytes, result, res);
-      continue;
-    }
-    if (res <= overlongMask) {
-      i += onError("OVERLONG", i - 1 - extraLength, bytes, result, res);
-      continue;
-    }
-    result.push(res);
-  }
-  return result;
-}
-function toUtf8Bytes(str, form) {
-  assertArgument(typeof str === "string", "invalid string value", "str", str);
-  let result = [];
-  for (let i = 0; i < str.length; i++) {
-    const c = str.charCodeAt(i);
-    if (c < 128) {
-      result.push(c);
-    } else if (c < 2048) {
-      result.push(c >> 6 | 192);
-      result.push(c & 63 | 128);
-    } else if ((c & 64512) == 55296) {
-      i++;
-      const c2 = str.charCodeAt(i);
-      assertArgument(i < str.length && (c2 & 64512) === 56320, "invalid surrogate pair", "str", str);
-      const pair = 65536 + ((c & 1023) << 10) + (c2 & 1023);
-      result.push(pair >> 18 | 240);
-      result.push(pair >> 12 & 63 | 128);
-      result.push(pair >> 6 & 63 | 128);
-      result.push(pair & 63 | 128);
-    } else {
-      result.push(c >> 12 | 224);
-      result.push(c >> 6 & 63 | 128);
-      result.push(c & 63 | 128);
-    }
-  }
-  return new Uint8Array(result);
-}
-function _toUtf8String(codePoints) {
-  return codePoints.map((codePoint) => {
-    if (codePoint <= 65535) {
-      return String.fromCharCode(codePoint);
-    }
-    codePoint -= 65536;
-    return String.fromCharCode((codePoint >> 10 & 1023) + 55296, (codePoint & 1023) + 56320);
-  }).join("");
-}
-function toUtf8String(bytes, onError) {
-  return _toUtf8String(getUtf8CodePoints(bytes, onError));
-}
-export {
-  Utf8ErrorFuncs,
-  toUtf8Bytes,
-  toUtf8String
-};
-//# sourceMappingURL=standards-sdk.es115.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"standards-sdk.es115.js","sources":["../../node_modules/ethers/lib.esm/utils/utf8.js"],"sourcesContent":["/**\n *  Using strings in Ethereum (or any security-basd system) requires\n *  additional care. These utilities attempt to mitigate some of the\n *  safety issues as well as provide the ability to recover and analyse\n *  strings.\n *\n *  @_subsection api/utils:Strings and UTF-8  [about-strings]\n */\nimport { getBytes } from \"./data.js\";\nimport { assertArgument, assertNormalize } from \"./errors.js\";\nfunction errorFunc(reason, offset, bytes, output, badCodepoint) {\n    assertArgument(false, `invalid codepoint at offset ${offset}; ${reason}`, \"bytes\", bytes);\n}\nfunction ignoreFunc(reason, offset, bytes, output, badCodepoint) {\n    // If there is an invalid prefix (including stray continuation), skip any additional continuation bytes\n    if (reason === \"BAD_PREFIX\" || reason === \"UNEXPECTED_CONTINUE\") {\n        let i = 0;\n        for (let o = offset + 1; o < bytes.length; o++) {\n            if (bytes[o] >> 6 !== 0x02) {\n                break;\n            }\n            i++;\n        }\n        return i;\n    }\n    // This byte runs us past the end of the string, so just jump to the end\n    // (but the first byte was read already read and therefore skipped)\n    if (reason === \"OVERRUN\") {\n        return bytes.length - offset - 1;\n    }\n    // Nothing to skip\n    return 0;\n}\nfunction replaceFunc(reason, offset, bytes, output, badCodepoint) {\n    // Overlong representations are otherwise \"valid\" code points; just non-deistingtished\n    if (reason === \"OVERLONG\") {\n        assertArgument(typeof (badCodepoint) === \"number\", \"invalid bad code point for replacement\", \"badCodepoint\", badCodepoint);\n        output.push(badCodepoint);\n        return 0;\n    }\n    // Put the replacement character into the output\n    output.push(0xfffd);\n    // Otherwise, process as if ignoring errors\n    return ignoreFunc(reason, offset, bytes, output, badCodepoint);\n}\n/**\n *  A handful of popular, built-in UTF-8 error handling strategies.\n *\n *  **``\"error\"``** - throws on ANY illegal UTF-8 sequence or\n *  non-canonical (overlong) codepoints (this is the default)\n *\n *  **``\"ignore\"``** - silently drops any illegal UTF-8 sequence\n *  and accepts non-canonical (overlong) codepoints\n *\n *  **``\"replace\"``** - replace any illegal UTF-8 sequence with the\n *  UTF-8 replacement character (i.e. ``\"\\\\ufffd\"``) and accepts\n *  non-canonical (overlong) codepoints\n *\n *  @returns: Record<\"error\" | \"ignore\" | \"replace\", Utf8ErrorFunc>\n */\nexport const Utf8ErrorFuncs = Object.freeze({\n    error: errorFunc,\n    ignore: ignoreFunc,\n    replace: replaceFunc\n});\n// http://stackoverflow.com/questions/13356493/decode-utf-8-with-javascript#13691499\nfunction getUtf8CodePoints(_bytes, onError) {\n    if (onError == null) {\n        onError = Utf8ErrorFuncs.error;\n    }\n    const bytes = getBytes(_bytes, \"bytes\");\n    const result = [];\n    let i = 0;\n    // Invalid bytes are ignored\n    while (i < bytes.length) {\n        const c = bytes[i++];\n        // 0xxx xxxx\n        if (c >> 7 === 0) {\n            result.push(c);\n            continue;\n        }\n        // Multibyte; how many bytes left for this character?\n        let extraLength = null;\n        let overlongMask = null;\n        // 110x xxxx 10xx xxxx\n        if ((c & 0xe0) === 0xc0) {\n            extraLength = 1;\n            overlongMask = 0x7f;\n            // 1110 xxxx 10xx xxxx 10xx xxxx\n        }\n        else if ((c & 0xf0) === 0xe0) {\n            extraLength = 2;\n            overlongMask = 0x7ff;\n            // 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx\n        }\n        else if ((c & 0xf8) === 0xf0) {\n            extraLength = 3;\n            overlongMask = 0xffff;\n        }\n        else {\n            if ((c & 0xc0) === 0x80) {\n                i += onError(\"UNEXPECTED_CONTINUE\", i - 1, bytes, result);\n            }\n            else {\n                i += onError(\"BAD_PREFIX\", i - 1, bytes, result);\n            }\n            continue;\n        }\n        // Do we have enough bytes in our data?\n        if (i - 1 + extraLength >= bytes.length) {\n            i += onError(\"OVERRUN\", i - 1, bytes, result);\n            continue;\n        }\n        // Remove the length prefix from the char\n        let res = c & ((1 << (8 - extraLength - 1)) - 1);\n        for (let j = 0; j < extraLength; j++) {\n            let nextChar = bytes[i];\n            // Invalid continuation byte\n            if ((nextChar & 0xc0) != 0x80) {\n                i += onError(\"MISSING_CONTINUE\", i, bytes, result);\n                res = null;\n                break;\n            }\n            ;\n            res = (res << 6) | (nextChar & 0x3f);\n            i++;\n        }\n        // See above loop for invalid continuation byte\n        if (res === null) {\n            continue;\n        }\n        // Maximum code point\n        if (res > 0x10ffff) {\n            i += onError(\"OUT_OF_RANGE\", i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        // Reserved for UTF-16 surrogate halves\n        if (res >= 0xd800 && res <= 0xdfff) {\n            i += onError(\"UTF16_SURROGATE\", i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        // Check for overlong sequences (more bytes than needed)\n        if (res <= overlongMask) {\n            i += onError(\"OVERLONG\", i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        result.push(res);\n    }\n    return result;\n}\n// http://stackoverflow.com/questions/18729405/how-to-convert-utf8-string-to-byte-array\n/**\n *  Returns the UTF-8 byte representation of %%str%%.\n *\n *  If %%form%% is specified, the string is normalized.\n */\nexport function toUtf8Bytes(str, form) {\n    assertArgument(typeof (str) === \"string\", \"invalid string value\", \"str\", str);\n    if (form != null) {\n        assertNormalize(form);\n        str = str.normalize(form);\n    }\n    let result = [];\n    for (let i = 0; i < str.length; i++) {\n        const c = str.charCodeAt(i);\n        if (c < 0x80) {\n            result.push(c);\n        }\n        else if (c < 0x800) {\n            result.push((c >> 6) | 0xc0);\n            result.push((c & 0x3f) | 0x80);\n        }\n        else if ((c & 0xfc00) == 0xd800) {\n            i++;\n            const c2 = str.charCodeAt(i);\n            assertArgument(i < str.length && ((c2 & 0xfc00) === 0xdc00), \"invalid surrogate pair\", \"str\", str);\n            // Surrogate Pair\n            const pair = 0x10000 + ((c & 0x03ff) << 10) + (c2 & 0x03ff);\n            result.push((pair >> 18) | 0xf0);\n            result.push(((pair >> 12) & 0x3f) | 0x80);\n            result.push(((pair >> 6) & 0x3f) | 0x80);\n            result.push((pair & 0x3f) | 0x80);\n        }\n        else {\n            result.push((c >> 12) | 0xe0);\n            result.push(((c >> 6) & 0x3f) | 0x80);\n            result.push((c & 0x3f) | 0x80);\n        }\n    }\n    return new Uint8Array(result);\n}\n;\n//export \nfunction _toUtf8String(codePoints) {\n    return codePoints.map((codePoint) => {\n        if (codePoint <= 0xffff) {\n            return String.fromCharCode(codePoint);\n        }\n        codePoint -= 0x10000;\n        return String.fromCharCode((((codePoint >> 10) & 0x3ff) + 0xd800), ((codePoint & 0x3ff) + 0xdc00));\n    }).join(\"\");\n}\n/**\n *  Returns the string represented by the UTF-8 data %%bytes%%.\n *\n *  When %%onError%% function is specified, it is called on UTF-8\n *  errors allowing recovery using the [[Utf8ErrorFunc]] API.\n *  (default: [error](Utf8ErrorFuncs))\n */\nexport function toUtf8String(bytes, onError) {\n    return _toUtf8String(getUtf8CodePoints(bytes, onError));\n}\n/**\n *  Returns the UTF-8 code-points for %%str%%.\n *\n *  If %%form%% is specified, the string is normalized.\n */\nexport function toUtf8CodePoints(str, form) {\n    return getUtf8CodePoints(toUtf8Bytes(str, form));\n}\n//# sourceMappingURL=utf8.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -1,6 +0,0 @@
-import AxiosURLSearchParams from "./standards-sdk.es83.js";
-const URLSearchParams$1 = typeof URLSearchParams !== "undefined" ? URLSearchParams : AxiosURLSearchParams;
-export {
-  URLSearchParams$1 as default
-};
-//# sourceMappingURL=standards-sdk.es116.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"standards-sdk.es116.js","sources":["../../node_modules/axios/lib/platform/browser/classes/URLSearchParams.js"],"sourcesContent":["'use strict';\n\nimport AxiosURLSearchParams from '../../../helpers/AxiosURLSearchParams.js';\nexport default typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;\n"],"names":[],"mappings":";AAGA,MAAA,oBAAe,OAAO,oBAAoB,cAAc,kBAAkB;","x_google_ignoreList":[0]}

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

@@ -1,5 +0,0 @@
-const FormData$1 = typeof FormData !== "undefined" ? FormData : null;
-export {
-  FormData$1 as default
-};
-//# sourceMappingURL=standards-sdk.es117.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"standards-sdk.es117.js","sources":["../../node_modules/axios/lib/platform/browser/classes/FormData.js"],"sourcesContent":["'use strict';\n\nexport default typeof FormData !== 'undefined' ? FormData : null;\n"],"names":[],"mappings":"AAEA,MAAA,aAAe,OAAO,aAAa,cAAc,WAAW;","x_google_ignoreList":[0]}

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

@@ -1,5 +0,0 @@
-const Blob$1 = typeof Blob !== "undefined" ? Blob : null;
-export {
-  Blob$1 as default
-};
-//# sourceMappingURL=standards-sdk.es118.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"standards-sdk.es118.js","sources":["../../node_modules/axios/lib/platform/browser/classes/Blob.js"],"sourcesContent":["'use strict'\n\nexport default typeof Blob !== 'undefined' ? Blob : null\n"],"names":[],"mappings":"AAEA,MAAA,SAAe,OAAO,SAAS,cAAc,OAAO;","x_google_ignoreList":[0]}

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

@@ -1,37 +0,0 @@
-function speedometer(samplesCount, min) {
-  samplesCount = samplesCount || 10;
-  const bytes = new Array(samplesCount);
-  const timestamps = new Array(samplesCount);
-  let head = 0;
-  let tail = 0;
-  let firstSampleTS;
-  min = min !== void 0 ? min : 1e3;
-  return function push(chunkLength) {
-    const now = Date.now();
-    const startedAt = timestamps[tail];
-    if (!firstSampleTS) {
-      firstSampleTS = now;
-    }
-    bytes[head] = chunkLength;
-    timestamps[head] = now;
-    let i = tail;
-    let bytesCount = 0;
-    while (i !== head) {
-      bytesCount += bytes[i++];
-      i = i % samplesCount;
-    }
-    head = (head + 1) % samplesCount;
-    if (head === tail) {
-      tail = (tail + 1) % samplesCount;
-    }
-    if (now - firstSampleTS < min) {
-      return;
-    }
-    const passed = startedAt && now - startedAt;
-    return passed ? Math.round(bytesCount * 1e3 / passed) : void 0;
-  };
-}
-export {
-  speedometer as default
-};
-//# sourceMappingURL=standards-sdk.es119.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"standards-sdk.es119.js","sources":["../../node_modules/axios/lib/helpers/speedometer.js"],"sourcesContent":["'use strict';\n\n/**\n * Calculate data maxRate\n * @param {Number} [samplesCount= 10]\n * @param {Number} [min= 1000]\n * @returns {Function}\n */\nfunction speedometer(samplesCount, min) {\n  samplesCount = samplesCount || 10;\n  const bytes = new Array(samplesCount);\n  const timestamps = new Array(samplesCount);\n  let head = 0;\n  let tail = 0;\n  let firstSampleTS;\n\n  min = min !== undefined ? min : 1000;\n\n  return function push(chunkLength) {\n    const now = Date.now();\n\n    const startedAt = timestamps[tail];\n\n    if (!firstSampleTS) {\n      firstSampleTS = now;\n    }\n\n    bytes[head] = chunkLength;\n    timestamps[head] = now;\n\n    let i = tail;\n    let bytesCount = 0;\n\n    while (i !== head) {\n      bytesCount += bytes[i++];\n      i = i % samplesCount;\n    }\n\n    head = (head + 1) % samplesCount;\n\n    if (head === tail) {\n      tail = (tail + 1) % samplesCount;\n    }\n\n    if (now - firstSampleTS < min) {\n      return;\n    }\n\n    const passed = startedAt && now - startedAt;\n\n    return passed ? Math.round(bytesCount * 1000 / passed) : undefined;\n  };\n}\n\nexport default speedometer;\n"],"names":[],"mappings":"AAQA,SAAS,YAAY,cAAc,KAAK;AACtC,iBAAe,gBAAgB;AAC/B,QAAM,QAAQ,IAAI,MAAM,YAAY;AACpC,QAAM,aAAa,IAAI,MAAM,YAAY;AACzC,MAAI,OAAO;AACX,MAAI,OAAO;AACX,MAAI;AAEJ,QAAM,QAAQ,SAAY,MAAM;AAEhC,SAAO,SAAS,KAAK,aAAa;AAChC,UAAM,MAAM,KAAK,IAAK;AAEtB,UAAM,YAAY,WAAW,IAAI;AAEjC,QAAI,CAAC,eAAe;AAClB,sBAAgB;AAAA,IACtB;AAEI,UAAM,IAAI,IAAI;AACd,eAAW,IAAI,IAAI;AAEnB,QAAI,IAAI;AACR,QAAI,aAAa;AAEjB,WAAO,MAAM,MAAM;AACjB,oBAAc,MAAM,GAAG;AACvB,UAAI,IAAI;AAAA,IACd;AAEI,YAAQ,OAAO,KAAK;AAEpB,QAAI,SAAS,MAAM;AACjB,cAAQ,OAAO,KAAK;AAAA,IAC1B;AAEI,QAAI,MAAM,gBAAgB,KAAK;AAC7B;AAAA,IACN;AAEI,UAAM,SAAS,aAAa,MAAM;AAElC,WAAO,SAAS,KAAK,MAAM,aAAa,MAAO,MAAM,IAAI;AAAA,EAC1D;AACH;","x_google_ignoreList":[0]}

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

@@ -1,36 +0,0 @@
-function throttle(fn, freq) {
-  let timestamp = 0;
-  let threshold = 1e3 / freq;
-  let lastArgs;
-  let timer;
-  const invoke = (args, now = Date.now()) => {
-    timestamp = now;
-    lastArgs = null;
-    if (timer) {
-      clearTimeout(timer);
-      timer = null;
-    }
-    fn.apply(null, args);
-  };
-  const throttled = (...args) => {
-    const now = Date.now();
-    const passed = now - timestamp;
-    if (passed >= threshold) {
-      invoke(args, now);
-    } else {
-      lastArgs = args;
-      if (!timer) {
-        timer = setTimeout(() => {
-          timer = null;
-          invoke(lastArgs);
-        }, threshold - passed);
-      }
-    }
-  };
-  const flush = () => lastArgs && invoke(lastArgs);
-  return [throttled, flush];
-}
-export {
-  throttle as default
-};
-//# sourceMappingURL=standards-sdk.es120.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"standards-sdk.es120.js","sources":["../../node_modules/axios/lib/helpers/throttle.js"],"sourcesContent":["/**\n * Throttle decorator\n * @param {Function} fn\n * @param {Number} freq\n * @return {Function}\n */\nfunction throttle(fn, freq) {\n  let timestamp = 0;\n  let threshold = 1000 / freq;\n  let lastArgs;\n  let timer;\n\n  const invoke = (args, now = Date.now()) => {\n    timestamp = now;\n    lastArgs = null;\n    if (timer) {\n      clearTimeout(timer);\n      timer = null;\n    }\n    fn.apply(null, args);\n  }\n\n  const throttled = (...args) => {\n    const now = Date.now();\n    const passed = now - timestamp;\n    if ( passed >= threshold) {\n      invoke(args, now);\n    } else {\n      lastArgs = args;\n      if (!timer) {\n        timer = setTimeout(() => {\n          timer = null;\n          invoke(lastArgs)\n        }, threshold - passed);\n      }\n    }\n  }\n\n  const flush = () => lastArgs && invoke(lastArgs);\n\n  return [throttled, flush];\n}\n\nexport default throttle;\n"],"names":[],"mappings":"AAMA,SAAS,SAAS,IAAI,MAAM;AAC1B,MAAI,YAAY;AAChB,MAAI,YAAY,MAAO;AACvB,MAAI;AACJ,MAAI;AAEJ,QAAM,SAAS,CAAC,MAAM,MAAM,KAAK,IAAG,MAAO;AACzC,gBAAY;AACZ,eAAW;AACX,QAAI,OAAO;AACT,mBAAa,KAAK;AAClB,cAAQ;AAAA,IACd;AACI,OAAG,MAAM,MAAM,IAAI;AAAA,EACvB;AAEE,QAAM,YAAY,IAAI,SAAS;AAC7B,UAAM,MAAM,KAAK,IAAK;AACtB,UAAM,SAAS,MAAM;AACrB,QAAK,UAAU,WAAW;AACxB,aAAO,MAAM,GAAG;AAAA,IACtB,OAAW;AACL,iBAAW;AACX,UAAI,CAAC,OAAO;AACV,gBAAQ,WAAW,MAAM;AACvB,kBAAQ;AACR,iBAAO,QAAQ;AAAA,QACzB,GAAW,YAAY,MAAM;AAAA,MAC7B;AAAA,IACA;AAAA,EACA;AAEE,QAAM,QAAQ,MAAM,YAAY,OAAO,QAAQ;AAE/C,SAAO,CAAC,WAAW,KAAK;AAC1B;","x_google_ignoreList":[0]}

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

@@ -1,12 +0,0 @@
-import platform from "./standards-sdk.es71.js";
-const isURLSameOrigin = platform.hasStandardBrowserEnv ? /* @__PURE__ */ ((origin, isMSIE) => (url) => {
-  url = new URL(url, platform.origin);
-  return origin.protocol === url.protocol && origin.host === url.host && (isMSIE || origin.port === url.port);
-})(
-  new URL(platform.origin),
-  platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent)
-) : () => true;
-export {
-  isURLSameOrigin as default
-};
-//# sourceMappingURL=standards-sdk.es121.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"standards-sdk.es121.js","sources":["../../node_modules/axios/lib/helpers/isURLSameOrigin.js"],"sourcesContent":["import platform from '../platform/index.js';\n\nexport default platform.hasStandardBrowserEnv ? ((origin, isMSIE) => (url) => {\n  url = new URL(url, platform.origin);\n\n  return (\n    origin.protocol === url.protocol &&\n    origin.host === url.host &&\n    (isMSIE || origin.port === url.port)\n  );\n})(\n  new URL(platform.origin),\n  platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent)\n) : () => true;\n"],"names":[],"mappings":";AAEA,MAAA,kBAAe,SAAS,wBAAyB,kBAAC,QAAQ,WAAW,CAAC,QAAQ;AAC5E,QAAM,IAAI,IAAI,KAAK,SAAS,MAAM;AAElC,SACE,OAAO,aAAa,IAAI,YACxB,OAAO,SAAS,IAAI,SACnB,UAAU,OAAO,SAAS,IAAI;AAEnC;AAAA,EACE,IAAI,IAAI,SAAS,MAAM;AAAA,EACvB,SAAS,aAAa,kBAAkB,KAAK,SAAS,UAAU,SAAS;AAC3E,IAAI,MAAM;","x_google_ignoreList":[0]}

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

@@ -1,37 +0,0 @@
-import utils from "./standards-sdk.es45.js";
-import platform from "./standards-sdk.es71.js";
-const cookies = platform.hasStandardBrowserEnv ? (
-  // Standard browser envs support document.cookie
-  {
-    write(name, value, expires, path, domain, secure) {
-      const cookie = [name + "=" + encodeURIComponent(value)];
-      utils.isNumber(expires) && cookie.push("expires=" + new Date(expires).toGMTString());
-      utils.isString(path) && cookie.push("path=" + path);
-      utils.isString(domain) && cookie.push("domain=" + domain);
-      secure === true && cookie.push("secure");
-      document.cookie = cookie.join("; ");
-    },
-    read(name) {
-      const match = document.cookie.match(new RegExp("(^|;\\s*)(" + name + ")=([^;]*)"));
-      return match ? decodeURIComponent(match[3]) : null;
-    },
-    remove(name) {
-      this.write(name, "", Date.now() - 864e5);
-    }
-  }
-) : (
-  // Non-standard browser env (web workers, react-native) lack needed support.
-  {
-    write() {
-    },
-    read() {
-      return null;
-    },
-    remove() {
-    }
-  }
-);
-export {
-  cookies as default
-};
-//# sourceMappingURL=standards-sdk.es122.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"standards-sdk.es122.js","sources":["../../node_modules/axios/lib/helpers/cookies.js"],"sourcesContent":["import utils from './../utils.js';\nimport platform from '../platform/index.js';\n\nexport default platform.hasStandardBrowserEnv ?\n\n  // Standard browser envs support document.cookie\n  {\n    write(name, value, expires, path, domain, secure) {\n      const cookie = [name + '=' + encodeURIComponent(value)];\n\n      utils.isNumber(expires) && cookie.push('expires=' + new Date(expires).toGMTString());\n\n      utils.isString(path) && cookie.push('path=' + path);\n\n      utils.isString(domain) && cookie.push('domain=' + domain);\n\n      secure === true && cookie.push('secure');\n\n      document.cookie = cookie.join('; ');\n    },\n\n    read(name) {\n      const match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n      return (match ? decodeURIComponent(match[3]) : null);\n    },\n\n    remove(name) {\n      this.write(name, '', Date.now() - 86400000);\n    }\n  }\n\n  :\n\n  // Non-standard browser env (web workers, react-native) lack needed support.\n  {\n    write() {},\n    read() {\n      return null;\n    },\n    remove() {}\n  };\n\n"],"names":[],"mappings":";;AAGA,MAAe,UAAA,SAAS;AAAA;AAAA,EAGtB;AAAA,IACE,MAAM,MAAM,OAAO,SAAS,MAAM,QAAQ,QAAQ;AAChD,YAAM,SAAS,CAAC,OAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtD,YAAM,SAAS,OAAO,KAAK,OAAO,KAAK,aAAa,IAAI,KAAK,OAAO,EAAE,YAAW,CAAE;AAEnF,YAAM,SAAS,IAAI,KAAK,OAAO,KAAK,UAAU,IAAI;AAElD,YAAM,SAAS,MAAM,KAAK,OAAO,KAAK,YAAY,MAAM;AAExD,iBAAW,QAAQ,OAAO,KAAK,QAAQ;AAEvC,eAAS,SAAS,OAAO,KAAK,IAAI;AAAA,IACnC;AAAA,IAED,KAAK,MAAM;AACT,YAAM,QAAQ,SAAS,OAAO,MAAM,IAAI,OAAO,eAAe,OAAO,WAAW,CAAC;AACjF,aAAQ,QAAQ,mBAAmB,MAAM,CAAC,CAAC,IAAI;AAAA,IAChD;AAAA,IAED,OAAO,MAAM;AACX,WAAK,MAAM,MAAM,IAAI,KAAK,IAAK,IAAG,KAAQ;AAAA,IAChD;AAAA,EACA;AAAA;AAAA;AAAA,EAKE;AAAA,IACE,QAAQ;AAAA,IAAE;AAAA,IACV,OAAO;AACL,aAAO;AAAA,IACR;AAAA,IACD,SAAS;AAAA,IAAA;AAAA,EACV;AAAA;","x_google_ignoreList":[0]}

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

@@ -1,24 +0,0 @@
-var __defProp = Object.defineProperty;
-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);
-import { Coder } from "./standards-sdk.es94.js";
-class AnonymousCoder extends Coder {
-  constructor(coder) {
-    super(coder.name, coder.type, "_", coder.dynamic);
-    __publicField(this, "coder");
-    this.coder = coder;
-  }
-  defaultValue() {
-    return this.coder.defaultValue();
-  }
-  encode(writer, value) {
-    return this.coder.encode(writer, value);
-  }
-  decode(reader) {
-    return this.coder.decode(reader);
-  }
-}
-export {
-  AnonymousCoder
-};
-//# sourceMappingURL=standards-sdk.es123.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"standards-sdk.es123.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/anonymous.js"],"sourcesContent":["import { Coder } from \"./abstract-coder.js\";\n/**\n *  Clones the functionality of an existing Coder, but without a localName\n *\n *  @_ignore\n */\nexport class AnonymousCoder extends Coder {\n    coder;\n    constructor(coder) {\n        super(coder.name, coder.type, \"_\", coder.dynamic);\n        this.coder = coder;\n    }\n    defaultValue() {\n        return this.coder.defaultValue();\n    }\n    encode(writer, value) {\n        return this.coder.encode(writer, value);\n    }\n    decode(reader) {\n        return this.coder.decode(reader);\n    }\n}\n//# sourceMappingURL=anonymous.js.map"],"names":[],"mappings":";;;;AAMO,MAAM,uBAAuB,MAAM;AAAA,EAEtC,YAAY,OAAO;AACf,UAAM,MAAM,MAAM,MAAM,MAAM,KAAK,MAAM,OAAO;AAFpD;AAGI,SAAK,QAAQ;AAAA,EACrB;AAAA,EACI,eAAe;AACX,WAAO,KAAK,MAAM,aAAc;AAAA,EACxC;AAAA,EACI,OAAO,QAAQ,OAAO;AAClB,WAAO,KAAK,MAAM,OAAO,QAAQ,KAAK;AAAA,EAC9C;AAAA,EACI,OAAO,QAAQ;AACX,WAAO,KAAK,MAAM,OAAO,MAAM;AAAA,EACvC;AACA;","x_google_ignoreList":[0]}

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

@@ -1,30 +0,0 @@
-function number(n) {
-  if (!Number.isSafeInteger(n) || n < 0)
-    throw new Error(`Wrong positive integer: ${n}`);
-}
-function bytes(b, ...lengths) {
-  if (!(b instanceof Uint8Array))
-    throw new Error("Expected Uint8Array");
-  if (lengths.length > 0 && !lengths.includes(b.length))
-    throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
-}
-function exists(instance, checkFinished = true) {
-  if (instance.destroyed)
-    throw new Error("Hash instance has been destroyed");
-  if (checkFinished && instance.finished)
-    throw new Error("Hash#digest() has already been called");
-}
-function output(out, instance) {
-  bytes(out);
-  const min = instance.outputLen;
-  if (out.length < min) {
-    throw new Error(`digestInto() expects output buffer of length at least ${min}`);
-  }
-}
-export {
-  bytes,
-  exists,
-  number,
-  output
-};
-//# sourceMappingURL=standards-sdk.es124.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"standards-sdk.es124.js","sources":["../../node_modules/@noble/hashes/esm/_assert.js"],"sourcesContent":["function number(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error(`Wrong positive integer: ${n}`);\n}\nfunction bool(b) {\n    if (typeof b !== 'boolean')\n        throw new Error(`Expected boolean, not ${b}`);\n}\nfunction bytes(b, ...lengths) {\n    if (!(b instanceof Uint8Array))\n        throw new Error('Expected Uint8Array');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);\n}\nfunction hash(hash) {\n    if (typeof hash !== 'function' || typeof hash.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.wrapConstructor');\n    number(hash.outputLen);\n    number(hash.blockLen);\n}\nfunction exists(instance, checkFinished = true) {\n    if (instance.destroyed)\n        throw new Error('Hash instance has been destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('Hash#digest() has already been called');\n}\nfunction output(out, instance) {\n    bytes(out);\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error(`digestInto() expects output buffer of length at least ${min}`);\n    }\n}\nexport { number, bool, bytes, hash, exists, output };\nconst assert = { number, bool, bytes, hash, exists, output };\nexport default assert;\n//# sourceMappingURL=_assert.js.map"],"names":[],"mappings":"AAAA,SAAS,OAAO,GAAG;AACf,MAAI,CAAC,OAAO,cAAc,CAAC,KAAK,IAAI;AAChC,UAAM,IAAI,MAAM,2BAA2B,CAAC,EAAE;AACtD;AAKA,SAAS,MAAM,MAAM,SAAS;AAC1B,MAAI,EAAE,aAAa;AACf,UAAM,IAAI,MAAM,qBAAqB;AACzC,MAAI,QAAQ,SAAS,KAAK,CAAC,QAAQ,SAAS,EAAE,MAAM;AAChD,UAAM,IAAI,MAAM,iCAAiC,OAAO,mBAAmB,EAAE,MAAM,EAAE;AAC7F;AAOA,SAAS,OAAO,UAAU,gBAAgB,MAAM;AAC5C,MAAI,SAAS;AACT,UAAM,IAAI,MAAM,kCAAkC;AACtD,MAAI,iBAAiB,SAAS;AAC1B,UAAM,IAAI,MAAM,uCAAuC;AAC/D;AACA,SAAS,OAAO,KAAK,UAAU;AAC3B,QAAM,GAAG;AACT,QAAM,MAAM,SAAS;AACrB,MAAI,IAAI,SAAS,KAAK;AAClB,UAAM,IAAI,MAAM,yDAAyD,GAAG,EAAE;AAAA,EACtF;AACA;","x_google_ignoreList":[0]}