@inco/js 0.1.22 → 0.1.23

package/dist/local/index.cjs

@@ -41,6 +41,792 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// ../node_modules/viem/_esm/utils/data/isHex.js
+function isHex(value6, { strict: strict2 = true } = {}) {
+  if (!value6)
+    return false;
+  if (typeof value6 !== "string")
+    return false;
+  return strict2 ? /^0x[0-9a-fA-F]*$/.test(value6) : value6.startsWith("0x");
+}
+
+// ../node_modules/viem/_esm/utils/data/size.js
+function size21(value6) {
+  if (isHex(value6, { strict: false }))
+    return Math.ceil((value6.length - 2) / 2);
+  return value6.length;
+}
+var init_size = () => {};
+
+// ../node_modules/viem/_esm/errors/version.js
+var version = "2.24.3";
+
+// ../node_modules/viem/_esm/errors/base.js
+function walk(err, fn) {
+  if (fn?.(err))
+    return err;
+  if (err && typeof err === "object" && "cause" in err && err.cause !== undefined)
+    return walk(err.cause, fn);
+  return fn ? null : err;
+}
+var errorConfig, BaseError;
+var init_base = __esm(() => {
+  errorConfig = {
+    getDocsUrl: ({ docsBaseUrl, docsPath = "", docsSlug }) => docsPath ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath}${docsSlug ? `#${docsSlug}` : ""}` : undefined,
+    version: `viem@${version}`
+  };
+  BaseError = class BaseError extends Error {
+    constructor(shortMessage, args2 = {}) {
+      const details = (() => {
+        if (args2.cause instanceof BaseError)
+          return args2.cause.details;
+        if (args2.cause?.message)
+          return args2.cause.message;
+        return args2.details;
+      })();
+      const docsPath = (() => {
+        if (args2.cause instanceof BaseError)
+          return args2.cause.docsPath || args2.docsPath;
+        return args2.docsPath;
+      })();
+      const docsUrl = errorConfig.getDocsUrl?.({ ...args2, docsPath });
+      const message = [
+        shortMessage || "An error occurred.",
+        "",
+        ...args2.metaMessages ? [...args2.metaMessages, ""] : [],
+        ...docsUrl ? [`Docs: ${docsUrl}`] : [],
+        ...details ? [`Details: ${details}`] : [],
+        ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
+      ].join(`
+`);
+      super(message, args2.cause ? { cause: args2.cause } : undefined);
+      Object.defineProperty(this, "details", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "docsPath", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "metaMessages", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "shortMessage", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "version", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      Object.defineProperty(this, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "BaseError"
+      });
+      this.details = details;
+      this.docsPath = docsPath;
+      this.metaMessages = args2.metaMessages;
+      this.name = args2.name ?? this.name;
+      this.shortMessage = shortMessage;
+      this.version = version;
+    }
+    walk(fn) {
+      return walk(this, fn);
+    }
+  };
+});
+
+// ../node_modules/viem/_esm/errors/abi.js
+var AbiEncodingLengthMismatchError, BytesSizeMismatchError, UnsupportedPackedAbiType;
+var init_abi = __esm(() => {
+  init_base();
+  AbiEncodingLengthMismatchError = class AbiEncodingLengthMismatchError extends BaseError {
+    constructor({ expectedLength, givenLength }) {
+      super([
+        "ABI encoding params/values length mismatch.",
+        `Expected length (params): ${expectedLength}`,
+        `Given length (values): ${givenLength}`
+      ].join(`
+`), { name: "AbiEncodingLengthMismatchError" });
+    }
+  };
+  BytesSizeMismatchError = class BytesSizeMismatchError extends BaseError {
+    constructor({ expectedSize, givenSize }) {
+      super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
+        name: "BytesSizeMismatchError"
+      });
+    }
+  };
+  UnsupportedPackedAbiType = class UnsupportedPackedAbiType extends BaseError {
+    constructor(type2) {
+      super(`Type "${type2}" is not supported for packed encoding.`, {
+        name: "UnsupportedPackedAbiType"
+      });
+    }
+  };
+});
+
+// ../node_modules/viem/_esm/errors/data.js
+var SizeExceedsPaddingSizeError;
+var init_data = __esm(() => {
+  init_base();
+  SizeExceedsPaddingSizeError = class SizeExceedsPaddingSizeError extends BaseError {
+    constructor({ size: size22, targetSize, type: type2 }) {
+      super(`${type2.charAt(0).toUpperCase()}${type2.slice(1).toLowerCase()} size (${size22}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
+    }
+  };
+});
+
+// ../node_modules/viem/_esm/utils/data/pad.js
+function pad(hexOrBytes, { dir: dir2, size: size22 = 32 } = {}) {
+  if (typeof hexOrBytes === "string")
+    return padHex(hexOrBytes, { dir: dir2, size: size22 });
+  return padBytes(hexOrBytes, { dir: dir2, size: size22 });
+}
+function padHex(hex_, { dir: dir2, size: size22 = 32 } = {}) {
+  if (size22 === null)
+    return hex_;
+  const hex = hex_.replace("0x", "");
+  if (hex.length > size22 * 2)
+    throw new SizeExceedsPaddingSizeError({
+      size: Math.ceil(hex.length / 2),
+      targetSize: size22,
+      type: "hex"
+    });
+  return `0x${hex[dir2 === "right" ? "padEnd" : "padStart"](size22 * 2, "0")}`;
+}
+function padBytes(bytes, { dir: dir2, size: size22 = 32 } = {}) {
+  if (size22 === null)
+    return bytes;
+  if (bytes.length > size22)
+    throw new SizeExceedsPaddingSizeError({
+      size: bytes.length,
+      targetSize: size22,
+      type: "bytes"
+    });
+  const paddedBytes = new Uint8Array(size22);
+  for (let i = 0;i < size22; i++) {
+    const padEnd = dir2 === "right";
+    paddedBytes[padEnd ? i : size22 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
+  }
+  return paddedBytes;
+}
+var init_pad = __esm(() => {
+  init_data();
+});
+
+// ../node_modules/viem/_esm/errors/encoding.js
+var IntegerOutOfRangeError, SizeOverflowError;
+var init_encoding = __esm(() => {
+  init_base();
+  IntegerOutOfRangeError = class IntegerOutOfRangeError extends BaseError {
+    constructor({ max: max6, min: min4, signed, size: size22, value: value6 }) {
+      super(`Number "${value6}" is not in safe ${size22 ? `${size22 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max6 ? `(${min4} to ${max6})` : `(above ${min4})`}`, { name: "IntegerOutOfRangeError" });
+    }
+  };
+  SizeOverflowError = class SizeOverflowError extends BaseError {
+    constructor({ givenSize, maxSize }) {
+      super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
+    }
+  };
+});
+
+// ../node_modules/viem/_esm/utils/encoding/fromHex.js
+function assertSize(hexOrBytes, { size: size22 }) {
+  if (size21(hexOrBytes) > size22)
+    throw new SizeOverflowError({
+      givenSize: size21(hexOrBytes),
+      maxSize: size22
+    });
+}
+var init_fromHex = __esm(() => {
+  init_encoding();
+  init_size();
+});
+
+// ../node_modules/viem/_esm/utils/encoding/toHex.js
+function toHex(value6, opts = {}) {
+  if (typeof value6 === "number" || typeof value6 === "bigint")
+    return numberToHex(value6, opts);
+  if (typeof value6 === "string") {
+    return stringToHex(value6, opts);
+  }
+  if (typeof value6 === "boolean")
+    return boolToHex(value6, opts);
+  return bytesToHex2(value6, opts);
+}
+function boolToHex(value6, opts = {}) {
+  const hex = `0x${Number(value6)}`;
+  if (typeof opts.size === "number") {
+    assertSize(hex, { size: opts.size });
+    return pad(hex, { size: opts.size });
+  }
+  return hex;
+}
+function bytesToHex2(value6, opts = {}) {
+  let string6 = "";
+  for (let i = 0;i < value6.length; i++) {
+    string6 += hexes[value6[i]];
+  }
+  const hex = `0x${string6}`;
+  if (typeof opts.size === "number") {
+    assertSize(hex, { size: opts.size });
+    return pad(hex, { dir: "right", size: opts.size });
+  }
+  return hex;
+}
+function numberToHex(value_, opts = {}) {
+  const { signed, size: size22 } = opts;
+  const value6 = BigInt(value_);
+  let maxValue;
+  if (size22) {
+    if (signed)
+      maxValue = (1n << BigInt(size22) * 8n - 1n) - 1n;
+    else
+      maxValue = 2n ** (BigInt(size22) * 8n) - 1n;
+  } else if (typeof value_ === "number") {
+    maxValue = BigInt(Number.MAX_SAFE_INTEGER);
+  }
+  const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
+  if (maxValue && value6 > maxValue || value6 < minValue) {
+    const suffix = typeof value_ === "bigint" ? "n" : "";
+    throw new IntegerOutOfRangeError({
+      max: maxValue ? `${maxValue}${suffix}` : undefined,
+      min: `${minValue}${suffix}`,
+      signed,
+      size: size22,
+      value: `${value_}${suffix}`
+    });
+  }
+  const hex = `0x${(signed && value6 < 0 ? (1n << BigInt(size22 * 8)) + BigInt(value6) : value6).toString(16)}`;
+  if (size22)
+    return pad(hex, { size: size22 });
+  return hex;
+}
+function stringToHex(value_, opts = {}) {
+  const value6 = encoder2.encode(value_);
+  return bytesToHex2(value6, opts);
+}
+var hexes, encoder2;
+var init_toHex = __esm(() => {
+  init_encoding();
+  init_pad();
+  init_fromHex();
+  hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
+  encoder2 = /* @__PURE__ */ new TextEncoder;
+});
+
+// ../node_modules/viem/_esm/utils/encoding/toBytes.js
+function toBytes(value6, opts = {}) {
+  if (typeof value6 === "number" || typeof value6 === "bigint")
+    return numberToBytes(value6, opts);
+  if (typeof value6 === "boolean")
+    return boolToBytes(value6, opts);
+  if (isHex(value6))
+    return hexToBytes(value6, opts);
+  return stringToBytes(value6, opts);
+}
+function boolToBytes(value6, opts = {}) {
+  const bytes = new Uint8Array(1);
+  bytes[0] = Number(value6);
+  if (typeof opts.size === "number") {
+    assertSize(bytes, { size: opts.size });
+    return pad(bytes, { size: opts.size });
+  }
+  return bytes;
+}
+function charCodeToBase16(char) {
+  if (char >= charCodeMap.zero && char <= charCodeMap.nine)
+    return char - charCodeMap.zero;
+  if (char >= charCodeMap.A && char <= charCodeMap.F)
+    return char - (charCodeMap.A - 10);
+  if (char >= charCodeMap.a && char <= charCodeMap.f)
+    return char - (charCodeMap.a - 10);
+  return;
+}
+function hexToBytes(hex_, opts = {}) {
+  let hex = hex_;
+  if (opts.size) {
+    assertSize(hex, { size: opts.size });
+    hex = pad(hex, { dir: "right", size: opts.size });
+  }
+  let hexString = hex.slice(2);
+  if (hexString.length % 2)
+    hexString = `0${hexString}`;
+  const length4 = hexString.length / 2;
+  const bytes = new Uint8Array(length4);
+  for (let index = 0, j = 0;index < length4; index++) {
+    const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
+    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
+    if (nibbleLeft === undefined || nibbleRight === undefined) {
+      throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+    }
+    bytes[index] = nibbleLeft * 16 + nibbleRight;
+  }
+  return bytes;
+}
+function numberToBytes(value6, opts) {
+  const hex = numberToHex(value6, opts);
+  return hexToBytes(hex);
+}
+function stringToBytes(value6, opts = {}) {
+  const bytes = encoder3.encode(value6);
+  if (typeof opts.size === "number") {
+    assertSize(bytes, { size: opts.size });
+    return pad(bytes, { dir: "right", size: opts.size });
+  }
+  return bytes;
+}
+var encoder3, charCodeMap;
+var init_toBytes = __esm(() => {
+  init_base();
+  init_pad();
+  init_fromHex();
+  init_toHex();
+  encoder3 = /* @__PURE__ */ new TextEncoder;
+  charCodeMap = {
+    zero: 48,
+    nine: 57,
+    A: 65,
+    F: 70,
+    a: 97,
+    f: 102
+  };
+});
+
+// ../node_modules/@noble/hashes/esm/_assert.js
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function aexists(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 aoutput(out, instance) {
+  abytes(out);
+  const min4 = instance.outputLen;
+  if (out.length < min4) {
+    throw new Error("digestInto() expects output buffer of length at least " + min4);
+  }
+}
+var init__assert = () => {};
+
+// ../node_modules/@noble/hashes/esm/_u64.js
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split3(lst, le = false) {
+  let Ah = new Uint32Array(lst.length);
+  let Al = new Uint32Array(lst.length);
+  for (let i = 0;i < lst.length; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+var U32_MASK64, _32n, rotlSH = (h, l, s) => h << s | l >>> 32 - s, rotlSL = (h, l, s) => l << s | h >>> 32 - s, rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s, rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+var init__u64 = __esm(() => {
+  U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+  _32n = /* @__PURE__ */ BigInt(32);
+});
+
+// ../node_modules/@noble/hashes/esm/utils.js
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+function byteSwap32(arr) {
+  for (let i = 0;i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
+  }
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("utf8ToBytes expected string, got " + typeof str);
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes2(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+
+class Hash {
+  clone() {
+    return this._cloneInto();
+  }
+}
+function wrapConstructor(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+function wrapXOFConstructorWithOpts(hashCons) {
+  const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
+  const tmp = hashCons({});
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  return hashC;
+}
+var isLE;
+var init_utils = __esm(() => {
+  init__assert();
+  /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+  isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+});
+
+// ../node_modules/@noble/hashes/esm/sha3.js
+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 shift2 = SHA3_ROTL[t];
+      const Th = rotlH(curH, curL, shift2);
+      const Tl = rotlL(curH, curL, shift2);
+      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);
+}
+var SHA3_PI, SHA3_ROTL, _SHA3_IOTA, _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_IOTA_H, SHA3_IOTA_L, rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s), rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s), Keccak, gen5 = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen)), sha3_224, sha3_256, sha3_384, sha3_512, keccak_224, keccak_256, keccak_384, keccak_512, genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true)), shake128, shake256;
+var init_sha3 = __esm(() => {
+  init__assert();
+  init__u64();
+  init_utils();
+  SHA3_PI = [];
+  SHA3_ROTL = [];
+  _SHA3_IOTA = [];
+  _0n = /* @__PURE__ */ BigInt(0);
+  _1n = /* @__PURE__ */ BigInt(1);
+  _2n = /* @__PURE__ */ BigInt(2);
+  _7n = /* @__PURE__ */ BigInt(7);
+  _256n = /* @__PURE__ */ BigInt(256);
+  _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);
+  }
+  [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split3(_SHA3_IOTA, true);
+  Keccak = class Keccak extends Hash {
+    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;
+      anumber(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() {
+      if (!isLE)
+        byteSwap32(this.state32);
+      keccakP(this.state32, this.rounds);
+      if (!isLE)
+        byteSwap32(this.state32);
+      this.posOut = 0;
+      this.pos = 0;
+    }
+    update(data) {
+      aexists(this);
+      const { blockLen, state } = this;
+      data = toBytes2(data);
+      const len = data.length;
+      for (let pos = 0;pos < len; ) {
+        const take10 = Math.min(blockLen - this.pos, len - pos);
+        for (let i = 0;i < take10; 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) {
+      aexists(this, false);
+      abytes(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 take10 = Math.min(blockLen - this.posOut, len - pos);
+        out.set(bufferOut.subarray(this.posOut, this.posOut + take10), pos);
+        this.posOut += take10;
+        pos += take10;
+      }
+      return out;
+    }
+    xofInto(out) {
+      if (!this.enableXOF)
+        throw new Error("XOF is not possible for this instance");
+      return this.writeInto(out);
+    }
+    xof(bytes) {
+      anumber(bytes);
+      return this.xofInto(new Uint8Array(bytes));
+    }
+    digestInto(out) {
+      aoutput(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;
+    }
+  };
+  sha3_224 = /* @__PURE__ */ gen5(6, 144, 224 / 8);
+  sha3_256 = /* @__PURE__ */ gen5(6, 136, 256 / 8);
+  sha3_384 = /* @__PURE__ */ gen5(6, 104, 384 / 8);
+  sha3_512 = /* @__PURE__ */ gen5(6, 72, 512 / 8);
+  keccak_224 = /* @__PURE__ */ gen5(1, 144, 224 / 8);
+  keccak_256 = /* @__PURE__ */ gen5(1, 136, 256 / 8);
+  keccak_384 = /* @__PURE__ */ gen5(1, 104, 384 / 8);
+  keccak_512 = /* @__PURE__ */ gen5(1, 72, 512 / 8);
+  shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
+  shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
+});
+
+// ../node_modules/viem/_esm/utils/hash/keccak256.js
+function keccak256(value6, to_) {
+  const to = to_ || "hex";
+  const bytes = keccak_256(isHex(value6, { strict: false }) ? toBytes(value6) : value6);
+  if (to === "bytes")
+    return bytes;
+  return toHex(bytes);
+}
+var init_keccak256 = __esm(() => {
+  init_sha3();
+  init_toBytes();
+  init_toHex();
+});
+
+// ../node_modules/viem/_esm/errors/address.js
+var InvalidAddressError;
+var init_address = __esm(() => {
+  init_base();
+  InvalidAddressError = class InvalidAddressError extends BaseError {
+    constructor({ address }) {
+      super(`Address "${address}" is invalid.`, {
+        metaMessages: [
+          "- Address must be a hex value of 20 bytes (40 hex characters).",
+          "- Address must match its checksum counterpart."
+        ],
+        name: "InvalidAddressError"
+      });
+    }
+  };
+});
+
+// ../node_modules/viem/_esm/utils/lru.js
+var LruMap;
+var init_lru = __esm(() => {
+  LruMap = class LruMap extends Map {
+    constructor(size22) {
+      super();
+      Object.defineProperty(this, "maxSize", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: undefined
+      });
+      this.maxSize = size22;
+    }
+    get(key) {
+      const value6 = super.get(key);
+      if (super.has(key) && value6 !== undefined) {
+        this.delete(key);
+        super.set(key, value6);
+      }
+      return value6;
+    }
+    set(key, value6) {
+      super.set(key, value6);
+      if (this.maxSize && this.size > this.maxSize) {
+        const firstKey = this.keys().next().value;
+        if (firstKey)
+          this.delete(firstKey);
+      }
+      return this;
+    }
+  };
+});
+
+// ../node_modules/viem/_esm/utils/address/getAddress.js
+function checksumAddress(address_, chainId) {
+  if (checksumAddressCache.has(`${address_}.${chainId}`))
+    return checksumAddressCache.get(`${address_}.${chainId}`);
+  const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
+  const hash2 = keccak256(stringToBytes(hexAddress), "bytes");
+  const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
+  for (let i = 0;i < 40; i += 2) {
+    if (hash2[i >> 1] >> 4 >= 8 && address[i]) {
+      address[i] = address[i].toUpperCase();
+    }
+    if ((hash2[i >> 1] & 15) >= 8 && address[i + 1]) {
+      address[i + 1] = address[i + 1].toUpperCase();
+    }
+  }
+  const result = `0x${address.join("")}`;
+  checksumAddressCache.set(`${address_}.${chainId}`, result);
+  return result;
+}
+var checksumAddressCache;
+var init_getAddress = __esm(() => {
+  init_toBytes();
+  init_keccak256();
+  init_lru();
+  checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
+});
+
+// ../node_modules/viem/_esm/utils/address/isAddress.js
+function isAddress(address, options) {
+  const { strict: strict2 = true } = options ?? {};
+  const cacheKey = `${address}.${strict2}`;
+  if (isAddressCache.has(cacheKey))
+    return isAddressCache.get(cacheKey);
+  const result = (() => {
+    if (!addressRegex.test(address))
+      return false;
+    if (address.toLowerCase() === address)
+      return true;
+    if (strict2)
+      return checksumAddress(address) === address;
+    return true;
+  })();
+  isAddressCache.set(cacheKey, result);
+  return result;
+}
+var addressRegex, isAddressCache;
+var init_isAddress = __esm(() => {
+  init_lru();
+  init_getAddress();
+  addressRegex = /^0x[a-fA-F0-9]{40}$/;
+  isAddressCache = /* @__PURE__ */ new LruMap(8192);
+});
+
+// ../node_modules/viem/_esm/utils/data/concat.js
+function concatHex(values7) {
+  return `0x${values7.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
+}
+
+// ../node_modules/viem/_esm/utils/regex.js
+var arrayRegex, bytesRegex, integerRegex;
+var init_regex = __esm(() => {
+  arrayRegex = /^(.*)\[([0-9]*)\]$/;
+  bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
+  integerRegex = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
+});
+
 // ../node_modules/dotenv/package.json
 var require_package = __commonJS((exports2, module2) => {
   module2.exports = {
@@ -114,7 +900,7 @@ var require_main = __commonJS((exports2, module2) => {
   var os = require("os");
   var crypto = require("crypto");
   var packageJson = require_package();
-  var version = packageJson.version;
+  var version2 = packageJson.version;
   var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
   function parse3(src) {
     const obj = {};
@@ -163,10 +949,10 @@ var require_main = __commonJS((exports2, module2) => {
     return DotenvModule.parse(decrypted);
   }
   function _warn(message) {
-    console.log(`[dotenv@${version}][WARN] ${message}`);
+    console.log(`[dotenv@${version2}][WARN] ${message}`);
   }
   function _debug(message) {
-    console.log(`[dotenv@${version}][DEBUG] ${message}`);
+    console.log(`[dotenv@${version2}][DEBUG] ${message}`);
   }
   function _dotenvKey(options) {
     if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
@@ -700,8 +1486,7 @@ var tracingFunction = (name) => {
   };
 };
 var internalCall = /* @__PURE__ */ tracingFunction("effect_internal_function");
-var genConstructor = function* () {
-}.constructor;
+var genConstructor = function* () {}.constructor;
 
 // ../node_modules/effect/dist/esm/Hash.js
 var randomHashCache = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/randomHashCache"), () => new WeakMap);
@@ -1048,8 +1833,7 @@ var StructuralCommitPrototype = {
   ...StructuralPrototype
 };
 var Base = /* @__PURE__ */ function() {
-  function Base2() {
-  }
+  function Base2() {}
   Base2.prototype = CommitPrototype;
   return Base2;
 }();
@@ -4552,8 +5336,7 @@ var Reference = () => (id, options) => {
   Error.stackTraceLimit = 2;
   const creationError = new Error;
   Error.stackTraceLimit = limit;
-  function ReferenceClass() {
-  }
+  function ReferenceClass() {}
   Object.setPrototypeOf(ReferenceClass, ReferenceProto);
   ReferenceClass.key = id;
   ReferenceClass.defaultValue = options.defaultValue;
@@ -7493,8 +8276,7 @@ var prettyErrorMessage = (u) => {
     if (hasProperty(u, "toString") && isFunction2(u["toString"]) && u["toString"] !== Object.prototype.toString && u["toString"] !== globalThis.Array.prototype.toString) {
       return u["toString"]();
     }
-  } catch {
-  }
+  } catch {}
   return stringifyCircular(u);
 };
 var locationRegex = /\((.*)\)/g;
@@ -8068,8 +8850,7 @@ var zip2 = /* @__PURE__ */ dual(2, (self, that) => flatMap6(self, (a) => map9(th
 var zipLeft = /* @__PURE__ */ dual(2, (self, that) => flatMap6(self, (a) => as(that, a)));
 var zipRight = /* @__PURE__ */ dual(2, (self, that) => flatMap6(self, () => that));
 var never = /* @__PURE__ */ asyncInterrupt(() => {
-  const interval = setInterval(() => {
-  }, 2 ** 31 - 1);
+  const interval = setInterval(() => {}, 2 ** 31 - 1);
   return sync(() => clearInterval(interval));
 });
 var interruptFiber = (self) => flatMap6(fiberId, (fiberId2) => pipe(self, interruptAsFiber(fiberId2)));
@@ -11889,16 +12670,11 @@ class Const {
   get value() {
     return this.effect;
   }
-  onStart(_context, _effect, _parent, _fiber) {
-  }
-  onEnd(_value, _fiber) {
-  }
-  onEffect(_fiber, _effect) {
-  }
-  onSuspend(_fiber) {
-  }
-  onResume(_fiber) {
-  }
+  onStart(_context, _effect, _parent, _fiber) {}
+  onEnd(_value, _fiber) {}
+  onEffect(_fiber, _effect) {}
+  onSuspend(_fiber) {}
+  onResume(_fiber) {}
   map(f) {
     return new ProxySupervisor(this, pipe(this.value, map9(f)));
   }
@@ -12372,8 +13148,7 @@ class FiberRuntime extends Class {
       return whileLoop({
         while: () => !isDone3,
         body,
-        step: () => {
-        }
+        step: () => {}
       });
     }
     return null;
@@ -21903,6 +22678,78 @@ class TrieIterator {
   }
 }
 var isTrie = (u) => hasProperty(u, TrieTypeId);
+// ../node_modules/viem/_esm/utils/abi/encodePacked.js
+init_abi();
+init_address();
+init_isAddress();
+init_pad();
+init_toHex();
+init_regex();
+function encodePacked(types, values7) {
+  if (types.length !== values7.length)
+    throw new AbiEncodingLengthMismatchError({
+      expectedLength: types.length,
+      givenLength: values7.length
+    });
+  const data = [];
+  for (let i = 0;i < types.length; i++) {
+    const type2 = types[i];
+    const value6 = values7[i];
+    data.push(encode6(type2, value6));
+  }
+  return concatHex(data);
+}
+function encode6(type2, value6, isArray2 = false) {
+  if (type2 === "address") {
+    const address = value6;
+    if (!isAddress(address))
+      throw new InvalidAddressError({ address });
+    return pad(address.toLowerCase(), {
+      size: isArray2 ? 32 : null
+    });
+  }
+  if (type2 === "string")
+    return stringToHex(value6);
+  if (type2 === "bytes")
+    return value6;
+  if (type2 === "bool")
+    return pad(boolToHex(value6), { size: isArray2 ? 32 : 1 });
+  const intMatch = type2.match(integerRegex);
+  if (intMatch) {
+    const [_type, baseType, bits = "256"] = intMatch;
+    const size22 = Number.parseInt(bits) / 8;
+    return numberToHex(value6, {
+      size: isArray2 ? 32 : size22,
+      signed: baseType === "int"
+    });
+  }
+  const bytesMatch = type2.match(bytesRegex);
+  if (bytesMatch) {
+    const [_type, size22] = bytesMatch;
+    if (Number.parseInt(size22) !== (value6.length - 2) / 2)
+      throw new BytesSizeMismatchError({
+        expectedSize: Number.parseInt(size22),
+        givenSize: (value6.length - 2) / 2
+      });
+    return pad(value6, { dir: "right", size: isArray2 ? 32 : null });
+  }
+  const arrayMatch = type2.match(arrayRegex);
+  if (arrayMatch && Array.isArray(value6)) {
+    const [_type, childType] = arrayMatch;
+    const data = [];
+    for (let i = 0;i < value6.length; i++) {
+      data.push(encode6(childType, value6[i], true));
+    }
+    if (data.length === 0)
+      return "0x";
+    return concatHex(data);
+  }
+  throw new UnsupportedPackedAbiType(type2);
+}
+
+// ../node_modules/viem/_esm/index.js
+init_toBytes();
+init_toHex();
 // ../contracts/pega/lib/hex.ts
 var HexString = exports_Schema.TemplateLiteral("0x", exports_Schema.String);
 var Address = HexString.pipe(exports_Schema.filter((s) => s.length === 42 || `Address must be a 20-byte '0x'-prefixed hex string, but got: ${s}`), exports_Schema.brand("Address"));