@elizaos/plugin-elizacloud 2.0.0-beta.1 → 2.0.11-beta.7

package/dist/cloud/cloud-wallet.js

@@ -201,4840 +201,8 @@ function isCloudWalletEnabled() {
   return readBoolFlag("ENABLE_CLOUD_WALLET");
 }
 
-// ../../node_modules/.bun/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/cryptoNode.js
-import * as nc from "node:crypto";
-var crypto;
-var init_cryptoNode = __esm(() => {
-  crypto = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && ("randomBytes" in nc) ? nc : undefined;
-});
-
-// ../../node_modules/.bun/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js
-function isBytes(a) {
-  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-}
-function anumber(n) {
-  if (!Number.isSafeInteger(n) || n < 0)
-    throw new Error("positive integer expected, got " + n);
-}
-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 ahash(h) {
-  if (typeof h !== "function" || typeof h.create !== "function")
-    throw new Error("Hash should be wrapped by utils.createHasher");
-  anumber(h.outputLen);
-  anumber(h.blockLen);
-}
-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 min = instance.outputLen;
-  if (out.length < min) {
-    throw new Error("digestInto() expects output buffer of length at least " + min);
-  }
-}
-function u32(arr) {
-  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-}
-function clean(...arrays) {
-  for (let i = 0;i < arrays.length; i++) {
-    arrays[i].fill(0);
-  }
-}
-function createView(arr) {
-  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-function rotr(word, shift) {
-  return word << 32 - shift | word >>> shift;
-}
-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]);
-  }
-  return arr;
-}
-function utf8ToBytes(str) {
-  if (typeof str !== "string")
-    throw new Error("string expected");
-  return new Uint8Array(new TextEncoder().encode(str));
-}
-function toBytes(data) {
-  if (typeof data === "string")
-    data = utf8ToBytes(data);
-  abytes(data);
-  return data;
-}
-function concatBytes(...arrays) {
-  let sum = 0;
-  for (let i = 0;i < arrays.length; i++) {
-    const a = arrays[i];
-    abytes(a);
-    sum += a.length;
-  }
-  const res = new Uint8Array(sum);
-  for (let i = 0, pad = 0;i < arrays.length; i++) {
-    const a = arrays[i];
-    res.set(a, pad);
-    pad += a.length;
-  }
-  return res;
-}
-
-class Hash {
-}
-function createHasher(hashCons) {
-  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
-  const tmp = hashCons();
-  hashC.outputLen = tmp.outputLen;
-  hashC.blockLen = tmp.blockLen;
-  hashC.create = () => hashCons();
-  return hashC;
-}
-function randomBytes(bytesLength = 32) {
-  if (crypto && typeof crypto.getRandomValues === "function") {
-    return crypto.getRandomValues(new Uint8Array(bytesLength));
-  }
-  if (crypto && typeof crypto.randomBytes === "function") {
-    return Uint8Array.from(crypto.randomBytes(bytesLength));
-  }
-  throw new Error("crypto.getRandomValues must be defined");
-}
-var isLE, swap32IfBE;
-var init_utils = __esm(() => {
-  init_cryptoNode();
-  /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
-  swap32IfBE = isLE ? (u) => u : byteSwap32;
-});
-
-// ../../node_modules/.bun/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_md.js
-function setBigUint64(view, byteOffset, value, isLE2) {
-  if (typeof view.setBigUint64 === "function")
-    return view.setBigUint64(byteOffset, value, isLE2);
-  const _32n = BigInt(32);
-  const _u32_max = BigInt(4294967295);
-  const wh = Number(value >> _32n & _u32_max);
-  const wl = Number(value & _u32_max);
-  const h = isLE2 ? 4 : 0;
-  const l = isLE2 ? 0 : 4;
-  view.setUint32(byteOffset + h, wh, isLE2);
-  view.setUint32(byteOffset + l, wl, isLE2);
-}
-function Chi(a, b, c) {
-  return a & b ^ ~a & c;
-}
-function Maj(a, b, c) {
-  return a & b ^ a & c ^ b & c;
-}
-var HashMD, SHA256_IV;
-var init__md = __esm(() => {
-  init_utils();
-  HashMD = class HashMD extends Hash {
-    constructor(blockLen, outputLen, padOffset, isLE2) {
-      super();
-      this.finished = false;
-      this.length = 0;
-      this.pos = 0;
-      this.destroyed = false;
-      this.blockLen = blockLen;
-      this.outputLen = outputLen;
-      this.padOffset = padOffset;
-      this.isLE = isLE2;
-      this.buffer = new Uint8Array(blockLen);
-      this.view = createView(this.buffer);
-    }
-    update(data) {
-      aexists(this);
-      data = toBytes(data);
-      abytes(data);
-      const { view, buffer, blockLen } = this;
-      const len = data.length;
-      for (let pos = 0;pos < len; ) {
-        const take = Math.min(blockLen - this.pos, len - pos);
-        if (take === blockLen) {
-          const dataView = createView(data);
-          for (;blockLen <= len - pos; pos += blockLen)
-            this.process(dataView, pos);
-          continue;
-        }
-        buffer.set(data.subarray(pos, pos + take), this.pos);
-        this.pos += take;
-        pos += take;
-        if (this.pos === blockLen) {
-          this.process(view, 0);
-          this.pos = 0;
-        }
-      }
-      this.length += data.length;
-      this.roundClean();
-      return this;
-    }
-    digestInto(out) {
-      aexists(this);
-      aoutput(out, this);
-      this.finished = true;
-      const { buffer, view, blockLen, isLE: isLE2 } = this;
-      let { pos } = this;
-      buffer[pos++] = 128;
-      clean(this.buffer.subarray(pos));
-      if (this.padOffset > blockLen - pos) {
-        this.process(view, 0);
-        pos = 0;
-      }
-      for (let i = pos;i < blockLen; i++)
-        buffer[i] = 0;
-      setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
-      this.process(view, 0);
-      const oview = createView(out);
-      const len = this.outputLen;
-      if (len % 4)
-        throw new Error("_sha2: outputLen should be aligned to 32bit");
-      const outLen = len / 4;
-      const state = this.get();
-      if (outLen > state.length)
-        throw new Error("_sha2: outputLen bigger than state");
-      for (let i = 0;i < outLen; i++)
-        oview.setUint32(4 * i, state[i], isLE2);
-    }
-    digest() {
-      const { buffer, outputLen } = this;
-      this.digestInto(buffer);
-      const res = buffer.slice(0, outputLen);
-      this.destroy();
-      return res;
-    }
-    _cloneInto(to) {
-      to || (to = new this.constructor);
-      to.set(...this.get());
-      const { blockLen, buffer, length, finished, destroyed, pos } = this;
-      to.destroyed = destroyed;
-      to.finished = finished;
-      to.length = length;
-      to.pos = pos;
-      if (length % blockLen)
-        to.buffer.set(buffer);
-      return to;
-    }
-    clone() {
-      return this._cloneInto();
-    }
-  };
-  SHA256_IV = /* @__PURE__ */ Uint32Array.from([
-    1779033703,
-    3144134277,
-    1013904242,
-    2773480762,
-    1359893119,
-    2600822924,
-    528734635,
-    1541459225
-  ]);
-});
-
-// ../../node_modules/.bun/@noble+hashes@1.8.0/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 split(lst, le = false) {
-  const len = lst.length;
-  let Ah = new Uint32Array(len);
-  let Al = new Uint32Array(len);
-  for (let i = 0;i < len; 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/.bun/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha2.js
-var SHA256_K, SHA256_W, SHA256, sha256;
-var init_sha2 = __esm(() => {
-  init__md();
-  init_utils();
-  SHA256_K = /* @__PURE__ */ Uint32Array.from([
-    1116352408,
-    1899447441,
-    3049323471,
-    3921009573,
-    961987163,
-    1508970993,
-    2453635748,
-    2870763221,
-    3624381080,
-    310598401,
-    607225278,
-    1426881987,
-    1925078388,
-    2162078206,
-    2614888103,
-    3248222580,
-    3835390401,
-    4022224774,
-    264347078,
-    604807628,
-    770255983,
-    1249150122,
-    1555081692,
-    1996064986,
-    2554220882,
-    2821834349,
-    2952996808,
-    3210313671,
-    3336571891,
-    3584528711,
-    113926993,
-    338241895,
-    666307205,
-    773529912,
-    1294757372,
-    1396182291,
-    1695183700,
-    1986661051,
-    2177026350,
-    2456956037,
-    2730485921,
-    2820302411,
-    3259730800,
-    3345764771,
-    3516065817,
-    3600352804,
-    4094571909,
-    275423344,
-    430227734,
-    506948616,
-    659060556,
-    883997877,
-    958139571,
-    1322822218,
-    1537002063,
-    1747873779,
-    1955562222,
-    2024104815,
-    2227730452,
-    2361852424,
-    2428436474,
-    2756734187,
-    3204031479,
-    3329325298
-  ]);
-  SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-  SHA256 = class SHA256 extends HashMD {
-    constructor(outputLen = 32) {
-      super(64, outputLen, 8, false);
-      this.A = SHA256_IV[0] | 0;
-      this.B = SHA256_IV[1] | 0;
-      this.C = SHA256_IV[2] | 0;
-      this.D = SHA256_IV[3] | 0;
-      this.E = SHA256_IV[4] | 0;
-      this.F = SHA256_IV[5] | 0;
-      this.G = SHA256_IV[6] | 0;
-      this.H = SHA256_IV[7] | 0;
-    }
-    get() {
-      const { A, B, C, D, E, F, G, H } = this;
-      return [A, B, C, D, E, F, G, H];
-    }
-    set(A, B, C, D, E, F, G, H) {
-      this.A = A | 0;
-      this.B = B | 0;
-      this.C = C | 0;
-      this.D = D | 0;
-      this.E = E | 0;
-      this.F = F | 0;
-      this.G = G | 0;
-      this.H = H | 0;
-    }
-    process(view, offset) {
-      for (let i = 0;i < 16; i++, offset += 4)
-        SHA256_W[i] = view.getUint32(offset, false);
-      for (let i = 16;i < 64; i++) {
-        const W15 = SHA256_W[i - 15];
-        const W2 = SHA256_W[i - 2];
-        const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
-        const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
-        SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
-      }
-      let { A, B, C, D, E, F, G, H } = this;
-      for (let i = 0;i < 64; i++) {
-        const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
-        const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
-        const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
-        const T2 = sigma0 + Maj(A, B, C) | 0;
-        H = G;
-        G = F;
-        F = E;
-        E = D + T1 | 0;
-        D = C;
-        C = B;
-        B = A;
-        A = T1 + T2 | 0;
-      }
-      A = A + this.A | 0;
-      B = B + this.B | 0;
-      C = C + this.C | 0;
-      D = D + this.D | 0;
-      E = E + this.E | 0;
-      F = F + this.F | 0;
-      G = G + this.G | 0;
-      H = H + this.H | 0;
-      this.set(A, B, C, D, E, F, G, H);
-    }
-    roundClean() {
-      clean(SHA256_W);
-    }
-    destroy() {
-      this.set(0, 0, 0, 0, 0, 0, 0, 0);
-      clean(this.buffer);
-    }
-  };
-  sha256 = /* @__PURE__ */ createHasher(() => new SHA256);
-});
-
-// ../../node_modules/.bun/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/hmac.js
-var HMAC, hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
-var init_hmac = __esm(() => {
-  init_utils();
-  HMAC = class HMAC extends Hash {
-    constructor(hash, _key) {
-      super();
-      this.finished = false;
-      this.destroyed = false;
-      ahash(hash);
-      const key = toBytes(_key);
-      this.iHash = hash.create();
-      if (typeof this.iHash.update !== "function")
-        throw new Error("Expected instance of class which extends utils.Hash");
-      this.blockLen = this.iHash.blockLen;
-      this.outputLen = this.iHash.outputLen;
-      const blockLen = this.blockLen;
-      const pad = new Uint8Array(blockLen);
-      pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
-      for (let i = 0;i < pad.length; i++)
-        pad[i] ^= 54;
-      this.iHash.update(pad);
-      this.oHash = hash.create();
-      for (let i = 0;i < pad.length; i++)
-        pad[i] ^= 54 ^ 92;
-      this.oHash.update(pad);
-      clean(pad);
-    }
-    update(buf) {
-      aexists(this);
-      this.iHash.update(buf);
-      return this;
-    }
-    digestInto(out) {
-      aexists(this);
-      abytes(out, this.outputLen);
-      this.finished = true;
-      this.iHash.digestInto(out);
-      this.oHash.update(out);
-      this.oHash.digestInto(out);
-      this.destroy();
-    }
-    digest() {
-      const out = new Uint8Array(this.oHash.outputLen);
-      this.digestInto(out);
-      return out;
-    }
-    _cloneInto(to) {
-      to || (to = Object.create(Object.getPrototypeOf(this), {}));
-      const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
-      to = to;
-      to.finished = finished;
-      to.destroyed = destroyed;
-      to.blockLen = blockLen;
-      to.outputLen = outputLen;
-      to.oHash = oHash._cloneInto(to.oHash);
-      to.iHash = iHash._cloneInto(to.iHash);
-      return to;
-    }
-    clone() {
-      return this._cloneInto();
-    }
-    destroy() {
-      this.destroyed = true;
-      this.oHash.destroy();
-      this.iHash.destroy();
-    }
-  };
-  hmac.create = (hash, key) => new HMAC(hash, key);
-});
-
-// ../../node_modules/.bun/@noble+curves@1.9.1/node_modules/@noble/curves/esm/abstract/utils.js
-function isBytes2(a) {
-  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-}
-function abytes2(item) {
-  if (!isBytes2(item))
-    throw new Error("Uint8Array expected");
-}
-function abool(title, value) {
-  if (typeof value !== "boolean")
-    throw new Error(title + " boolean expected, got " + value);
-}
-function numberToHexUnpadded(num) {
-  const hex = num.toString(16);
-  return hex.length & 1 ? "0" + hex : hex;
-}
-function hexToNumber(hex) {
-  if (typeof hex !== "string")
-    throw new Error("hex string expected, got " + typeof hex);
-  return hex === "" ? _0n : BigInt("0x" + hex);
-}
-function bytesToHex(bytes) {
-  abytes2(bytes);
-  if (hasHexBuiltin)
-    return bytes.toHex();
-  let hex = "";
-  for (let i = 0;i < bytes.length; i++) {
-    hex += hexes[bytes[i]];
-  }
-  return hex;
-}
-function asciiToBase16(ch) {
-  if (ch >= asciis._0 && ch <= asciis._9)
-    return ch - asciis._0;
-  if (ch >= asciis.A && ch <= asciis.F)
-    return ch - (asciis.A - 10);
-  if (ch >= asciis.a && ch <= asciis.f)
-    return ch - (asciis.a - 10);
-  return;
-}
-function hexToBytes(hex) {
-  if (typeof hex !== "string")
-    throw new Error("hex string expected, got " + typeof hex);
-  if (hasHexBuiltin)
-    return Uint8Array.fromHex(hex);
-  const hl = hex.length;
-  const al = hl / 2;
-  if (hl % 2)
-    throw new Error("hex string expected, got unpadded hex of length " + hl);
-  const array = new Uint8Array(al);
-  for (let ai = 0, hi = 0;ai < al; ai++, hi += 2) {
-    const n1 = asciiToBase16(hex.charCodeAt(hi));
-    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
-    if (n1 === undefined || n2 === undefined) {
-      const char = hex[hi] + hex[hi + 1];
-      throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
-    }
-    array[ai] = n1 * 16 + n2;
-  }
-  return array;
-}
-function bytesToNumberBE(bytes) {
-  return hexToNumber(bytesToHex(bytes));
-}
-function bytesToNumberLE(bytes) {
-  abytes2(bytes);
-  return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
-}
-function numberToBytesBE(n, len) {
-  return hexToBytes(n.toString(16).padStart(len * 2, "0"));
-}
-function numberToBytesLE(n, len) {
-  return numberToBytesBE(n, len).reverse();
-}
-function ensureBytes(title, hex, expectedLength) {
-  let res;
-  if (typeof hex === "string") {
-    try {
-      res = hexToBytes(hex);
-    } catch (e) {
-      throw new Error(title + " must be hex string or Uint8Array, cause: " + e);
-    }
-  } else if (isBytes2(hex)) {
-    res = Uint8Array.from(hex);
-  } else {
-    throw new Error(title + " must be hex string or Uint8Array");
-  }
-  const len = res.length;
-  if (typeof expectedLength === "number" && len !== expectedLength)
-    throw new Error(title + " of length " + expectedLength + " expected, got " + len);
-  return res;
-}
-function concatBytes2(...arrays) {
-  let sum = 0;
-  for (let i = 0;i < arrays.length; i++) {
-    const a = arrays[i];
-    abytes2(a);
-    sum += a.length;
-  }
-  const res = new Uint8Array(sum);
-  for (let i = 0, pad = 0;i < arrays.length; i++) {
-    const a = arrays[i];
-    res.set(a, pad);
-    pad += a.length;
-  }
-  return res;
-}
-function inRange(n, min, max) {
-  return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
-}
-function aInRange(title, n, min, max) {
-  if (!inRange(n, min, max))
-    throw new Error("expected valid " + title + ": " + min + " <= n < " + max + ", got " + n);
-}
-function bitLen(n) {
-  let len;
-  for (len = 0;n > _0n; n >>= _1n, len += 1)
-    ;
-  return len;
-}
-function createHmacDrbg(hashLen, qByteLen, hmacFn) {
-  if (typeof hashLen !== "number" || hashLen < 2)
-    throw new Error("hashLen must be a number");
-  if (typeof qByteLen !== "number" || qByteLen < 2)
-    throw new Error("qByteLen must be a number");
-  if (typeof hmacFn !== "function")
-    throw new Error("hmacFn must be a function");
-  let v = u8n(hashLen);
-  let k = u8n(hashLen);
-  let i = 0;
-  const reset = () => {
-    v.fill(1);
-    k.fill(0);
-    i = 0;
-  };
-  const h = (...b) => hmacFn(k, v, ...b);
-  const reseed = (seed = u8n(0)) => {
-    k = h(u8fr([0]), seed);
-    v = h();
-    if (seed.length === 0)
-      return;
-    k = h(u8fr([1]), seed);
-    v = h();
-  };
-  const gen = () => {
-    if (i++ >= 1000)
-      throw new Error("drbg: tried 1000 values");
-    let len = 0;
-    const out = [];
-    while (len < qByteLen) {
-      v = h();
-      const sl = v.slice();
-      out.push(sl);
-      len += v.length;
-    }
-    return concatBytes2(...out);
-  };
-  const genUntil = (seed, pred) => {
-    reset();
-    reseed(seed);
-    let res = undefined;
-    while (!(res = pred(gen())))
-      reseed();
-    reset();
-    return res;
-  };
-  return genUntil;
-}
-function validateObject(object, validators, optValidators = {}) {
-  const checkField = (fieldName, type, isOptional) => {
-    const checkVal = validatorFns[type];
-    if (typeof checkVal !== "function")
-      throw new Error("invalid validator function");
-    const val = object[fieldName];
-    if (isOptional && val === undefined)
-      return;
-    if (!checkVal(val, object)) {
-      throw new Error("param " + String(fieldName) + " is invalid. Expected " + type + ", got " + val);
-    }
-  };
-  for (const [fieldName, type] of Object.entries(validators))
-    checkField(fieldName, type, false);
-  for (const [fieldName, type] of Object.entries(optValidators))
-    checkField(fieldName, type, true);
-  return object;
-}
-function memoized(fn) {
-  const map = new WeakMap;
-  return (arg, ...args) => {
-    const val = map.get(arg);
-    if (val !== undefined)
-      return val;
-    const computed = fn(arg, ...args);
-    map.set(arg, computed);
-    return computed;
-  };
-}
-var _0n, _1n, hasHexBuiltin, hexes, asciis, isPosBig = (n) => typeof n === "bigint" && _0n <= n, bitMask = (n) => (_1n << BigInt(n)) - _1n, u8n = (len) => new Uint8Array(len), u8fr = (arr) => Uint8Array.from(arr), validatorFns;
-var init_utils2 = __esm(() => {
-  /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  _0n = /* @__PURE__ */ BigInt(0);
-  _1n = /* @__PURE__ */ BigInt(1);
-  hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
-  hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-  asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
-  validatorFns = {
-    bigint: (val) => typeof val === "bigint",
-    function: (val) => typeof val === "function",
-    boolean: (val) => typeof val === "boolean",
-    string: (val) => typeof val === "string",
-    stringOrUint8Array: (val) => typeof val === "string" || isBytes2(val),
-    isSafeInteger: (val) => Number.isSafeInteger(val),
-    array: (val) => Array.isArray(val),
-    field: (val, object) => object.Fp.isValid(val),
-    hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
-  };
-});
-
-// ../../node_modules/.bun/@noble+curves@1.9.1/node_modules/@noble/curves/esm/abstract/modular.js
-function mod(a, b) {
-  const result = a % b;
-  return result >= _0n2 ? result : b + result;
-}
-function pow2(x, power, modulo) {
-  let res = x;
-  while (power-- > _0n2) {
-    res *= res;
-    res %= modulo;
-  }
-  return res;
-}
-function invert(number, modulo) {
-  if (number === _0n2)
-    throw new Error("invert: expected non-zero number");
-  if (modulo <= _0n2)
-    throw new Error("invert: expected positive modulus, got " + modulo);
-  let a = mod(number, modulo);
-  let b = modulo;
-  let x = _0n2, y = _1n2, u = _1n2, v = _0n2;
-  while (a !== _0n2) {
-    const q = b / a;
-    const r = b % a;
-    const m = x - u * q;
-    const n = y - v * q;
-    b = a, a = r, x = u, y = v, u = m, v = n;
-  }
-  const gcd = b;
-  if (gcd !== _1n2)
-    throw new Error("invert: does not exist");
-  return mod(x, modulo);
-}
-function sqrt3mod4(Fp, n) {
-  const p1div4 = (Fp.ORDER + _1n2) / _4n;
-  const root = Fp.pow(n, p1div4);
-  if (!Fp.eql(Fp.sqr(root), n))
-    throw new Error("Cannot find square root");
-  return root;
-}
-function sqrt5mod8(Fp, n) {
-  const p5div8 = (Fp.ORDER - _5n) / _8n;
-  const n2 = Fp.mul(n, _2n);
-  const v = Fp.pow(n2, p5div8);
-  const nv = Fp.mul(n, v);
-  const i = Fp.mul(Fp.mul(nv, _2n), v);
-  const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
-  if (!Fp.eql(Fp.sqr(root), n))
-    throw new Error("Cannot find square root");
-  return root;
-}
-function tonelliShanks(P) {
-  if (P < BigInt(3))
-    throw new Error("sqrt is not defined for small field");
-  let Q = P - _1n2;
-  let S = 0;
-  while (Q % _2n === _0n2) {
-    Q /= _2n;
-    S++;
-  }
-  let Z = _2n;
-  const _Fp = Field(P);
-  while (FpLegendre(_Fp, Z) === 1) {
-    if (Z++ > 1000)
-      throw new Error("Cannot find square root: probably non-prime P");
-  }
-  if (S === 1)
-    return sqrt3mod4;
-  let cc = _Fp.pow(Z, Q);
-  const Q1div2 = (Q + _1n2) / _2n;
-  return function tonelliSlow(Fp, n) {
-    if (Fp.is0(n))
-      return n;
-    if (FpLegendre(Fp, n) !== 1)
-      throw new Error("Cannot find square root");
-    let M = S;
-    let c = Fp.mul(Fp.ONE, cc);
-    let t = Fp.pow(n, Q);
-    let R = Fp.pow(n, Q1div2);
-    while (!Fp.eql(t, Fp.ONE)) {
-      if (Fp.is0(t))
-        return Fp.ZERO;
-      let i = 1;
-      let t_tmp = Fp.sqr(t);
-      while (!Fp.eql(t_tmp, Fp.ONE)) {
-        i++;
-        t_tmp = Fp.sqr(t_tmp);
-        if (i === M)
-          throw new Error("Cannot find square root");
-      }
-      const exponent = _1n2 << BigInt(M - i - 1);
-      const b = Fp.pow(c, exponent);
-      M = i;
-      c = Fp.sqr(b);
-      t = Fp.mul(t, c);
-      R = Fp.mul(R, b);
-    }
-    return R;
-  };
-}
-function FpSqrt(P) {
-  if (P % _4n === _3n)
-    return sqrt3mod4;
-  if (P % _8n === _5n)
-    return sqrt5mod8;
-  return tonelliShanks(P);
-}
-function validateField(field) {
-  const initial = {
-    ORDER: "bigint",
-    MASK: "bigint",
-    BYTES: "isSafeInteger",
-    BITS: "isSafeInteger"
-  };
-  const opts = FIELD_FIELDS.reduce((map, val) => {
-    map[val] = "function";
-    return map;
-  }, initial);
-  return validateObject(field, opts);
-}
-function FpPow(Fp, num, power) {
-  if (power < _0n2)
-    throw new Error("invalid exponent, negatives unsupported");
-  if (power === _0n2)
-    return Fp.ONE;
-  if (power === _1n2)
-    return num;
-  let p = Fp.ONE;
-  let d = num;
-  while (power > _0n2) {
-    if (power & _1n2)
-      p = Fp.mul(p, d);
-    d = Fp.sqr(d);
-    power >>= _1n2;
-  }
-  return p;
-}
-function FpInvertBatch(Fp, nums, passZero = false) {
-  const inverted = new Array(nums.length).fill(passZero ? Fp.ZERO : undefined);
-  const multipliedAcc = nums.reduce((acc, num, i) => {
-    if (Fp.is0(num))
-      return acc;
-    inverted[i] = acc;
-    return Fp.mul(acc, num);
-  }, Fp.ONE);
-  const invertedAcc = Fp.inv(multipliedAcc);
-  nums.reduceRight((acc, num, i) => {
-    if (Fp.is0(num))
-      return acc;
-    inverted[i] = Fp.mul(acc, inverted[i]);
-    return Fp.mul(acc, num);
-  }, invertedAcc);
-  return inverted;
-}
-function FpLegendre(Fp, n) {
-  const p1mod2 = (Fp.ORDER - _1n2) / _2n;
-  const powered = Fp.pow(n, p1mod2);
-  const yes = Fp.eql(powered, Fp.ONE);
-  const zero = Fp.eql(powered, Fp.ZERO);
-  const no = Fp.eql(powered, Fp.neg(Fp.ONE));
-  if (!yes && !zero && !no)
-    throw new Error("invalid Legendre symbol result");
-  return yes ? 1 : zero ? 0 : -1;
-}
-function nLength(n, nBitLength) {
-  if (nBitLength !== undefined)
-    anumber(nBitLength);
-  const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;
-  const nByteLength = Math.ceil(_nBitLength / 8);
-  return { nBitLength: _nBitLength, nByteLength };
-}
-function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
-  if (ORDER <= _0n2)
-    throw new Error("invalid field: expected ORDER > 0, got " + ORDER);
-  const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
-  if (BYTES > 2048)
-    throw new Error("invalid field: expected ORDER of <= 2048 bytes");
-  let sqrtP;
-  const f = Object.freeze({
-    ORDER,
-    isLE: isLE2,
-    BITS,
-    BYTES,
-    MASK: bitMask(BITS),
-    ZERO: _0n2,
-    ONE: _1n2,
-    create: (num) => mod(num, ORDER),
-    isValid: (num) => {
-      if (typeof num !== "bigint")
-        throw new Error("invalid field element: expected bigint, got " + typeof num);
-      return _0n2 <= num && num < ORDER;
-    },
-    is0: (num) => num === _0n2,
-    isOdd: (num) => (num & _1n2) === _1n2,
-    neg: (num) => mod(-num, ORDER),
-    eql: (lhs, rhs) => lhs === rhs,
-    sqr: (num) => mod(num * num, ORDER),
-    add: (lhs, rhs) => mod(lhs + rhs, ORDER),
-    sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
-    mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
-    pow: (num, power) => FpPow(f, num, power),
-    div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
-    sqrN: (num) => num * num,
-    addN: (lhs, rhs) => lhs + rhs,
-    subN: (lhs, rhs) => lhs - rhs,
-    mulN: (lhs, rhs) => lhs * rhs,
-    inv: (num) => invert(num, ORDER),
-    sqrt: redef.sqrt || ((n) => {
-      if (!sqrtP)
-        sqrtP = FpSqrt(ORDER);
-      return sqrtP(f, n);
-    }),
-    toBytes: (num) => isLE2 ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES),
-    fromBytes: (bytes) => {
-      if (bytes.length !== BYTES)
-        throw new Error("Field.fromBytes: expected " + BYTES + " bytes, got " + bytes.length);
-      return isLE2 ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);
-    },
-    invertBatch: (lst) => FpInvertBatch(f, lst),
-    cmov: (a, b, c) => c ? b : a
-  });
-  return Object.freeze(f);
-}
-function getFieldBytesLength(fieldOrder) {
-  if (typeof fieldOrder !== "bigint")
-    throw new Error("field order must be bigint");
-  const bitLength = fieldOrder.toString(2).length;
-  return Math.ceil(bitLength / 8);
-}
-function getMinHashLength(fieldOrder) {
-  const length = getFieldBytesLength(fieldOrder);
-  return length + Math.ceil(length / 2);
-}
-function mapHashToField(key, fieldOrder, isLE2 = false) {
-  const len = key.length;
-  const fieldLen = getFieldBytesLength(fieldOrder);
-  const minLen = getMinHashLength(fieldOrder);
-  if (len < 16 || len < minLen || len > 1024)
-    throw new Error("expected " + minLen + "-1024 bytes of input, got " + len);
-  const num = isLE2 ? bytesToNumberLE(key) : bytesToNumberBE(key);
-  const reduced = mod(num, fieldOrder - _1n2) + _1n2;
-  return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
-}
-var _0n2, _1n2, _2n, _3n, _4n, _5n, _8n, FIELD_FIELDS;
-var init_modular = __esm(() => {
-  init_utils();
-  init_utils2();
-  /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  _0n2 = BigInt(0);
-  _1n2 = BigInt(1);
-  _2n = /* @__PURE__ */ BigInt(2);
-  _3n = /* @__PURE__ */ BigInt(3);
-  _4n = /* @__PURE__ */ BigInt(4);
-  _5n = /* @__PURE__ */ BigInt(5);
-  _8n = /* @__PURE__ */ BigInt(8);
-  FIELD_FIELDS = [
-    "create",
-    "isValid",
-    "is0",
-    "neg",
-    "inv",
-    "sqrt",
-    "sqr",
-    "eql",
-    "add",
-    "sub",
-    "mul",
-    "pow",
-    "div",
-    "addN",
-    "subN",
-    "mulN",
-    "sqrN"
-  ];
-});
-
-// ../../node_modules/.bun/@noble+curves@1.9.1/node_modules/@noble/curves/esm/abstract/curve.js
-function constTimeNegate(condition, item) {
-  const neg = item.negate();
-  return condition ? neg : item;
-}
-function validateW(W, bits) {
-  if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
-    throw new Error("invalid window size, expected [1.." + bits + "], got W=" + W);
-}
-function calcWOpts(W, scalarBits) {
-  validateW(W, scalarBits);
-  const windows = Math.ceil(scalarBits / W) + 1;
-  const windowSize = 2 ** (W - 1);
-  const maxNumber = 2 ** W;
-  const mask = bitMask(W);
-  const shiftBy = BigInt(W);
-  return { windows, windowSize, mask, maxNumber, shiftBy };
-}
-function calcOffsets(n, window, wOpts) {
-  const { windowSize, mask, maxNumber, shiftBy } = wOpts;
-  let wbits = Number(n & mask);
-  let nextN = n >> shiftBy;
-  if (wbits > windowSize) {
-    wbits -= maxNumber;
-    nextN += _1n3;
-  }
-  const offsetStart = window * windowSize;
-  const offset = offsetStart + Math.abs(wbits) - 1;
-  const isZero = wbits === 0;
-  const isNeg = wbits < 0;
-  const isNegF = window % 2 !== 0;
-  const offsetF = offsetStart;
-  return { nextN, offset, isZero, isNeg, isNegF, offsetF };
-}
-function validateMSMPoints(points, c) {
-  if (!Array.isArray(points))
-    throw new Error("array expected");
-  points.forEach((p, i) => {
-    if (!(p instanceof c))
-      throw new Error("invalid point at index " + i);
-  });
-}
-function validateMSMScalars(scalars, field) {
-  if (!Array.isArray(scalars))
-    throw new Error("array of scalars expected");
-  scalars.forEach((s, i) => {
-    if (!field.isValid(s))
-      throw new Error("invalid scalar at index " + i);
-  });
-}
-function getW(P) {
-  return pointWindowSizes.get(P) || 1;
-}
-function wNAF(c, bits) {
-  return {
-    constTimeNegate,
-    hasPrecomputes(elm) {
-      return getW(elm) !== 1;
-    },
-    unsafeLadder(elm, n, p = c.ZERO) {
-      let d = elm;
-      while (n > _0n3) {
-        if (n & _1n3)
-          p = p.add(d);
-        d = d.double();
-        n >>= _1n3;
-      }
-      return p;
-    },
-    precomputeWindow(elm, W) {
-      const { windows, windowSize } = calcWOpts(W, bits);
-      const points = [];
-      let p = elm;
-      let base = p;
-      for (let window = 0;window < windows; window++) {
-        base = p;
-        points.push(base);
-        for (let i = 1;i < windowSize; i++) {
-          base = base.add(p);
-          points.push(base);
-        }
-        p = base.double();
-      }
-      return points;
-    },
-    wNAF(W, precomputes, n) {
-      let p = c.ZERO;
-      let f = c.BASE;
-      const wo = calcWOpts(W, bits);
-      for (let window = 0;window < wo.windows; window++) {
-        const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);
-        n = nextN;
-        if (isZero) {
-          f = f.add(constTimeNegate(isNegF, precomputes[offsetF]));
-        } else {
-          p = p.add(constTimeNegate(isNeg, precomputes[offset]));
-        }
-      }
-      return { p, f };
-    },
-    wNAFUnsafe(W, precomputes, n, acc = c.ZERO) {
-      const wo = calcWOpts(W, bits);
-      for (let window = 0;window < wo.windows; window++) {
-        if (n === _0n3)
-          break;
-        const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);
-        n = nextN;
-        if (isZero) {
-          continue;
-        } else {
-          const item = precomputes[offset];
-          acc = acc.add(isNeg ? item.negate() : item);
-        }
-      }
-      return acc;
-    },
-    getPrecomputes(W, P, transform) {
-      let comp = pointPrecomputes.get(P);
-      if (!comp) {
-        comp = this.precomputeWindow(P, W);
-        if (W !== 1)
-          pointPrecomputes.set(P, transform(comp));
-      }
-      return comp;
-    },
-    wNAFCached(P, n, transform) {
-      const W = getW(P);
-      return this.wNAF(W, this.getPrecomputes(W, P, transform), n);
-    },
-    wNAFCachedUnsafe(P, n, transform, prev) {
-      const W = getW(P);
-      if (W === 1)
-        return this.unsafeLadder(P, n, prev);
-      return this.wNAFUnsafe(W, this.getPrecomputes(W, P, transform), n, prev);
-    },
-    setWindowSize(P, W) {
-      validateW(W, bits);
-      pointWindowSizes.set(P, W);
-      pointPrecomputes.delete(P);
-    }
-  };
-}
-function pippenger(c, fieldN, points, scalars) {
-  validateMSMPoints(points, c);
-  validateMSMScalars(scalars, fieldN);
-  const plength = points.length;
-  const slength = scalars.length;
-  if (plength !== slength)
-    throw new Error("arrays of points and scalars must have equal length");
-  const zero = c.ZERO;
-  const wbits = bitLen(BigInt(plength));
-  let windowSize = 1;
-  if (wbits > 12)
-    windowSize = wbits - 3;
-  else if (wbits > 4)
-    windowSize = wbits - 2;
-  else if (wbits > 0)
-    windowSize = 2;
-  const MASK = bitMask(windowSize);
-  const buckets = new Array(Number(MASK) + 1).fill(zero);
-  const lastBits = Math.floor((fieldN.BITS - 1) / windowSize) * windowSize;
-  let sum = zero;
-  for (let i = lastBits;i >= 0; i -= windowSize) {
-    buckets.fill(zero);
-    for (let j = 0;j < slength; j++) {
-      const scalar = scalars[j];
-      const wbits2 = Number(scalar >> BigInt(i) & MASK);
-      buckets[wbits2] = buckets[wbits2].add(points[j]);
-    }
-    let resI = zero;
-    for (let j = buckets.length - 1, sumI = zero;j > 0; j--) {
-      sumI = sumI.add(buckets[j]);
-      resI = resI.add(sumI);
-    }
-    sum = sum.add(resI);
-    if (i !== 0)
-      for (let j = 0;j < windowSize; j++)
-        sum = sum.double();
-  }
-  return sum;
-}
-function validateBasic(curve) {
-  validateField(curve.Fp);
-  validateObject(curve, {
-    n: "bigint",
-    h: "bigint",
-    Gx: "field",
-    Gy: "field"
-  }, {
-    nBitLength: "isSafeInteger",
-    nByteLength: "isSafeInteger"
-  });
-  return Object.freeze({
-    ...nLength(curve.n, curve.nBitLength),
-    ...curve,
-    ...{ p: curve.Fp.ORDER }
-  });
-}
-var _0n3, _1n3, pointPrecomputes, pointWindowSizes;
-var init_curve = __esm(() => {
-  init_modular();
-  init_utils2();
-  /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  _0n3 = BigInt(0);
-  _1n3 = BigInt(1);
-  pointPrecomputes = new WeakMap;
-  pointWindowSizes = new WeakMap;
-});
-
-// ../../node_modules/.bun/@noble+curves@1.9.1/node_modules/@noble/curves/esm/abstract/weierstrass.js
-function validateSigVerOpts(opts) {
-  if (opts.lowS !== undefined)
-    abool("lowS", opts.lowS);
-  if (opts.prehash !== undefined)
-    abool("prehash", opts.prehash);
-}
-function validatePointOpts(curve) {
-  const opts = validateBasic(curve);
-  validateObject(opts, {
-    a: "field",
-    b: "field"
-  }, {
-    allowInfinityPoint: "boolean",
-    allowedPrivateKeyLengths: "array",
-    clearCofactor: "function",
-    fromBytes: "function",
-    isTorsionFree: "function",
-    toBytes: "function",
-    wrapPrivateKey: "boolean"
-  });
-  const { endo, Fp, a } = opts;
-  if (endo) {
-    if (!Fp.eql(a, Fp.ZERO)) {
-      throw new Error("invalid endo: CURVE.a must be 0");
-    }
-    if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
-      throw new Error('invalid endo: expected "beta": bigint and "splitScalar": function');
-    }
-  }
-  return Object.freeze({ ...opts });
-}
-function numToSizedHex(num, size) {
-  return bytesToHex(numberToBytesBE(num, size));
-}
-function weierstrassPoints(opts) {
-  const CURVE = validatePointOpts(opts);
-  const { Fp } = CURVE;
-  const Fn = Field(CURVE.n, CURVE.nBitLength);
-  const toBytes2 = CURVE.toBytes || ((_c, point, _isCompressed) => {
-    const a = point.toAffine();
-    return concatBytes2(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
-  });
-  const fromBytes = CURVE.fromBytes || ((bytes) => {
-    const tail = bytes.subarray(1);
-    const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));
-    const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));
-    return { x, y };
-  });
-  function weierstrassEquation(x) {
-    const { a, b } = CURVE;
-    const x2 = Fp.sqr(x);
-    const x3 = Fp.mul(x2, x);
-    return Fp.add(Fp.add(x3, Fp.mul(x, a)), b);
-  }
-  function isValidXY(x, y) {
-    const left = Fp.sqr(y);
-    const right = weierstrassEquation(x);
-    return Fp.eql(left, right);
-  }
-  if (!isValidXY(CURVE.Gx, CURVE.Gy))
-    throw new Error("bad curve params: generator point");
-  const _4a3 = Fp.mul(Fp.pow(CURVE.a, _3n2), _4n2);
-  const _27b2 = Fp.mul(Fp.sqr(CURVE.b), BigInt(27));
-  if (Fp.is0(Fp.add(_4a3, _27b2)))
-    throw new Error("bad curve params: a or b");
-  function isWithinCurveOrder(num) {
-    return inRange(num, _1n4, CURVE.n);
-  }
-  function normPrivateKeyToScalar(key) {
-    const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
-    if (lengths && typeof key !== "bigint") {
-      if (isBytes2(key))
-        key = bytesToHex(key);
-      if (typeof key !== "string" || !lengths.includes(key.length))
-        throw new Error("invalid private key");
-      key = key.padStart(nByteLength * 2, "0");
-    }
-    let num;
-    try {
-      num = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
-    } catch (error) {
-      throw new Error("invalid private key, expected hex or " + nByteLength + " bytes, got " + typeof key);
-    }
-    if (wrapPrivateKey)
-      num = mod(num, N);
-    aInRange("private key", num, _1n4, N);
-    return num;
-  }
-  function aprjpoint(other) {
-    if (!(other instanceof Point))
-      throw new Error("ProjectivePoint expected");
-  }
-  const toAffineMemo = memoized((p, iz) => {
-    const { px: x, py: y, pz: z } = p;
-    if (Fp.eql(z, Fp.ONE))
-      return { x, y };
-    const is0 = p.is0();
-    if (iz == null)
-      iz = is0 ? Fp.ONE : Fp.inv(z);
-    const ax = Fp.mul(x, iz);
-    const ay = Fp.mul(y, iz);
-    const zz = Fp.mul(z, iz);
-    if (is0)
-      return { x: Fp.ZERO, y: Fp.ZERO };
-    if (!Fp.eql(zz, Fp.ONE))
-      throw new Error("invZ was invalid");
-    return { x: ax, y: ay };
-  });
-  const assertValidMemo = memoized((p) => {
-    if (p.is0()) {
-      if (CURVE.allowInfinityPoint && !Fp.is0(p.py))
-        return;
-      throw new Error("bad point: ZERO");
-    }
-    const { x, y } = p.toAffine();
-    if (!Fp.isValid(x) || !Fp.isValid(y))
-      throw new Error("bad point: x or y not FE");
-    if (!isValidXY(x, y))
-      throw new Error("bad point: equation left != right");
-    if (!p.isTorsionFree())
-      throw new Error("bad point: not in prime-order subgroup");
-    return true;
-  });
-
-  class Point {
-    constructor(px, py, pz) {
-      if (px == null || !Fp.isValid(px))
-        throw new Error("x required");
-      if (py == null || !Fp.isValid(py) || Fp.is0(py))
-        throw new Error("y required");
-      if (pz == null || !Fp.isValid(pz))
-        throw new Error("z required");
-      this.px = px;
-      this.py = py;
-      this.pz = pz;
-      Object.freeze(this);
-    }
-    static fromAffine(p) {
-      const { x, y } = p || {};
-      if (!p || !Fp.isValid(x) || !Fp.isValid(y))
-        throw new Error("invalid affine point");
-      if (p instanceof Point)
-        throw new Error("projective point not allowed");
-      const is0 = (i) => Fp.eql(i, Fp.ZERO);
-      if (is0(x) && is0(y))
-        return Point.ZERO;
-      return new Point(x, y, Fp.ONE);
-    }
-    get x() {
-      return this.toAffine().x;
-    }
-    get y() {
-      return this.toAffine().y;
-    }
-    static normalizeZ(points) {
-      const toInv = FpInvertBatch(Fp, points.map((p) => p.pz));
-      return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
-    }
-    static fromHex(hex) {
-      const P = Point.fromAffine(fromBytes(ensureBytes("pointHex", hex)));
-      P.assertValidity();
-      return P;
-    }
-    static fromPrivateKey(privateKey) {
-      return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));
-    }
-    static msm(points, scalars) {
-      return pippenger(Point, Fn, points, scalars);
-    }
-    _setWindowSize(windowSize) {
-      wnaf.setWindowSize(this, windowSize);
-    }
-    assertValidity() {
-      assertValidMemo(this);
-    }
-    hasEvenY() {
-      const { y } = this.toAffine();
-      if (Fp.isOdd)
-        return !Fp.isOdd(y);
-      throw new Error("Field doesn't support isOdd");
-    }
-    equals(other) {
-      aprjpoint(other);
-      const { px: X1, py: Y1, pz: Z1 } = this;
-      const { px: X2, py: Y2, pz: Z2 } = other;
-      const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));
-      const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));
-      return U1 && U2;
-    }
-    negate() {
-      return new Point(this.px, Fp.neg(this.py), this.pz);
-    }
-    double() {
-      const { a, b } = CURVE;
-      const b3 = Fp.mul(b, _3n2);
-      const { px: X1, py: Y1, pz: Z1 } = this;
-      let { ZERO: X3, ZERO: Y3, ZERO: Z3 } = Fp;
-      let t0 = Fp.mul(X1, X1);
-      let t1 = Fp.mul(Y1, Y1);
-      let t2 = Fp.mul(Z1, Z1);
-      let t3 = Fp.mul(X1, Y1);
-      t3 = Fp.add(t3, t3);
-      Z3 = Fp.mul(X1, Z1);
-      Z3 = Fp.add(Z3, Z3);
-      X3 = Fp.mul(a, Z3);
-      Y3 = Fp.mul(b3, t2);
-      Y3 = Fp.add(X3, Y3);
-      X3 = Fp.sub(t1, Y3);
-      Y3 = Fp.add(t1, Y3);
-      Y3 = Fp.mul(X3, Y3);
-      X3 = Fp.mul(t3, X3);
-      Z3 = Fp.mul(b3, Z3);
-      t2 = Fp.mul(a, t2);
-      t3 = Fp.sub(t0, t2);
-      t3 = Fp.mul(a, t3);
-      t3 = Fp.add(t3, Z3);
-      Z3 = Fp.add(t0, t0);
-      t0 = Fp.add(Z3, t0);
-      t0 = Fp.add(t0, t2);
-      t0 = Fp.mul(t0, t3);
-      Y3 = Fp.add(Y3, t0);
-      t2 = Fp.mul(Y1, Z1);
-      t2 = Fp.add(t2, t2);
-      t0 = Fp.mul(t2, t3);
-      X3 = Fp.sub(X3, t0);
-      Z3 = Fp.mul(t2, t1);
-      Z3 = Fp.add(Z3, Z3);
-      Z3 = Fp.add(Z3, Z3);
-      return new Point(X3, Y3, Z3);
-    }
-    add(other) {
-      aprjpoint(other);
-      const { px: X1, py: Y1, pz: Z1 } = this;
-      const { px: X2, py: Y2, pz: Z2 } = other;
-      let { ZERO: X3, ZERO: Y3, ZERO: Z3 } = Fp;
-      const a = CURVE.a;
-      const b3 = Fp.mul(CURVE.b, _3n2);
-      let t0 = Fp.mul(X1, X2);
-      let t1 = Fp.mul(Y1, Y2);
-      let t2 = Fp.mul(Z1, Z2);
-      let t3 = Fp.add(X1, Y1);
-      let t4 = Fp.add(X2, Y2);
-      t3 = Fp.mul(t3, t4);
-      t4 = Fp.add(t0, t1);
-      t3 = Fp.sub(t3, t4);
-      t4 = Fp.add(X1, Z1);
-      let t5 = Fp.add(X2, Z2);
-      t4 = Fp.mul(t4, t5);
-      t5 = Fp.add(t0, t2);
-      t4 = Fp.sub(t4, t5);
-      t5 = Fp.add(Y1, Z1);
-      X3 = Fp.add(Y2, Z2);
-      t5 = Fp.mul(t5, X3);
-      X3 = Fp.add(t1, t2);
-      t5 = Fp.sub(t5, X3);
-      Z3 = Fp.mul(a, t4);
-      X3 = Fp.mul(b3, t2);
-      Z3 = Fp.add(X3, Z3);
-      X3 = Fp.sub(t1, Z3);
-      Z3 = Fp.add(t1, Z3);
-      Y3 = Fp.mul(X3, Z3);
-      t1 = Fp.add(t0, t0);
-      t1 = Fp.add(t1, t0);
-      t2 = Fp.mul(a, t2);
-      t4 = Fp.mul(b3, t4);
-      t1 = Fp.add(t1, t2);
-      t2 = Fp.sub(t0, t2);
-      t2 = Fp.mul(a, t2);
-      t4 = Fp.add(t4, t2);
-      t0 = Fp.mul(t1, t4);
-      Y3 = Fp.add(Y3, t0);
-      t0 = Fp.mul(t5, t4);
-      X3 = Fp.mul(t3, X3);
-      X3 = Fp.sub(X3, t0);
-      t0 = Fp.mul(t3, t1);
-      Z3 = Fp.mul(t5, Z3);
-      Z3 = Fp.add(Z3, t0);
-      return new Point(X3, Y3, Z3);
-    }
-    subtract(other) {
-      return this.add(other.negate());
-    }
-    is0() {
-      return this.equals(Point.ZERO);
-    }
-    wNAF(n) {
-      return wnaf.wNAFCached(this, n, Point.normalizeZ);
-    }
-    multiplyUnsafe(sc) {
-      const { endo: endo2, n: N } = CURVE;
-      aInRange("scalar", sc, _0n4, N);
-      const I = Point.ZERO;
-      if (sc === _0n4)
-        return I;
-      if (this.is0() || sc === _1n4)
-        return this;
-      if (!endo2 || wnaf.hasPrecomputes(this))
-        return wnaf.wNAFCachedUnsafe(this, sc, Point.normalizeZ);
-      let { k1neg, k1, k2neg, k2 } = endo2.splitScalar(sc);
-      let k1p = I;
-      let k2p = I;
-      let d = this;
-      while (k1 > _0n4 || k2 > _0n4) {
-        if (k1 & _1n4)
-          k1p = k1p.add(d);
-        if (k2 & _1n4)
-          k2p = k2p.add(d);
-        d = d.double();
-        k1 >>= _1n4;
-        k2 >>= _1n4;
-      }
-      if (k1neg)
-        k1p = k1p.negate();
-      if (k2neg)
-        k2p = k2p.negate();
-      k2p = new Point(Fp.mul(k2p.px, endo2.beta), k2p.py, k2p.pz);
-      return k1p.add(k2p);
-    }
-    multiply(scalar) {
-      const { endo: endo2, n: N } = CURVE;
-      aInRange("scalar", scalar, _1n4, N);
-      let point, fake;
-      if (endo2) {
-        const { k1neg, k1, k2neg, k2 } = endo2.splitScalar(scalar);
-        let { p: k1p, f: f1p } = this.wNAF(k1);
-        let { p: k2p, f: f2p } = this.wNAF(k2);
-        k1p = wnaf.constTimeNegate(k1neg, k1p);
-        k2p = wnaf.constTimeNegate(k2neg, k2p);
-        k2p = new Point(Fp.mul(k2p.px, endo2.beta), k2p.py, k2p.pz);
-        point = k1p.add(k2p);
-        fake = f1p.add(f2p);
-      } else {
-        const { p, f } = this.wNAF(scalar);
-        point = p;
-        fake = f;
-      }
-      return Point.normalizeZ([point, fake])[0];
-    }
-    multiplyAndAddUnsafe(Q, a, b) {
-      const G = Point.BASE;
-      const mul = (P, a2) => a2 === _0n4 || a2 === _1n4 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
-      const sum = mul(this, a).add(mul(Q, b));
-      return sum.is0() ? undefined : sum;
-    }
-    toAffine(iz) {
-      return toAffineMemo(this, iz);
-    }
-    isTorsionFree() {
-      const { h: cofactor, isTorsionFree } = CURVE;
-      if (cofactor === _1n4)
-        return true;
-      if (isTorsionFree)
-        return isTorsionFree(Point, this);
-      throw new Error("isTorsionFree() has not been declared for the elliptic curve");
-    }
-    clearCofactor() {
-      const { h: cofactor, clearCofactor } = CURVE;
-      if (cofactor === _1n4)
-        return this;
-      if (clearCofactor)
-        return clearCofactor(Point, this);
-      return this.multiplyUnsafe(CURVE.h);
-    }
-    toRawBytes(isCompressed = true) {
-      abool("isCompressed", isCompressed);
-      this.assertValidity();
-      return toBytes2(Point, this, isCompressed);
-    }
-    toHex(isCompressed = true) {
-      abool("isCompressed", isCompressed);
-      return bytesToHex(this.toRawBytes(isCompressed));
-    }
-  }
-  Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
-  Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
-  const { endo, nBitLength } = CURVE;
-  const wnaf = wNAF(Point, endo ? Math.ceil(nBitLength / 2) : nBitLength);
-  return {
-    CURVE,
-    ProjectivePoint: Point,
-    normPrivateKeyToScalar,
-    weierstrassEquation,
-    isWithinCurveOrder
-  };
-}
-function validateOpts(curve) {
-  const opts = validateBasic(curve);
-  validateObject(opts, {
-    hash: "hash",
-    hmac: "function",
-    randomBytes: "function"
-  }, {
-    bits2int: "function",
-    bits2int_modN: "function",
-    lowS: "boolean"
-  });
-  return Object.freeze({ lowS: true, ...opts });
-}
-function weierstrass(curveDef) {
-  const CURVE = validateOpts(curveDef);
-  const { Fp, n: CURVE_ORDER, nByteLength, nBitLength } = CURVE;
-  const compressedLen = Fp.BYTES + 1;
-  const uncompressedLen = 2 * Fp.BYTES + 1;
-  function modN(a) {
-    return mod(a, CURVE_ORDER);
-  }
-  function invN(a) {
-    return invert(a, CURVE_ORDER);
-  }
-  const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
-    ...CURVE,
-    toBytes(_c, point, isCompressed) {
-      const a = point.toAffine();
-      const x = Fp.toBytes(a.x);
-      const cat = concatBytes2;
-      abool("isCompressed", isCompressed);
-      if (isCompressed) {
-        return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
-      } else {
-        return cat(Uint8Array.from([4]), x, Fp.toBytes(a.y));
-      }
-    },
-    fromBytes(bytes) {
-      const len = bytes.length;
-      const head = bytes[0];
-      const tail = bytes.subarray(1);
-      if (len === compressedLen && (head === 2 || head === 3)) {
-        const x = bytesToNumberBE(tail);
-        if (!inRange(x, _1n4, Fp.ORDER))
-          throw new Error("Point is not on curve");
-        const y2 = weierstrassEquation(x);
-        let y;
-        try {
-          y = Fp.sqrt(y2);
-        } catch (sqrtError) {
-          const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
-          throw new Error("Point is not on curve" + suffix);
-        }
-        const isYOdd = (y & _1n4) === _1n4;
-        const isHeadOdd = (head & 1) === 1;
-        if (isHeadOdd !== isYOdd)
-          y = Fp.neg(y);
-        return { x, y };
-      } else if (len === uncompressedLen && head === 4) {
-        const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));
-        const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));
-        return { x, y };
-      } else {
-        const cl = compressedLen;
-        const ul = uncompressedLen;
-        throw new Error("invalid Point, expected length of " + cl + ", or uncompressed " + ul + ", got " + len);
-      }
-    }
-  });
-  function isBiggerThanHalfOrder(number) {
-    const HALF = CURVE_ORDER >> _1n4;
-    return number > HALF;
-  }
-  function normalizeS(s) {
-    return isBiggerThanHalfOrder(s) ? modN(-s) : s;
-  }
-  const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
-
-  class Signature {
-    constructor(r, s, recovery) {
-      aInRange("r", r, _1n4, CURVE_ORDER);
-      aInRange("s", s, _1n4, CURVE_ORDER);
-      this.r = r;
-      this.s = s;
-      if (recovery != null)
-        this.recovery = recovery;
-      Object.freeze(this);
-    }
-    static fromCompact(hex) {
-      const l = nByteLength;
-      hex = ensureBytes("compactSignature", hex, l * 2);
-      return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
-    }
-    static fromDER(hex) {
-      const { r, s } = DER.toSig(ensureBytes("DER", hex));
-      return new Signature(r, s);
-    }
-    assertValidity() {}
-    addRecoveryBit(recovery) {
-      return new Signature(this.r, this.s, recovery);
-    }
-    recoverPublicKey(msgHash) {
-      const { r, s, recovery: rec } = this;
-      const h = bits2int_modN(ensureBytes("msgHash", msgHash));
-      if (rec == null || ![0, 1, 2, 3].includes(rec))
-        throw new Error("recovery id invalid");
-      const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
-      if (radj >= Fp.ORDER)
-        throw new Error("recovery id 2 or 3 invalid");
-      const prefix = (rec & 1) === 0 ? "02" : "03";
-      const R = Point.fromHex(prefix + numToSizedHex(radj, Fp.BYTES));
-      const ir = invN(radj);
-      const u1 = modN(-h * ir);
-      const u2 = modN(s * ir);
-      const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2);
-      if (!Q)
-        throw new Error("point at infinify");
-      Q.assertValidity();
-      return Q;
-    }
-    hasHighS() {
-      return isBiggerThanHalfOrder(this.s);
-    }
-    normalizeS() {
-      return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;
-    }
-    toDERRawBytes() {
-      return hexToBytes(this.toDERHex());
-    }
-    toDERHex() {
-      return DER.hexFromSig(this);
-    }
-    toCompactRawBytes() {
-      return hexToBytes(this.toCompactHex());
-    }
-    toCompactHex() {
-      const l = nByteLength;
-      return numToSizedHex(this.r, l) + numToSizedHex(this.s, l);
-    }
-  }
-  const utils = {
-    isValidPrivateKey(privateKey) {
-      try {
-        normPrivateKeyToScalar(privateKey);
-        return true;
-      } catch (error) {
-        return false;
-      }
-    },
-    normPrivateKeyToScalar,
-    randomPrivateKey: () => {
-      const length = getMinHashLength(CURVE.n);
-      return mapHashToField(CURVE.randomBytes(length), CURVE.n);
-    },
-    precompute(windowSize = 8, point = Point.BASE) {
-      point._setWindowSize(windowSize);
-      point.multiply(BigInt(3));
-      return point;
-    }
-  };
-  function getPublicKey(privateKey, isCompressed = true) {
-    return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);
-  }
-  function isProbPub(item) {
-    if (typeof item === "bigint")
-      return false;
-    if (item instanceof Point)
-      return true;
-    const arr = ensureBytes("key", item);
-    const len = arr.length;
-    const fpl = Fp.BYTES;
-    const compLen = fpl + 1;
-    const uncompLen = 2 * fpl + 1;
-    if (CURVE.allowedPrivateKeyLengths || nByteLength === compLen) {
-      return;
-    } else {
-      return len === compLen || len === uncompLen;
-    }
-  }
-  function getSharedSecret(privateA, publicB, isCompressed = true) {
-    if (isProbPub(privateA) === true)
-      throw new Error("first arg must be private key");
-    if (isProbPub(publicB) === false)
-      throw new Error("second arg must be public key");
-    const b = Point.fromHex(publicB);
-    return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
-  }
-  const bits2int = CURVE.bits2int || function(bytes) {
-    if (bytes.length > 8192)
-      throw new Error("input is too large");
-    const num = bytesToNumberBE(bytes);
-    const delta = bytes.length * 8 - nBitLength;
-    return delta > 0 ? num >> BigInt(delta) : num;
-  };
-  const bits2int_modN = CURVE.bits2int_modN || function(bytes) {
-    return modN(bits2int(bytes));
-  };
-  const ORDER_MASK = bitMask(nBitLength);
-  function int2octets(num) {
-    aInRange("num < 2^" + nBitLength, num, _0n4, ORDER_MASK);
-    return numberToBytesBE(num, nByteLength);
-  }
-  function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
-    if (["recovered", "canonical"].some((k) => (k in opts)))
-      throw new Error("sign() legacy options not supported");
-    const { hash, randomBytes: randomBytes2 } = CURVE;
-    let { lowS, prehash, extraEntropy: ent } = opts;
-    if (lowS == null)
-      lowS = true;
-    msgHash = ensureBytes("msgHash", msgHash);
-    validateSigVerOpts(opts);
-    if (prehash)
-      msgHash = ensureBytes("prehashed msgHash", hash(msgHash));
-    const h1int = bits2int_modN(msgHash);
-    const d = normPrivateKeyToScalar(privateKey);
-    const seedArgs = [int2octets(d), int2octets(h1int)];
-    if (ent != null && ent !== false) {
-      const e = ent === true ? randomBytes2(Fp.BYTES) : ent;
-      seedArgs.push(ensureBytes("extraEntropy", e));
-    }
-    const seed = concatBytes2(...seedArgs);
-    const m = h1int;
-    function k2sig(kBytes) {
-      const k = bits2int(kBytes);
-      if (!isWithinCurveOrder(k))
-        return;
-      const ik = invN(k);
-      const q = Point.BASE.multiply(k).toAffine();
-      const r = modN(q.x);
-      if (r === _0n4)
-        return;
-      const s = modN(ik * modN(m + r * d));
-      if (s === _0n4)
-        return;
-      let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n4);
-      let normS = s;
-      if (lowS && isBiggerThanHalfOrder(s)) {
-        normS = normalizeS(s);
-        recovery ^= 1;
-      }
-      return new Signature(r, normS, recovery);
-    }
-    return { seed, k2sig };
-  }
-  const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
-  const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
-  function sign(msgHash, privKey, opts = defaultSigOpts) {
-    const { seed, k2sig } = prepSig(msgHash, privKey, opts);
-    const C = CURVE;
-    const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
-    return drbg(seed, k2sig);
-  }
-  Point.BASE._setWindowSize(8);
-  function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
-    const sg = signature;
-    msgHash = ensureBytes("msgHash", msgHash);
-    publicKey = ensureBytes("publicKey", publicKey);
-    const { lowS, prehash, format } = opts;
-    validateSigVerOpts(opts);
-    if ("strict" in opts)
-      throw new Error("options.strict was renamed to lowS");
-    if (format !== undefined && format !== "compact" && format !== "der")
-      throw new Error("format must be compact or der");
-    const isHex = typeof sg === "string" || isBytes2(sg);
-    const isObj = !isHex && !format && typeof sg === "object" && sg !== null && typeof sg.r === "bigint" && typeof sg.s === "bigint";
-    if (!isHex && !isObj)
-      throw new Error("invalid signature, expected Uint8Array, hex string or Signature instance");
-    let _sig = undefined;
-    let P;
-    try {
-      if (isObj)
-        _sig = new Signature(sg.r, sg.s);
-      if (isHex) {
-        try {
-          if (format !== "compact")
-            _sig = Signature.fromDER(sg);
-        } catch (derError) {
-          if (!(derError instanceof DER.Err))
-            throw derError;
-        }
-        if (!_sig && format !== "der")
-          _sig = Signature.fromCompact(sg);
-      }
-      P = Point.fromHex(publicKey);
-    } catch (error) {
-      return false;
-    }
-    if (!_sig)
-      return false;
-    if (lowS && _sig.hasHighS())
-      return false;
-    if (prehash)
-      msgHash = CURVE.hash(msgHash);
-    const { r, s } = _sig;
-    const h = bits2int_modN(msgHash);
-    const is = invN(s);
-    const u1 = modN(h * is);
-    const u2 = modN(r * is);
-    const R = Point.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
-    if (!R)
-      return false;
-    const v = modN(R.x);
-    return v === r;
-  }
-  return {
-    CURVE,
-    getPublicKey,
-    getSharedSecret,
-    sign,
-    verify,
-    ProjectivePoint: Point,
-    Signature,
-    utils
-  };
-}
-var DERErr, DER, _0n4, _1n4, _2n2, _3n2, _4n2;
-var init_weierstrass = __esm(() => {
-  init_curve();
-  init_modular();
-  init_utils2();
-  /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  DERErr = class DERErr extends Error {
-    constructor(m = "") {
-      super(m);
-    }
-  };
-  DER = {
-    Err: DERErr,
-    _tlv: {
-      encode: (tag, data) => {
-        const { Err: E } = DER;
-        if (tag < 0 || tag > 256)
-          throw new E("tlv.encode: wrong tag");
-        if (data.length & 1)
-          throw new E("tlv.encode: unpadded data");
-        const dataLen = data.length / 2;
-        const len = numberToHexUnpadded(dataLen);
-        if (len.length / 2 & 128)
-          throw new E("tlv.encode: long form length too big");
-        const lenLen = dataLen > 127 ? numberToHexUnpadded(len.length / 2 | 128) : "";
-        const t = numberToHexUnpadded(tag);
-        return t + lenLen + len + data;
-      },
-      decode(tag, data) {
-        const { Err: E } = DER;
-        let pos = 0;
-        if (tag < 0 || tag > 256)
-          throw new E("tlv.encode: wrong tag");
-        if (data.length < 2 || data[pos++] !== tag)
-          throw new E("tlv.decode: wrong tlv");
-        const first = data[pos++];
-        const isLong = !!(first & 128);
-        let length = 0;
-        if (!isLong)
-          length = first;
-        else {
-          const lenLen = first & 127;
-          if (!lenLen)
-            throw new E("tlv.decode(long): indefinite length not supported");
-          if (lenLen > 4)
-            throw new E("tlv.decode(long): byte length is too big");
-          const lengthBytes = data.subarray(pos, pos + lenLen);
-          if (lengthBytes.length !== lenLen)
-            throw new E("tlv.decode: length bytes not complete");
-          if (lengthBytes[0] === 0)
-            throw new E("tlv.decode(long): zero leftmost byte");
-          for (const b of lengthBytes)
-            length = length << 8 | b;
-          pos += lenLen;
-          if (length < 128)
-            throw new E("tlv.decode(long): not minimal encoding");
-        }
-        const v = data.subarray(pos, pos + length);
-        if (v.length !== length)
-          throw new E("tlv.decode: wrong value length");
-        return { v, l: data.subarray(pos + length) };
-      }
-    },
-    _int: {
-      encode(num) {
-        const { Err: E } = DER;
-        if (num < _0n4)
-          throw new E("integer: negative integers are not allowed");
-        let hex = numberToHexUnpadded(num);
-        if (Number.parseInt(hex[0], 16) & 8)
-          hex = "00" + hex;
-        if (hex.length & 1)
-          throw new E("unexpected DER parsing assertion: unpadded hex");
-        return hex;
-      },
-      decode(data) {
-        const { Err: E } = DER;
-        if (data[0] & 128)
-          throw new E("invalid signature integer: negative");
-        if (data[0] === 0 && !(data[1] & 128))
-          throw new E("invalid signature integer: unnecessary leading zero");
-        return bytesToNumberBE(data);
-      }
-    },
-    toSig(hex) {
-      const { Err: E, _int: int, _tlv: tlv } = DER;
-      const data = ensureBytes("signature", hex);
-      const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
-      if (seqLeftBytes.length)
-        throw new E("invalid signature: left bytes after parsing");
-      const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes);
-      const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes);
-      if (sLeftBytes.length)
-        throw new E("invalid signature: left bytes after parsing");
-      return { r: int.decode(rBytes), s: int.decode(sBytes) };
-    },
-    hexFromSig(sig) {
-      const { _tlv: tlv, _int: int } = DER;
-      const rs = tlv.encode(2, int.encode(sig.r));
-      const ss = tlv.encode(2, int.encode(sig.s));
-      const seq = rs + ss;
-      return tlv.encode(48, seq);
-    }
-  };
-  _0n4 = BigInt(0);
-  _1n4 = BigInt(1);
-  _2n2 = BigInt(2);
-  _3n2 = BigInt(3);
-  _4n2 = BigInt(4);
-});
-
-// ../../node_modules/.bun/@noble+curves@1.9.1/node_modules/@noble/curves/esm/_shortw_utils.js
-function getHash(hash) {
-  return {
-    hash,
-    hmac: (key, ...msgs) => hmac(hash, key, concatBytes(...msgs)),
-    randomBytes
-  };
-}
-function createCurve(curveDef, defHash) {
-  const create = (hash) => weierstrass({ ...curveDef, ...getHash(hash) });
-  return { ...create(defHash), create };
-}
-var init__shortw_utils = __esm(() => {
-  init_hmac();
-  init_utils();
-  init_weierstrass();
-  /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-});
-
-// ../../node_modules/.bun/@noble+curves@1.9.1/node_modules/@noble/curves/esm/secp256k1.js
-function sqrtMod(y) {
-  const P = secp256k1P;
-  const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
-  const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
-  const b2 = y * y * y % P;
-  const b3 = b2 * b2 * y % P;
-  const b6 = pow2(b3, _3n3, P) * b3 % P;
-  const b9 = pow2(b6, _3n3, P) * b3 % P;
-  const b11 = pow2(b9, _2n3, P) * b2 % P;
-  const b22 = pow2(b11, _11n, P) * b11 % P;
-  const b44 = pow2(b22, _22n, P) * b22 % P;
-  const b88 = pow2(b44, _44n, P) * b44 % P;
-  const b176 = pow2(b88, _88n, P) * b88 % P;
-  const b220 = pow2(b176, _44n, P) * b44 % P;
-  const b223 = pow2(b220, _3n3, P) * b3 % P;
-  const t1 = pow2(b223, _23n, P) * b22 % P;
-  const t2 = pow2(t1, _6n, P) * b2 % P;
-  const root = pow2(t2, _2n3, P);
-  if (!Fpk1.eql(Fpk1.sqr(root), y))
-    throw new Error("Cannot find square root");
-  return root;
-}
-var secp256k1P, secp256k1N, _0n5, _1n5, _2n3, divNearest = (a, b) => (a + b / _2n3) / b, Fpk1, secp256k1;
-var init_secp256k1 = __esm(() => {
-  init_sha2();
-  init__shortw_utils();
-  init_modular();
-  /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
-  secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
-  _0n5 = BigInt(0);
-  _1n5 = BigInt(1);
-  _2n3 = BigInt(2);
-  Fpk1 = Field(secp256k1P, undefined, undefined, { sqrt: sqrtMod });
-  secp256k1 = createCurve({
-    a: _0n5,
-    b: BigInt(7),
-    Fp: Fpk1,
-    n: secp256k1N,
-    Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
-    Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
-    h: BigInt(1),
-    lowS: true,
-    endo: {
-      beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
-      splitScalar: (k) => {
-        const n = secp256k1N;
-        const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
-        const b1 = -_1n5 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
-        const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
-        const b2 = a1;
-        const POW_2_128 = BigInt("0x100000000000000000000000000000000");
-        const c1 = divNearest(b2 * k, n);
-        const c2 = divNearest(-b1 * k, n);
-        let k1 = mod(k - c1 * a1 - c2 * a2, n);
-        let k2 = mod(-c1 * b1 - c2 * b2, n);
-        const k1neg = k1 > POW_2_128;
-        const k2neg = k2 > POW_2_128;
-        if (k1neg)
-          k1 = n - k1;
-        if (k2neg)
-          k2 = n - k2;
-        if (k1 > POW_2_128 || k2 > POW_2_128) {
-          throw new Error("splitScalar: Endomorphism failed, k=" + k);
-        }
-        return { k1neg, k1, k2neg, k2 };
-      }
-    }
-  }, sha256);
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/errors/version.js
-var version = "2.48.8";
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/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, args = {}) {
-      const details = (() => {
-        if (args.cause instanceof BaseError)
-          return args.cause.details;
-        if (args.cause?.message)
-          return args.cause.message;
-        return args.details;
-      })();
-      const docsPath = (() => {
-        if (args.cause instanceof BaseError)
-          return args.cause.docsPath || args.docsPath;
-        return args.docsPath;
-      })();
-      const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath });
-      const message = [
-        shortMessage || "An error occurred.",
-        "",
-        ...args.metaMessages ? [...args.metaMessages, ""] : [],
-        ...docsUrl ? [`Docs: ${docsUrl}`] : [],
-        ...details ? [`Details: ${details}`] : [],
-        ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
-      ].join(`
-`);
-      super(message, args.cause ? { cause: args.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 = args.metaMessages;
-      this.name = args.name ?? this.name;
-      this.shortMessage = shortMessage;
-      this.version = version;
-    }
-    walk(fn) {
-      return walk(this, fn);
-    }
-  };
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/errors/encoding.js
-var IntegerOutOfRangeError, SizeOverflowError;
-var init_encoding = __esm(() => {
-  init_base();
-  IntegerOutOfRangeError = class IntegerOutOfRangeError extends BaseError {
-    constructor({ max, min, signed, size, value }) {
-      super(`Number "${value}" is not in safe ${size ? `${size * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
-    }
-  };
-  SizeOverflowError = class SizeOverflowError extends BaseError {
-    constructor({ givenSize, maxSize }) {
-      super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
-    }
-  };
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/errors/data.js
-var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
-var init_data = __esm(() => {
-  init_base();
-  SliceOffsetOutOfBoundsError = class SliceOffsetOutOfBoundsError extends BaseError {
-    constructor({ offset, position, size }) {
-      super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size}).`, { name: "SliceOffsetOutOfBoundsError" });
-    }
-  };
-  SizeExceedsPaddingSizeError = class SizeExceedsPaddingSizeError extends BaseError {
-    constructor({ size, targetSize, type }) {
-      super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
-    }
-  };
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/data/pad.js
-function pad(hexOrBytes, { dir, size = 32 } = {}) {
-  if (typeof hexOrBytes === "string")
-    return padHex(hexOrBytes, { dir, size });
-  return padBytes(hexOrBytes, { dir, size });
-}
-function padHex(hex_, { dir, size = 32 } = {}) {
-  if (size === null)
-    return hex_;
-  const hex = hex_.replace("0x", "");
-  if (hex.length > size * 2)
-    throw new SizeExceedsPaddingSizeError({
-      size: Math.ceil(hex.length / 2),
-      targetSize: size,
-      type: "hex"
-    });
-  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size * 2, "0")}`;
-}
-function padBytes(bytes, { dir, size = 32 } = {}) {
-  if (size === null)
-    return bytes;
-  if (bytes.length > size)
-    throw new SizeExceedsPaddingSizeError({
-      size: bytes.length,
-      targetSize: size,
-      type: "bytes"
-    });
-  const paddedBytes = new Uint8Array(size);
-  for (let i = 0;i < size; i++) {
-    const padEnd = dir === "right";
-    paddedBytes[padEnd ? i : size - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
-  }
-  return paddedBytes;
-}
-var init_pad = __esm(() => {
-  init_data();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/data/isHex.js
-function isHex(value, { strict = true } = {}) {
-  if (!value)
-    return false;
-  if (typeof value !== "string")
-    return false;
-  return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
-}
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/data/size.js
-function size(value) {
-  if (isHex(value, { strict: false }))
-    return Math.ceil((value.length - 2) / 2);
-  return value.length;
-}
-var init_size = () => {};
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/data/trim.js
-function trim(hexOrBytes, { dir = "left" } = {}) {
-  let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
-  let sliceLength = 0;
-  for (let i = 0;i < data.length - 1; i++) {
-    if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
-      sliceLength++;
-    else
-      break;
-  }
-  data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
-  if (typeof hexOrBytes === "string") {
-    if (data.length === 1 && dir === "right")
-      data = `${data}0`;
-    return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
-  }
-  return data;
-}
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/encoding/toBytes.js
-function toBytes2(value, opts = {}) {
-  if (typeof value === "number" || typeof value === "bigint")
-    return numberToBytes(value, opts);
-  if (typeof value === "boolean")
-    return boolToBytes(value, opts);
-  if (isHex(value))
-    return hexToBytes2(value, opts);
-  return stringToBytes(value, opts);
-}
-function boolToBytes(value, opts = {}) {
-  const bytes = new Uint8Array(1);
-  bytes[0] = Number(value);
-  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 hexToBytes2(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 length = hexString.length / 2;
-  const bytes = new Uint8Array(length);
-  for (let index = 0, j = 0;index < length; 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(value, opts) {
-  const hex = numberToHex(value, opts);
-  return hexToBytes2(hex);
-}
-function stringToBytes(value, opts = {}) {
-  const bytes = encoder.encode(value);
-  if (typeof opts.size === "number") {
-    assertSize(bytes, { size: opts.size });
-    return pad(bytes, { dir: "right", size: opts.size });
-  }
-  return bytes;
-}
-var encoder, charCodeMap;
-var init_toBytes = __esm(() => {
-  init_base();
-  init_pad();
-  init_fromHex();
-  init_toHex();
-  encoder = /* @__PURE__ */ new TextEncoder;
-  charCodeMap = {
-    zero: 48,
-    nine: 57,
-    A: 65,
-    F: 70,
-    a: 97,
-    f: 102
-  };
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/encoding/fromHex.js
-function assertSize(hexOrBytes, { size: size2 }) {
-  if (size(hexOrBytes) > size2)
-    throw new SizeOverflowError({
-      givenSize: size(hexOrBytes),
-      maxSize: size2
-    });
-}
-function hexToBigInt(hex, opts = {}) {
-  const { signed } = opts;
-  if (opts.size)
-    assertSize(hex, { size: opts.size });
-  const value = BigInt(hex);
-  if (!signed)
-    return value;
-  const size2 = (hex.length - 2) / 2;
-  const max = (1n << BigInt(size2) * 8n - 1n) - 1n;
-  if (value <= max)
-    return value;
-  return value - BigInt(`0x${"f".padStart(size2 * 2, "f")}`) - 1n;
-}
-function hexToNumber2(hex, opts = {}) {
-  const value = hexToBigInt(hex, opts);
-  const number = Number(value);
-  if (!Number.isSafeInteger(number))
-    throw new IntegerOutOfRangeError({
-      max: `${Number.MAX_SAFE_INTEGER}`,
-      min: `${Number.MIN_SAFE_INTEGER}`,
-      signed: opts.signed,
-      size: opts.size,
-      value: `${value}n`
-    });
-  return number;
-}
-var init_fromHex = __esm(() => {
-  init_encoding();
-  init_size();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/encoding/toHex.js
-function toHex(value, opts = {}) {
-  if (typeof value === "number" || typeof value === "bigint")
-    return numberToHex(value, opts);
-  if (typeof value === "string") {
-    return stringToHex(value, opts);
-  }
-  if (typeof value === "boolean")
-    return boolToHex(value, opts);
-  return bytesToHex2(value, opts);
-}
-function boolToHex(value, opts = {}) {
-  const hex = `0x${Number(value)}`;
-  if (typeof opts.size === "number") {
-    assertSize(hex, { size: opts.size });
-    return pad(hex, { size: opts.size });
-  }
-  return hex;
-}
-function bytesToHex2(value, opts = {}) {
-  let string = "";
-  for (let i = 0;i < value.length; i++) {
-    string += hexes2[value[i]];
-  }
-  const hex = `0x${string}`;
-  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: size2 } = opts;
-  const value = BigInt(value_);
-  let maxValue;
-  if (size2) {
-    if (signed)
-      maxValue = (1n << BigInt(size2) * 8n - 1n) - 1n;
-    else
-      maxValue = 2n ** (BigInt(size2) * 8n) - 1n;
-  } else if (typeof value_ === "number") {
-    maxValue = BigInt(Number.MAX_SAFE_INTEGER);
-  }
-  const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
-  if (maxValue && value > maxValue || value < minValue) {
-    const suffix = typeof value_ === "bigint" ? "n" : "";
-    throw new IntegerOutOfRangeError({
-      max: maxValue ? `${maxValue}${suffix}` : undefined,
-      min: `${minValue}${suffix}`,
-      signed,
-      size: size2,
-      value: `${value_}${suffix}`
-    });
-  }
-  const hex = `0x${(signed && value < 0 ? (1n << BigInt(size2 * 8)) + BigInt(value) : value).toString(16)}`;
-  if (size2)
-    return pad(hex, { size: size2 });
-  return hex;
-}
-function stringToHex(value_, opts = {}) {
-  const value = encoder2.encode(value_);
-  return bytesToHex2(value, opts);
-}
-var hexes2, encoder2;
-var init_toHex = __esm(() => {
-  init_encoding();
-  init_pad();
-  init_fromHex();
-  hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
-  encoder2 = /* @__PURE__ */ new TextEncoder;
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/accounts/generatePrivateKey.js
-function generatePrivateKey() {
-  return toHex(secp256k1.utils.randomPrivateKey());
-}
-var init_generatePrivateKey = __esm(() => {
-  init_secp256k1();
-  init_toHex();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/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/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/lru.js
-var LruMap;
-var init_lru = __esm(() => {
-  LruMap = class LruMap extends Map {
-    constructor(size2) {
-      super();
-      Object.defineProperty(this, "maxSize", {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: undefined
-      });
-      this.maxSize = size2;
-    }
-    get(key) {
-      const value = super.get(key);
-      if (super.has(key)) {
-        super.delete(key);
-        super.set(key, value);
-      }
-      return value;
-    }
-    set(key, value) {
-      if (super.has(key))
-        super.delete(key);
-      super.set(key, value);
-      if (this.maxSize && this.size > this.maxSize) {
-        const firstKey = super.keys().next().value;
-        if (firstKey !== undefined)
-          super.delete(firstKey);
-      }
-      return this;
-    }
-  };
-});
-
-// ../../node_modules/.bun/@noble+hashes@1.8.0/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 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];
-  }
-  clean(B);
-}
-var _0n6, _1n6, _2n4, _7n, _256n, _0x71n, SHA3_PI, SHA3_ROTL, _SHA3_IOTA, IOTAS, 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, gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen)), keccak_256;
-var init_sha3 = __esm(() => {
-  init__u64();
-  init_utils();
-  _0n6 = BigInt(0);
-  _1n6 = BigInt(1);
-  _2n4 = BigInt(2);
-  _7n = BigInt(7);
-  _256n = BigInt(256);
-  _0x71n = BigInt(113);
-  SHA3_PI = [];
-  SHA3_ROTL = [];
-  _SHA3_IOTA = [];
-  for (let round = 0, R = _1n6, 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 = _0n6;
-    for (let j = 0;j < 7; j++) {
-      R = (R << _1n6 ^ (R >> _7n) * _0x71n) % _256n;
-      if (R & _2n4)
-        t ^= _1n6 << (_1n6 << /* @__PURE__ */ BigInt(j)) - _1n6;
-    }
-    _SHA3_IOTA.push(t);
-  }
-  IOTAS = split(_SHA3_IOTA, true);
-  SHA3_IOTA_H = IOTAS[0];
-  SHA3_IOTA_L = IOTAS[1];
-  Keccak = class Keccak extends Hash {
-    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
-      super();
-      this.pos = 0;
-      this.posOut = 0;
-      this.finished = false;
-      this.destroyed = false;
-      this.enableXOF = false;
-      this.blockLen = blockLen;
-      this.suffix = suffix;
-      this.outputLen = outputLen;
-      this.enableXOF = enableXOF;
-      this.rounds = rounds;
-      anumber(outputLen);
-      if (!(0 < blockLen && blockLen < 200))
-        throw new Error("only keccak-f1600 function is supported");
-      this.state = new Uint8Array(200);
-      this.state32 = u32(this.state);
-    }
-    clone() {
-      return this._cloneInto();
-    }
-    keccak() {
-      swap32IfBE(this.state32);
-      keccakP(this.state32, this.rounds);
-      swap32IfBE(this.state32);
-      this.posOut = 0;
-      this.pos = 0;
-    }
-    update(data) {
-      aexists(this);
-      data = toBytes(data);
-      abytes(data);
-      const { blockLen, state } = this;
-      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) {
-      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 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(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;
-      clean(this.state);
-    }
-    _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;
-    }
-  };
-  keccak_256 = /* @__PURE__ */ (() => gen(1, 136, 256 / 8))();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/hash/keccak256.js
-function keccak256(value, to_) {
-  const to = to_ || "hex";
-  const bytes = keccak_256(isHex(value, { strict: false }) ? toBytes2(value) : value);
-  if (to === "bytes")
-    return bytes;
-  return toHex(bytes);
-}
-var init_keccak256 = __esm(() => {
-  init_sha3();
-  init_toBytes();
-  init_toHex();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/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 hash = keccak256(stringToBytes(hexAddress), "bytes");
-  const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
-  for (let i = 0;i < 40; i += 2) {
-    if (hash[i >> 1] >> 4 >= 8 && address[i]) {
-      address[i] = address[i].toUpperCase();
-    }
-    if ((hash[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/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/address/isAddress.js
-function isAddress(address, options) {
-  const { strict = true } = options ?? {};
-  const cacheKey = `${address}.${strict}`;
-  if (isAddressCache.has(cacheKey))
-    return isAddressCache.get(cacheKey);
-  const result = (() => {
-    if (!addressRegex.test(address))
-      return false;
-    if (address.toLowerCase() === address)
-      return true;
-    if (strict)
-      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/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/accounts/toAccount.js
-function toAccount(source) {
-  if (typeof source === "string") {
-    if (!isAddress(source, { strict: false }))
-      throw new InvalidAddressError({ address: source });
-    return {
-      address: source,
-      type: "json-rpc"
-    };
-  }
-  if (!isAddress(source.address, { strict: false }))
-    throw new InvalidAddressError({ address: source.address });
-  return {
-    address: source.address,
-    nonceManager: source.nonceManager,
-    sign: source.sign,
-    signAuthorization: source.signAuthorization,
-    signMessage: source.signMessage,
-    signTransaction: source.signTransaction,
-    signTypedData: source.signTypedData,
-    source: "custom",
-    type: "local"
-  };
-}
-var init_toAccount = __esm(() => {
-  init_address();
-  init_isAddress();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
-function publicKeyToAddress(publicKey) {
-  const address = keccak256(`0x${publicKey.substring(4)}`).substring(26);
-  return checksumAddress(`0x${address}`);
-}
-var init_publicKeyToAddress = __esm(() => {
-  init_getAddress();
-  init_keccak256();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/signature/serializeSignature.js
-function serializeSignature({ r, s, to = "hex", v, yParity }) {
-  const yParity_ = (() => {
-    if (yParity === 0 || yParity === 1)
-      return yParity;
-    if (v && (v === 27n || v === 28n || v >= 35n))
-      return v % 2n === 0n ? 1 : 0;
-    throw new Error("Invalid `v` or `yParity` value");
-  })();
-  const signature = `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? "1b" : "1c"}`;
-  if (to === "hex")
-    return signature;
-  return hexToBytes2(signature);
-}
-var init_serializeSignature = __esm(() => {
-  init_secp256k1();
-  init_fromHex();
-  init_toBytes();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/accounts/utils/sign.js
-async function sign({ hash, privateKey, to = "object" }) {
-  const { r, s, recovery } = secp256k1.sign(hash.slice(2), privateKey.slice(2), {
-    lowS: true,
-    extraEntropy: isHex(extraEntropy, { strict: false }) ? hexToBytes2(extraEntropy) : extraEntropy
-  });
-  const signature = {
-    r: numberToHex(r, { size: 32 }),
-    s: numberToHex(s, { size: 32 }),
-    v: recovery ? 28n : 27n,
-    yParity: recovery
-  };
-  return (() => {
-    if (to === "bytes" || to === "hex")
-      return serializeSignature({ ...signature, to });
-    return signature;
-  })();
-}
-var extraEntropy = false;
-var init_sign = __esm(() => {
-  init_secp256k1();
-  init_toBytes();
-  init_toHex();
-  init_serializeSignature();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/data/concat.js
-function concat(values) {
-  if (typeof values[0] === "string")
-    return concatHex(values);
-  return concatBytes3(values);
-}
-function concatBytes3(values) {
-  let length = 0;
-  for (const arr of values) {
-    length += arr.length;
-  }
-  const result = new Uint8Array(length);
-  let offset = 0;
-  for (const arr of values) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-  return result;
-}
-function concatHex(values) {
-  return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
-}
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/errors/cursor.js
-var NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededError;
-var init_cursor = __esm(() => {
-  init_base();
-  NegativeOffsetError = class NegativeOffsetError extends BaseError {
-    constructor({ offset }) {
-      super(`Offset \`${offset}\` cannot be negative.`, {
-        name: "NegativeOffsetError"
-      });
-    }
-  };
-  PositionOutOfBoundsError = class PositionOutOfBoundsError extends BaseError {
-    constructor({ length, position }) {
-      super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
-    }
-  };
-  RecursiveReadLimitExceededError = class RecursiveReadLimitExceededError extends BaseError {
-    constructor({ count, limit }) {
-      super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
-    }
-  };
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/cursor.js
-function createCursor(bytes, { recursiveReadLimit = 8192 } = {}) {
-  const cursor = Object.create(staticCursor);
-  cursor.bytes = bytes;
-  cursor.dataView = new DataView(bytes.buffer ?? bytes, bytes.byteOffset, bytes.byteLength);
-  cursor.positionReadCount = new Map;
-  cursor.recursiveReadLimit = recursiveReadLimit;
-  return cursor;
-}
-var staticCursor;
-var init_cursor2 = __esm(() => {
-  init_cursor();
-  staticCursor = {
-    bytes: new Uint8Array,
-    dataView: new DataView(new ArrayBuffer(0)),
-    position: 0,
-    positionReadCount: new Map,
-    recursiveReadCount: 0,
-    recursiveReadLimit: Number.POSITIVE_INFINITY,
-    assertReadLimit() {
-      if (this.recursiveReadCount >= this.recursiveReadLimit)
-        throw new RecursiveReadLimitExceededError({
-          count: this.recursiveReadCount + 1,
-          limit: this.recursiveReadLimit
-        });
-    },
-    assertPosition(position) {
-      if (position < 0 || position > this.bytes.length - 1)
-        throw new PositionOutOfBoundsError({
-          length: this.bytes.length,
-          position
-        });
-    },
-    decrementPosition(offset) {
-      if (offset < 0)
-        throw new NegativeOffsetError({ offset });
-      const position = this.position - offset;
-      this.assertPosition(position);
-      this.position = position;
-    },
-    getReadCount(position) {
-      return this.positionReadCount.get(position || this.position) || 0;
-    },
-    incrementPosition(offset) {
-      if (offset < 0)
-        throw new NegativeOffsetError({ offset });
-      const position = this.position + offset;
-      this.assertPosition(position);
-      this.position = position;
-    },
-    inspectByte(position_) {
-      const position = position_ ?? this.position;
-      this.assertPosition(position);
-      return this.bytes[position];
-    },
-    inspectBytes(length, position_) {
-      const position = position_ ?? this.position;
-      this.assertPosition(position + length - 1);
-      return this.bytes.subarray(position, position + length);
-    },
-    inspectUint8(position_) {
-      const position = position_ ?? this.position;
-      this.assertPosition(position);
-      return this.bytes[position];
-    },
-    inspectUint16(position_) {
-      const position = position_ ?? this.position;
-      this.assertPosition(position + 1);
-      return this.dataView.getUint16(position);
-    },
-    inspectUint24(position_) {
-      const position = position_ ?? this.position;
-      this.assertPosition(position + 2);
-      return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
-    },
-    inspectUint32(position_) {
-      const position = position_ ?? this.position;
-      this.assertPosition(position + 3);
-      return this.dataView.getUint32(position);
-    },
-    pushByte(byte) {
-      this.assertPosition(this.position);
-      this.bytes[this.position] = byte;
-      this.position++;
-    },
-    pushBytes(bytes) {
-      this.assertPosition(this.position + bytes.length - 1);
-      this.bytes.set(bytes, this.position);
-      this.position += bytes.length;
-    },
-    pushUint8(value) {
-      this.assertPosition(this.position);
-      this.bytes[this.position] = value;
-      this.position++;
-    },
-    pushUint16(value) {
-      this.assertPosition(this.position + 1);
-      this.dataView.setUint16(this.position, value);
-      this.position += 2;
-    },
-    pushUint24(value) {
-      this.assertPosition(this.position + 2);
-      this.dataView.setUint16(this.position, value >> 8);
-      this.dataView.setUint8(this.position + 2, value & ~4294967040);
-      this.position += 3;
-    },
-    pushUint32(value) {
-      this.assertPosition(this.position + 3);
-      this.dataView.setUint32(this.position, value);
-      this.position += 4;
-    },
-    readByte() {
-      this.assertReadLimit();
-      this._touch();
-      const value = this.inspectByte();
-      this.position++;
-      return value;
-    },
-    readBytes(length, size2) {
-      this.assertReadLimit();
-      this._touch();
-      const value = this.inspectBytes(length);
-      this.position += size2 ?? length;
-      return value;
-    },
-    readUint8() {
-      this.assertReadLimit();
-      this._touch();
-      const value = this.inspectUint8();
-      this.position += 1;
-      return value;
-    },
-    readUint16() {
-      this.assertReadLimit();
-      this._touch();
-      const value = this.inspectUint16();
-      this.position += 2;
-      return value;
-    },
-    readUint24() {
-      this.assertReadLimit();
-      this._touch();
-      const value = this.inspectUint24();
-      this.position += 3;
-      return value;
-    },
-    readUint32() {
-      this.assertReadLimit();
-      this._touch();
-      const value = this.inspectUint32();
-      this.position += 4;
-      return value;
-    },
-    get remaining() {
-      return this.bytes.length - this.position;
-    },
-    setPosition(position) {
-      const oldPosition = this.position;
-      this.assertPosition(position);
-      this.position = position;
-      return () => this.position = oldPosition;
-    },
-    _touch() {
-      if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
-        return;
-      const count = this.getReadCount();
-      this.positionReadCount.set(this.position, count + 1);
-      if (count > 0)
-        this.recursiveReadCount++;
-    }
-  };
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/encoding/toRlp.js
-function toRlp(bytes, to = "hex") {
-  const encodable = getEncodable(bytes);
-  const cursor = createCursor(new Uint8Array(encodable.length));
-  encodable.encode(cursor);
-  if (to === "hex")
-    return bytesToHex2(cursor.bytes);
-  return cursor.bytes;
-}
-function getEncodable(bytes) {
-  if (Array.isArray(bytes))
-    return getEncodableList(bytes.map((x) => getEncodable(x)));
-  return getEncodableBytes(bytes);
-}
-function getEncodableList(list) {
-  const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
-  const sizeOfBodyLength = getSizeOfLength(bodyLength);
-  const length = (() => {
-    if (bodyLength <= 55)
-      return 1 + bodyLength;
-    return 1 + sizeOfBodyLength + bodyLength;
-  })();
-  return {
-    length,
-    encode(cursor) {
-      if (bodyLength <= 55) {
-        cursor.pushByte(192 + bodyLength);
-      } else {
-        cursor.pushByte(192 + 55 + sizeOfBodyLength);
-        if (sizeOfBodyLength === 1)
-          cursor.pushUint8(bodyLength);
-        else if (sizeOfBodyLength === 2)
-          cursor.pushUint16(bodyLength);
-        else if (sizeOfBodyLength === 3)
-          cursor.pushUint24(bodyLength);
-        else
-          cursor.pushUint32(bodyLength);
-      }
-      for (const { encode } of list) {
-        encode(cursor);
-      }
-    }
-  };
-}
-function getEncodableBytes(bytesOrHex) {
-  const bytes = typeof bytesOrHex === "string" ? hexToBytes2(bytesOrHex) : bytesOrHex;
-  const sizeOfBytesLength = getSizeOfLength(bytes.length);
-  const length = (() => {
-    if (bytes.length === 1 && bytes[0] < 128)
-      return 1;
-    if (bytes.length <= 55)
-      return 1 + bytes.length;
-    return 1 + sizeOfBytesLength + bytes.length;
-  })();
-  return {
-    length,
-    encode(cursor) {
-      if (bytes.length === 1 && bytes[0] < 128) {
-        cursor.pushBytes(bytes);
-      } else if (bytes.length <= 55) {
-        cursor.pushByte(128 + bytes.length);
-        cursor.pushBytes(bytes);
-      } else {
-        cursor.pushByte(128 + 55 + sizeOfBytesLength);
-        if (sizeOfBytesLength === 1)
-          cursor.pushUint8(bytes.length);
-        else if (sizeOfBytesLength === 2)
-          cursor.pushUint16(bytes.length);
-        else if (sizeOfBytesLength === 3)
-          cursor.pushUint24(bytes.length);
-        else
-          cursor.pushUint32(bytes.length);
-        cursor.pushBytes(bytes);
-      }
-    }
-  };
-}
-function getSizeOfLength(length) {
-  if (length < 2 ** 8)
-    return 1;
-  if (length < 2 ** 16)
-    return 2;
-  if (length < 2 ** 24)
-    return 3;
-  if (length < 2 ** 32)
-    return 4;
-  throw new BaseError("Length is too large.");
-}
-var init_toRlp = __esm(() => {
-  init_base();
-  init_cursor2();
-  init_toBytes();
-  init_toHex();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/authorization/hashAuthorization.js
-function hashAuthorization(parameters) {
-  const { chainId, nonce, to } = parameters;
-  const address = parameters.contractAddress ?? parameters.address;
-  const hash = keccak256(concatHex([
-    "0x05",
-    toRlp([
-      chainId ? numberToHex(chainId) : "0x",
-      address,
-      nonce ? numberToHex(nonce) : "0x"
-    ])
-  ]));
-  if (to === "bytes")
-    return hexToBytes2(hash);
-  return hash;
-}
-var init_hashAuthorization = __esm(() => {
-  init_toBytes();
-  init_toHex();
-  init_toRlp();
-  init_keccak256();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/accounts/utils/signAuthorization.js
-async function signAuthorization(parameters) {
-  const { chainId, nonce, privateKey, to = "object" } = parameters;
-  const address = parameters.contractAddress ?? parameters.address;
-  const signature = await sign({
-    hash: hashAuthorization({ address, chainId, nonce }),
-    privateKey,
-    to
-  });
-  if (to === "object")
-    return {
-      address,
-      chainId,
-      nonce,
-      ...signature
-    };
-  return signature;
-}
-var init_signAuthorization = __esm(() => {
-  init_hashAuthorization();
-  init_sign();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/constants/strings.js
-var presignMessagePrefix = `\x19Ethereum Signed Message:
-`;
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/signature/toPrefixedMessage.js
-function toPrefixedMessage(message_) {
-  const message = (() => {
-    if (typeof message_ === "string")
-      return stringToHex(message_);
-    if (typeof message_.raw === "string")
-      return message_.raw;
-    return bytesToHex2(message_.raw);
-  })();
-  const prefix = stringToHex(`${presignMessagePrefix}${size(message)}`);
-  return concat([prefix, message]);
-}
-var init_toPrefixedMessage = __esm(() => {
-  init_size();
-  init_toHex();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/signature/hashMessage.js
-function hashMessage(message, to_) {
-  return keccak256(toPrefixedMessage(message), to_);
-}
-var init_hashMessage = __esm(() => {
-  init_keccak256();
-  init_toPrefixedMessage();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/accounts/utils/signMessage.js
-async function signMessage({ message, privateKey }) {
-  return await sign({ hash: hashMessage(message), privateKey, to: "hex" });
-}
-var init_signMessage = __esm(() => {
-  init_hashMessage();
-  init_sign();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/constants/unit.js
-var gweiUnits;
-var init_unit = __esm(() => {
-  gweiUnits = {
-    ether: -9,
-    wei: 9
-  };
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/unit/formatUnits.js
-function formatUnits(value, decimals) {
-  let display = value.toString();
-  const negative = display.startsWith("-");
-  if (negative)
-    display = display.slice(1);
-  display = display.padStart(decimals, "0");
-  let [integer, fraction] = [
-    display.slice(0, display.length - decimals),
-    display.slice(display.length - decimals)
-  ];
-  fraction = fraction.replace(/(0+)$/, "");
-  return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
-}
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/unit/formatGwei.js
-function formatGwei(wei, unit = "wei") {
-  return formatUnits(wei, gweiUnits[unit]);
-}
-var init_formatGwei = __esm(() => {
-  init_unit();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/errors/transaction.js
-function prettyPrint(args) {
-  const entries = Object.entries(args).map(([key, value]) => {
-    if (value === undefined || value === false)
-      return null;
-    return [key, value];
-  }).filter(Boolean);
-  const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
-  return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join(`
-`);
-}
-var InvalidLegacyVError, InvalidSerializableTransactionError, InvalidStorageKeySizeError;
-var init_transaction = __esm(() => {
-  init_base();
-  InvalidLegacyVError = class InvalidLegacyVError extends BaseError {
-    constructor({ v }) {
-      super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
-        name: "InvalidLegacyVError"
-      });
-    }
-  };
-  InvalidSerializableTransactionError = class InvalidSerializableTransactionError extends BaseError {
-    constructor({ transaction }) {
-      super("Cannot infer a transaction type from provided transaction.", {
-        metaMessages: [
-          "Provided Transaction:",
-          "{",
-          prettyPrint(transaction),
-          "}",
-          "",
-          "To infer the type, either provide:",
-          "- a `type` to the Transaction, or",
-          "- an EIP-1559 Transaction with `maxFeePerGas`, or",
-          "- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
-          "- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
-          "- an EIP-7702 Transaction with `authorizationList`, or",
-          "- a Legacy Transaction with `gasPrice`"
-        ],
-        name: "InvalidSerializableTransactionError"
-      });
-    }
-  };
-  InvalidStorageKeySizeError = class InvalidStorageKeySizeError extends BaseError {
-    constructor({ storageKey }) {
-      super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
-    }
-  };
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/authorization/serializeAuthorizationList.js
-function serializeAuthorizationList(authorizationList) {
-  if (!authorizationList || authorizationList.length === 0)
-    return [];
-  const serializedAuthorizationList = [];
-  for (const authorization of authorizationList) {
-    const { chainId, nonce, ...signature } = authorization;
-    const contractAddress = authorization.address;
-    serializedAuthorizationList.push([
-      chainId ? toHex(chainId) : "0x",
-      contractAddress,
-      nonce ? toHex(nonce) : "0x",
-      ...toYParitySignatureArray({}, signature)
-    ]);
-  }
-  return serializedAuthorizationList;
-}
-var init_serializeAuthorizationList = __esm(() => {
-  init_toHex();
-  init_serializeTransaction();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/blob/blobsToCommitments.js
-function blobsToCommitments(parameters) {
-  const { kzg } = parameters;
-  const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
-  const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes2(x)) : parameters.blobs;
-  const commitments = [];
-  for (const blob of blobs)
-    commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)));
-  return to === "bytes" ? commitments : commitments.map((x) => bytesToHex2(x));
-}
-var init_blobsToCommitments = __esm(() => {
-  init_toBytes();
-  init_toHex();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/blob/blobsToProofs.js
-function blobsToProofs(parameters) {
-  const { kzg } = parameters;
-  const to = parameters.to ?? (typeof parameters.blobs[0] === "string" ? "hex" : "bytes");
-  const blobs = typeof parameters.blobs[0] === "string" ? parameters.blobs.map((x) => hexToBytes2(x)) : parameters.blobs;
-  const commitments = typeof parameters.commitments[0] === "string" ? parameters.commitments.map((x) => hexToBytes2(x)) : parameters.commitments;
-  const proofs = [];
-  for (let i = 0;i < blobs.length; i++) {
-    const blob = blobs[i];
-    const commitment = commitments[i];
-    proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)));
-  }
-  return to === "bytes" ? proofs : proofs.map((x) => bytesToHex2(x));
-}
-var init_blobsToProofs = __esm(() => {
-  init_toBytes();
-  init_toHex();
-});
-
-// ../../node_modules/.bun/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha256.js
-var sha2562;
-var init_sha256 = __esm(() => {
-  init_sha2();
-  sha2562 = sha256;
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/hash/sha256.js
-function sha2563(value, to_) {
-  const to = to_ || "hex";
-  const bytes = sha2562(isHex(value, { strict: false }) ? toBytes2(value) : value);
-  if (to === "bytes")
-    return bytes;
-  return toHex(bytes);
-}
-var init_sha2562 = __esm(() => {
-  init_sha256();
-  init_toBytes();
-  init_toHex();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
-function commitmentToVersionedHash(parameters) {
-  const { commitment, version: version2 = 1 } = parameters;
-  const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
-  const versionedHash = sha2563(commitment, "bytes");
-  versionedHash.set([version2], 0);
-  return to === "bytes" ? versionedHash : bytesToHex2(versionedHash);
-}
-var init_commitmentToVersionedHash = __esm(() => {
-  init_toHex();
-  init_sha2562();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
-function commitmentsToVersionedHashes(parameters) {
-  const { commitments, version: version2 } = parameters;
-  const to = parameters.to ?? (typeof commitments[0] === "string" ? "hex" : "bytes");
-  const hashes = [];
-  for (const commitment of commitments) {
-    hashes.push(commitmentToVersionedHash({
-      commitment,
-      to,
-      version: version2
-    }));
-  }
-  return hashes;
-}
-var init_commitmentsToVersionedHashes = __esm(() => {
-  init_commitmentToVersionedHash();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/constants/blob.js
-var blobsPerTransaction = 6, bytesPerFieldElement = 32, fieldElementsPerBlob = 4096, bytesPerBlob, maxBytesPerTransaction;
-var init_blob = __esm(() => {
-  bytesPerBlob = bytesPerFieldElement * fieldElementsPerBlob;
-  maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction - 1 - 1 * fieldElementsPerBlob * blobsPerTransaction;
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/constants/kzg.js
-var versionedHashVersionKzg = 1;
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/errors/blob.js
-var BlobSizeTooLargeError, EmptyBlobError, InvalidVersionedHashSizeError, InvalidVersionedHashVersionError;
-var init_blob2 = __esm(() => {
-  init_base();
-  BlobSizeTooLargeError = class BlobSizeTooLargeError extends BaseError {
-    constructor({ maxSize, size: size2 }) {
-      super("Blob size is too large.", {
-        metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size2} bytes`],
-        name: "BlobSizeTooLargeError"
-      });
-    }
-  };
-  EmptyBlobError = class EmptyBlobError extends BaseError {
-    constructor() {
-      super("Blob data must not be empty.", { name: "EmptyBlobError" });
-    }
-  };
-  InvalidVersionedHashSizeError = class InvalidVersionedHashSizeError extends BaseError {
-    constructor({ hash, size: size2 }) {
-      super(`Versioned hash "${hash}" size is invalid.`, {
-        metaMessages: ["Expected: 32", `Received: ${size2}`],
-        name: "InvalidVersionedHashSizeError"
-      });
-    }
-  };
-  InvalidVersionedHashVersionError = class InvalidVersionedHashVersionError extends BaseError {
-    constructor({ hash, version: version2 }) {
-      super(`Versioned hash "${hash}" version is invalid.`, {
-        metaMessages: [
-          `Expected: ${versionedHashVersionKzg}`,
-          `Received: ${version2}`
-        ],
-        name: "InvalidVersionedHashVersionError"
-      });
-    }
-  };
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/blob/toBlobs.js
-function toBlobs(parameters) {
-  const to = parameters.to ?? (typeof parameters.data === "string" ? "hex" : "bytes");
-  const data = typeof parameters.data === "string" ? hexToBytes2(parameters.data) : parameters.data;
-  const size_ = size(data);
-  if (!size_)
-    throw new EmptyBlobError;
-  if (size_ > maxBytesPerTransaction)
-    throw new BlobSizeTooLargeError({
-      maxSize: maxBytesPerTransaction,
-      size: size_
-    });
-  const blobs = [];
-  let active = true;
-  let position = 0;
-  while (active) {
-    const blob = createCursor(new Uint8Array(bytesPerBlob));
-    let size2 = 0;
-    while (size2 < fieldElementsPerBlob) {
-      const bytes = data.slice(position, position + (bytesPerFieldElement - 1));
-      blob.pushByte(0);
-      blob.pushBytes(bytes);
-      if (bytes.length < 31) {
-        blob.pushByte(128);
-        active = false;
-        break;
-      }
-      size2++;
-      position += 31;
-    }
-    blobs.push(blob);
-  }
-  return to === "bytes" ? blobs.map((x) => x.bytes) : blobs.map((x) => bytesToHex2(x.bytes));
-}
-var init_toBlobs = __esm(() => {
-  init_blob();
-  init_blob2();
-  init_cursor2();
-  init_size();
-  init_toBytes();
-  init_toHex();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/blob/toBlobSidecars.js
-function toBlobSidecars(parameters) {
-  const { data, kzg, to } = parameters;
-  const blobs = parameters.blobs ?? toBlobs({ data, to });
-  const commitments = parameters.commitments ?? blobsToCommitments({ blobs, kzg, to });
-  const proofs = parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg, to });
-  const sidecars = [];
-  for (let i = 0;i < blobs.length; i++)
-    sidecars.push({
-      blob: blobs[i],
-      commitment: commitments[i],
-      proof: proofs[i]
-    });
-  return sidecars;
-}
-var init_toBlobSidecars = __esm(() => {
-  init_blobsToCommitments();
-  init_blobsToProofs();
-  init_toBlobs();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/constants/number.js
-var maxInt8, maxInt16, maxInt24, maxInt32, maxInt40, maxInt48, maxInt56, maxInt64, maxInt72, maxInt80, maxInt88, maxInt96, maxInt104, maxInt112, maxInt120, maxInt128, maxInt136, maxInt144, maxInt152, maxInt160, maxInt168, maxInt176, maxInt184, maxInt192, maxInt200, maxInt208, maxInt216, maxInt224, maxInt232, maxInt240, maxInt248, maxInt256, minInt8, minInt16, minInt24, minInt32, minInt40, minInt48, minInt56, minInt64, minInt72, minInt80, minInt88, minInt96, minInt104, minInt112, minInt120, minInt128, minInt136, minInt144, minInt152, minInt160, minInt168, minInt176, minInt184, minInt192, minInt200, minInt208, minInt216, minInt224, minInt232, minInt240, minInt248, minInt256, maxUint8, maxUint16, maxUint24, maxUint32, maxUint40, maxUint48, maxUint56, maxUint64, maxUint72, maxUint80, maxUint88, maxUint96, maxUint104, maxUint112, maxUint120, maxUint128, maxUint136, maxUint144, maxUint152, maxUint160, maxUint168, maxUint176, maxUint184, maxUint192, maxUint200, maxUint208, maxUint216, maxUint224, maxUint232, maxUint240, maxUint248, maxUint256;
-var init_number = __esm(() => {
-  maxInt8 = 2n ** (8n - 1n) - 1n;
-  maxInt16 = 2n ** (16n - 1n) - 1n;
-  maxInt24 = 2n ** (24n - 1n) - 1n;
-  maxInt32 = 2n ** (32n - 1n) - 1n;
-  maxInt40 = 2n ** (40n - 1n) - 1n;
-  maxInt48 = 2n ** (48n - 1n) - 1n;
-  maxInt56 = 2n ** (56n - 1n) - 1n;
-  maxInt64 = 2n ** (64n - 1n) - 1n;
-  maxInt72 = 2n ** (72n - 1n) - 1n;
-  maxInt80 = 2n ** (80n - 1n) - 1n;
-  maxInt88 = 2n ** (88n - 1n) - 1n;
-  maxInt96 = 2n ** (96n - 1n) - 1n;
-  maxInt104 = 2n ** (104n - 1n) - 1n;
-  maxInt112 = 2n ** (112n - 1n) - 1n;
-  maxInt120 = 2n ** (120n - 1n) - 1n;
-  maxInt128 = 2n ** (128n - 1n) - 1n;
-  maxInt136 = 2n ** (136n - 1n) - 1n;
-  maxInt144 = 2n ** (144n - 1n) - 1n;
-  maxInt152 = 2n ** (152n - 1n) - 1n;
-  maxInt160 = 2n ** (160n - 1n) - 1n;
-  maxInt168 = 2n ** (168n - 1n) - 1n;
-  maxInt176 = 2n ** (176n - 1n) - 1n;
-  maxInt184 = 2n ** (184n - 1n) - 1n;
-  maxInt192 = 2n ** (192n - 1n) - 1n;
-  maxInt200 = 2n ** (200n - 1n) - 1n;
-  maxInt208 = 2n ** (208n - 1n) - 1n;
-  maxInt216 = 2n ** (216n - 1n) - 1n;
-  maxInt224 = 2n ** (224n - 1n) - 1n;
-  maxInt232 = 2n ** (232n - 1n) - 1n;
-  maxInt240 = 2n ** (240n - 1n) - 1n;
-  maxInt248 = 2n ** (248n - 1n) - 1n;
-  maxInt256 = 2n ** (256n - 1n) - 1n;
-  minInt8 = -(2n ** (8n - 1n));
-  minInt16 = -(2n ** (16n - 1n));
-  minInt24 = -(2n ** (24n - 1n));
-  minInt32 = -(2n ** (32n - 1n));
-  minInt40 = -(2n ** (40n - 1n));
-  minInt48 = -(2n ** (48n - 1n));
-  minInt56 = -(2n ** (56n - 1n));
-  minInt64 = -(2n ** (64n - 1n));
-  minInt72 = -(2n ** (72n - 1n));
-  minInt80 = -(2n ** (80n - 1n));
-  minInt88 = -(2n ** (88n - 1n));
-  minInt96 = -(2n ** (96n - 1n));
-  minInt104 = -(2n ** (104n - 1n));
-  minInt112 = -(2n ** (112n - 1n));
-  minInt120 = -(2n ** (120n - 1n));
-  minInt128 = -(2n ** (128n - 1n));
-  minInt136 = -(2n ** (136n - 1n));
-  minInt144 = -(2n ** (144n - 1n));
-  minInt152 = -(2n ** (152n - 1n));
-  minInt160 = -(2n ** (160n - 1n));
-  minInt168 = -(2n ** (168n - 1n));
-  minInt176 = -(2n ** (176n - 1n));
-  minInt184 = -(2n ** (184n - 1n));
-  minInt192 = -(2n ** (192n - 1n));
-  minInt200 = -(2n ** (200n - 1n));
-  minInt208 = -(2n ** (208n - 1n));
-  minInt216 = -(2n ** (216n - 1n));
-  minInt224 = -(2n ** (224n - 1n));
-  minInt232 = -(2n ** (232n - 1n));
-  minInt240 = -(2n ** (240n - 1n));
-  minInt248 = -(2n ** (248n - 1n));
-  minInt256 = -(2n ** (256n - 1n));
-  maxUint8 = 2n ** 8n - 1n;
-  maxUint16 = 2n ** 16n - 1n;
-  maxUint24 = 2n ** 24n - 1n;
-  maxUint32 = 2n ** 32n - 1n;
-  maxUint40 = 2n ** 40n - 1n;
-  maxUint48 = 2n ** 48n - 1n;
-  maxUint56 = 2n ** 56n - 1n;
-  maxUint64 = 2n ** 64n - 1n;
-  maxUint72 = 2n ** 72n - 1n;
-  maxUint80 = 2n ** 80n - 1n;
-  maxUint88 = 2n ** 88n - 1n;
-  maxUint96 = 2n ** 96n - 1n;
-  maxUint104 = 2n ** 104n - 1n;
-  maxUint112 = 2n ** 112n - 1n;
-  maxUint120 = 2n ** 120n - 1n;
-  maxUint128 = 2n ** 128n - 1n;
-  maxUint136 = 2n ** 136n - 1n;
-  maxUint144 = 2n ** 144n - 1n;
-  maxUint152 = 2n ** 152n - 1n;
-  maxUint160 = 2n ** 160n - 1n;
-  maxUint168 = 2n ** 168n - 1n;
-  maxUint176 = 2n ** 176n - 1n;
-  maxUint184 = 2n ** 184n - 1n;
-  maxUint192 = 2n ** 192n - 1n;
-  maxUint200 = 2n ** 200n - 1n;
-  maxUint208 = 2n ** 208n - 1n;
-  maxUint216 = 2n ** 216n - 1n;
-  maxUint224 = 2n ** 224n - 1n;
-  maxUint232 = 2n ** 232n - 1n;
-  maxUint240 = 2n ** 240n - 1n;
-  maxUint248 = 2n ** 248n - 1n;
-  maxUint256 = 2n ** 256n - 1n;
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/errors/chain.js
-var InvalidChainIdError;
-var init_chain = __esm(() => {
-  init_base();
-  InvalidChainIdError = class InvalidChainIdError extends BaseError {
-    constructor({ chainId }) {
-      super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
-    }
-  };
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/errors/node.js
-var ExecutionRevertedError, FeeCapTooHighError, FeeCapTooLowError, NonceTooHighError, NonceTooLowError, NonceMaxValueError, InsufficientFundsError, IntrinsicGasTooHighError, IntrinsicGasTooLowError, TransactionTypeNotSupportedError, TipAboveFeeCapError;
-var init_node = __esm(() => {
-  init_formatGwei();
-  init_base();
-  ExecutionRevertedError = class ExecutionRevertedError extends BaseError {
-    constructor({ cause, message } = {}) {
-      const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
-      super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
-        cause,
-        name: "ExecutionRevertedError"
-      });
-    }
-  };
-  Object.defineProperty(ExecutionRevertedError, "code", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: 3
-  });
-  Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: /execution reverted|gas required exceeds allowance/
-  });
-  FeeCapTooHighError = class FeeCapTooHighError extends BaseError {
-    constructor({ cause, maxFeePerGas } = {}) {
-      super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
-        cause,
-        name: "FeeCapTooHighError"
-      });
-    }
-  };
-  Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
-  });
-  FeeCapTooLowError = class FeeCapTooLowError extends BaseError {
-    constructor({ cause, maxFeePerGas } = {}) {
-      super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
-        cause,
-        name: "FeeCapTooLowError"
-      });
-    }
-  };
-  Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
-  });
-  NonceTooHighError = class NonceTooHighError extends BaseError {
-    constructor({ cause, nonce } = {}) {
-      super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, { cause, name: "NonceTooHighError" });
-    }
-  };
-  Object.defineProperty(NonceTooHighError, "nodeMessage", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: /nonce too high/
-  });
-  NonceTooLowError = class NonceTooLowError extends BaseError {
-    constructor({ cause, nonce } = {}) {
-      super([
-        `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
-        "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
-      ].join(`
-`), { cause, name: "NonceTooLowError" });
-    }
-  };
-  Object.defineProperty(NonceTooLowError, "nodeMessage", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: /nonce too low|transaction already imported|already known/
-  });
-  NonceMaxValueError = class NonceMaxValueError extends BaseError {
-    constructor({ cause, nonce } = {}) {
-      super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, { cause, name: "NonceMaxValueError" });
-    }
-  };
-  Object.defineProperty(NonceMaxValueError, "nodeMessage", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: /nonce has max value/
-  });
-  InsufficientFundsError = class InsufficientFundsError extends BaseError {
-    constructor({ cause } = {}) {
-      super([
-        "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
-      ].join(`
-`), {
-        cause,
-        metaMessages: [
-          "This error could arise when the account does not have enough funds to:",
-          " - pay for the total gas fee,",
-          " - pay for the value to send.",
-          " ",
-          "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
-          " - `gas` is the amount of gas needed for transaction to execute,",
-          " - `gas fee` is the gas fee,",
-          " - `value` is the amount of ether to send to the recipient."
-        ],
-        name: "InsufficientFundsError"
-      });
-    }
-  };
-  Object.defineProperty(InsufficientFundsError, "nodeMessage", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: /insufficient funds|exceeds transaction sender account balance/
-  });
-  IntrinsicGasTooHighError = class IntrinsicGasTooHighError extends BaseError {
-    constructor({ cause, gas } = {}) {
-      super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
-        cause,
-        name: "IntrinsicGasTooHighError"
-      });
-    }
-  };
-  Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: /intrinsic gas too high|gas limit reached/
-  });
-  IntrinsicGasTooLowError = class IntrinsicGasTooLowError extends BaseError {
-    constructor({ cause, gas } = {}) {
-      super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
-        cause,
-        name: "IntrinsicGasTooLowError"
-      });
-    }
-  };
-  Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: /intrinsic gas too low/
-  });
-  TransactionTypeNotSupportedError = class TransactionTypeNotSupportedError extends BaseError {
-    constructor({ cause }) {
-      super("The transaction type is not supported for this chain.", {
-        cause,
-        name: "TransactionTypeNotSupportedError"
-      });
-    }
-  };
-  Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: /transaction type not valid/
-  });
-  TipAboveFeeCapError = class TipAboveFeeCapError extends BaseError {
-    constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
-      super([
-        `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
-      ].join(`
-`), {
-        cause,
-        name: "TipAboveFeeCapError"
-      });
-    }
-  };
-  Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
-  });
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/data/slice.js
-function slice(value, start, end, { strict } = {}) {
-  if (isHex(value, { strict: false }))
-    return sliceHex(value, start, end, {
-      strict
-    });
-  return sliceBytes(value, start, end, {
-    strict
-  });
-}
-function assertStartOffset(value, start) {
-  if (typeof start === "number" && start > 0 && start > size(value) - 1)
-    throw new SliceOffsetOutOfBoundsError({
-      offset: start,
-      position: "start",
-      size: size(value)
-    });
-}
-function assertEndOffset(value, start, end) {
-  if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
-    throw new SliceOffsetOutOfBoundsError({
-      offset: end,
-      position: "end",
-      size: size(value)
-    });
-  }
-}
-function sliceBytes(value_, start, end, { strict } = {}) {
-  assertStartOffset(value_, start);
-  const value = value_.slice(start, end);
-  if (strict)
-    assertEndOffset(value, start, end);
-  return value;
-}
-function sliceHex(value_, start, end, { strict } = {}) {
-  assertStartOffset(value_, start);
-  const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
-  if (strict)
-    assertEndOffset(value, start, end);
-  return value;
-}
-var init_slice = __esm(() => {
-  init_data();
-  init_size();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/transaction/assertTransaction.js
-function assertTransactionEIP7702(transaction) {
-  const { authorizationList } = transaction;
-  if (authorizationList) {
-    for (const authorization of authorizationList) {
-      const { chainId } = authorization;
-      const address = authorization.address;
-      if (!isAddress(address))
-        throw new InvalidAddressError({ address });
-      if (chainId < 0)
-        throw new InvalidChainIdError({ chainId });
-    }
-  }
-  assertTransactionEIP1559(transaction);
-}
-function assertTransactionEIP4844(transaction) {
-  const { blobVersionedHashes } = transaction;
-  if (blobVersionedHashes) {
-    if (blobVersionedHashes.length === 0)
-      throw new EmptyBlobError;
-    for (const hash of blobVersionedHashes) {
-      const size_ = size(hash);
-      const version2 = hexToNumber2(slice(hash, 0, 1));
-      if (size_ !== 32)
-        throw new InvalidVersionedHashSizeError({ hash, size: size_ });
-      if (version2 !== versionedHashVersionKzg)
-        throw new InvalidVersionedHashVersionError({
-          hash,
-          version: version2
-        });
-    }
-  }
-  assertTransactionEIP1559(transaction);
-}
-function assertTransactionEIP1559(transaction) {
-  const { chainId, maxPriorityFeePerGas, maxFeePerGas, to } = transaction;
-  if (chainId <= 0)
-    throw new InvalidChainIdError({ chainId });
-  if (to && !isAddress(to))
-    throw new InvalidAddressError({ address: to });
-  if (maxFeePerGas && maxFeePerGas > maxUint256)
-    throw new FeeCapTooHighError({ maxFeePerGas });
-  if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
-    throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
-}
-function assertTransactionEIP2930(transaction) {
-  const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
-  if (chainId <= 0)
-    throw new InvalidChainIdError({ chainId });
-  if (to && !isAddress(to))
-    throw new InvalidAddressError({ address: to });
-  if (maxPriorityFeePerGas || maxFeePerGas)
-    throw new BaseError("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
-  if (gasPrice && gasPrice > maxUint256)
-    throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
-}
-function assertTransactionLegacy(transaction) {
-  const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
-  if (to && !isAddress(to))
-    throw new InvalidAddressError({ address: to });
-  if (typeof chainId !== "undefined" && chainId <= 0)
-    throw new InvalidChainIdError({ chainId });
-  if (maxPriorityFeePerGas || maxFeePerGas)
-    throw new BaseError("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
-  if (gasPrice && gasPrice > maxUint256)
-    throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
-}
-var init_assertTransaction = __esm(() => {
-  init_number();
-  init_address();
-  init_base();
-  init_blob2();
-  init_chain();
-  init_node();
-  init_isAddress();
-  init_size();
-  init_slice();
-  init_fromHex();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/transaction/getTransactionType.js
-function getTransactionType(transaction) {
-  if (transaction.type)
-    return transaction.type;
-  if (typeof transaction.authorizationList !== "undefined")
-    return "eip7702";
-  if (typeof transaction.blobs !== "undefined" || typeof transaction.blobVersionedHashes !== "undefined" || typeof transaction.maxFeePerBlobGas !== "undefined" || typeof transaction.sidecars !== "undefined")
-    return "eip4844";
-  if (typeof transaction.maxFeePerGas !== "undefined" || typeof transaction.maxPriorityFeePerGas !== "undefined") {
-    return "eip1559";
-  }
-  if (typeof transaction.gasPrice !== "undefined") {
-    if (typeof transaction.accessList !== "undefined")
-      return "eip2930";
-    return "legacy";
-  }
-  throw new InvalidSerializableTransactionError({ transaction });
-}
-var init_getTransactionType = __esm(() => {
-  init_transaction();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/transaction/serializeAccessList.js
-function serializeAccessList(accessList) {
-  if (!accessList || accessList.length === 0)
-    return [];
-  const serializedAccessList = [];
-  for (let i = 0;i < accessList.length; i++) {
-    const { address, storageKeys } = accessList[i];
-    for (let j = 0;j < storageKeys.length; j++) {
-      if (storageKeys[j].length - 2 !== 64) {
-        throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
-      }
-    }
-    if (!isAddress(address, { strict: false })) {
-      throw new InvalidAddressError({ address });
-    }
-    serializedAccessList.push([address, storageKeys]);
-  }
-  return serializedAccessList;
-}
-var init_serializeAccessList = __esm(() => {
-  init_address();
-  init_transaction();
-  init_isAddress();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/transaction/serializeTransaction.js
-function serializeTransaction(transaction, signature) {
-  const type = getTransactionType(transaction);
-  if (type === "eip1559")
-    return serializeTransactionEIP1559(transaction, signature);
-  if (type === "eip2930")
-    return serializeTransactionEIP2930(transaction, signature);
-  if (type === "eip4844")
-    return serializeTransactionEIP4844(transaction, signature);
-  if (type === "eip7702")
-    return serializeTransactionEIP7702(transaction, signature);
-  return serializeTransactionLegacy(transaction, signature);
-}
-function serializeTransactionEIP7702(transaction, signature) {
-  const { authorizationList, chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
-  assertTransactionEIP7702(transaction);
-  const serializedAccessList = serializeAccessList(accessList);
-  const serializedAuthorizationList = serializeAuthorizationList(authorizationList);
-  return concatHex([
-    "0x04",
-    toRlp([
-      numberToHex(chainId),
-      nonce ? numberToHex(nonce) : "0x",
-      maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : "0x",
-      maxFeePerGas ? numberToHex(maxFeePerGas) : "0x",
-      gas ? numberToHex(gas) : "0x",
-      to ?? "0x",
-      value ? numberToHex(value) : "0x",
-      data ?? "0x",
-      serializedAccessList,
-      serializedAuthorizationList,
-      ...toYParitySignatureArray(transaction, signature)
-    ])
-  ]);
-}
-function serializeTransactionEIP4844(transaction, signature) {
-  const { chainId, gas, nonce, to, value, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
-  assertTransactionEIP4844(transaction);
-  let blobVersionedHashes = transaction.blobVersionedHashes;
-  let sidecars = transaction.sidecars;
-  if (transaction.blobs && (typeof blobVersionedHashes === "undefined" || typeof sidecars === "undefined")) {
-    const blobs2 = typeof transaction.blobs[0] === "string" ? transaction.blobs : transaction.blobs.map((x) => bytesToHex2(x));
-    const kzg = transaction.kzg;
-    const commitments2 = blobsToCommitments({
-      blobs: blobs2,
-      kzg
-    });
-    if (typeof blobVersionedHashes === "undefined")
-      blobVersionedHashes = commitmentsToVersionedHashes({
-        commitments: commitments2
-      });
-    if (typeof sidecars === "undefined") {
-      const proofs2 = blobsToProofs({ blobs: blobs2, commitments: commitments2, kzg });
-      sidecars = toBlobSidecars({ blobs: blobs2, commitments: commitments2, proofs: proofs2 });
-    }
-  }
-  const serializedAccessList = serializeAccessList(accessList);
-  const serializedTransaction = [
-    numberToHex(chainId),
-    nonce ? numberToHex(nonce) : "0x",
-    maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : "0x",
-    maxFeePerGas ? numberToHex(maxFeePerGas) : "0x",
-    gas ? numberToHex(gas) : "0x",
-    to ?? "0x",
-    value ? numberToHex(value) : "0x",
-    data ?? "0x",
-    serializedAccessList,
-    maxFeePerBlobGas ? numberToHex(maxFeePerBlobGas) : "0x",
-    blobVersionedHashes ?? [],
-    ...toYParitySignatureArray(transaction, signature)
-  ];
-  const blobs = [];
-  const commitments = [];
-  const proofs = [];
-  if (sidecars)
-    for (let i = 0;i < sidecars.length; i++) {
-      const { blob, commitment, proof } = sidecars[i];
-      blobs.push(blob);
-      commitments.push(commitment);
-      proofs.push(proof);
-    }
-  return concatHex([
-    "0x03",
-    sidecars ? toRlp([serializedTransaction, blobs, commitments, proofs]) : toRlp(serializedTransaction)
-  ]);
-}
-function serializeTransactionEIP1559(transaction, signature) {
-  const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data } = transaction;
-  assertTransactionEIP1559(transaction);
-  const serializedAccessList = serializeAccessList(accessList);
-  const serializedTransaction = [
-    numberToHex(chainId),
-    nonce ? numberToHex(nonce) : "0x",
-    maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : "0x",
-    maxFeePerGas ? numberToHex(maxFeePerGas) : "0x",
-    gas ? numberToHex(gas) : "0x",
-    to ?? "0x",
-    value ? numberToHex(value) : "0x",
-    data ?? "0x",
-    serializedAccessList,
-    ...toYParitySignatureArray(transaction, signature)
-  ];
-  return concatHex([
-    "0x02",
-    toRlp(serializedTransaction)
-  ]);
-}
-function serializeTransactionEIP2930(transaction, signature) {
-  const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
-  assertTransactionEIP2930(transaction);
-  const serializedAccessList = serializeAccessList(accessList);
-  const serializedTransaction = [
-    numberToHex(chainId),
-    nonce ? numberToHex(nonce) : "0x",
-    gasPrice ? numberToHex(gasPrice) : "0x",
-    gas ? numberToHex(gas) : "0x",
-    to ?? "0x",
-    value ? numberToHex(value) : "0x",
-    data ?? "0x",
-    serializedAccessList,
-    ...toYParitySignatureArray(transaction, signature)
-  ];
-  return concatHex([
-    "0x01",
-    toRlp(serializedTransaction)
-  ]);
-}
-function serializeTransactionLegacy(transaction, signature) {
-  const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
-  assertTransactionLegacy(transaction);
-  let serializedTransaction = [
-    nonce ? numberToHex(nonce) : "0x",
-    gasPrice ? numberToHex(gasPrice) : "0x",
-    gas ? numberToHex(gas) : "0x",
-    to ?? "0x",
-    value ? numberToHex(value) : "0x",
-    data ?? "0x"
-  ];
-  if (signature) {
-    const v = (() => {
-      if (signature.v >= 35n) {
-        const inferredChainId = (signature.v - 35n) / 2n;
-        if (inferredChainId > 0)
-          return signature.v;
-        return 27n + (signature.v === 35n ? 0n : 1n);
-      }
-      if (chainId > 0)
-        return BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
-      const v2 = 27n + (signature.v === 27n ? 0n : 1n);
-      if (signature.v !== v2)
-        throw new InvalidLegacyVError({ v: signature.v });
-      return v2;
-    })();
-    const r = trim(signature.r);
-    const s = trim(signature.s);
-    serializedTransaction = [
-      ...serializedTransaction,
-      numberToHex(v),
-      r === "0x00" ? "0x" : r,
-      s === "0x00" ? "0x" : s
-    ];
-  } else if (chainId > 0) {
-    serializedTransaction = [
-      ...serializedTransaction,
-      numberToHex(chainId),
-      "0x",
-      "0x"
-    ];
-  }
-  return toRlp(serializedTransaction);
-}
-function toYParitySignatureArray(transaction, signature_) {
-  const signature = signature_ ?? transaction;
-  const { v, yParity } = signature;
-  if (typeof signature.r === "undefined")
-    return [];
-  if (typeof signature.s === "undefined")
-    return [];
-  if (typeof v === "undefined" && typeof yParity === "undefined")
-    return [];
-  const r = trim(signature.r);
-  const s = trim(signature.s);
-  const yParity_ = (() => {
-    if (typeof yParity === "number")
-      return yParity ? numberToHex(1) : "0x";
-    if (v === 0n)
-      return "0x";
-    if (v === 1n)
-      return numberToHex(1);
-    return v === 27n ? "0x" : numberToHex(1);
-  })();
-  return [yParity_, r === "0x00" ? "0x" : r, s === "0x00" ? "0x" : s];
-}
-var init_serializeTransaction = __esm(() => {
-  init_transaction();
-  init_serializeAuthorizationList();
-  init_blobsToCommitments();
-  init_blobsToProofs();
-  init_commitmentsToVersionedHashes();
-  init_toBlobSidecars();
-  init_toHex();
-  init_toRlp();
-  init_assertTransaction();
-  init_getTransactionType();
-  init_serializeAccessList();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/accounts/utils/signTransaction.js
-async function signTransaction(parameters) {
-  const { privateKey, transaction, serializer = serializeTransaction } = parameters;
-  const signableTransaction = (() => {
-    if (transaction.type === "eip4844")
-      return {
-        ...transaction,
-        sidecars: false
-      };
-    return transaction;
-  })();
-  const signature = await sign({
-    hash: keccak256(await serializer(signableTransaction)),
-    privateKey
-  });
-  return await serializer(transaction, signature);
-}
-var init_signTransaction = __esm(() => {
-  init_keccak256();
-  init_serializeTransaction();
-  init_sign();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/errors/abi.js
-var AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, BytesSizeMismatchError, InvalidAbiEncodingTypeError, InvalidArrayError;
-var init_abi = __esm(() => {
-  init_size();
-  init_base();
-  AbiEncodingArrayLengthMismatchError = class AbiEncodingArrayLengthMismatchError extends BaseError {
-    constructor({ expectedLength, givenLength, type }) {
-      super([
-        `ABI encoding array length mismatch for type ${type}.`,
-        `Expected length: ${expectedLength}`,
-        `Given length: ${givenLength}`
-      ].join(`
-`), { name: "AbiEncodingArrayLengthMismatchError" });
-    }
-  };
-  AbiEncodingBytesSizeMismatchError = class AbiEncodingBytesSizeMismatchError extends BaseError {
-    constructor({ expectedSize, value }) {
-      super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
-    }
-  };
-  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"
-      });
-    }
-  };
-  InvalidAbiEncodingTypeError = class InvalidAbiEncodingTypeError extends BaseError {
-    constructor(type, { docsPath }) {
-      super([
-        `Type "${type}" is not a valid encoding type.`,
-        "Please provide a valid ABI type."
-      ].join(`
-`), { docsPath, name: "InvalidAbiEncodingType" });
-    }
-  };
-  InvalidArrayError = class InvalidArrayError extends BaseError {
-    constructor(value) {
-      super([`Value "${value}" is not a valid array.`].join(`
-`), {
-        name: "InvalidArrayError"
-      });
-    }
-  };
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/regex.js
-var bytesRegex, integerRegex;
-var init_regex = __esm(() => {
-  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/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
-function encodeAbiParameters(params, values) {
-  if (params.length !== values.length)
-    throw new AbiEncodingLengthMismatchError({
-      expectedLength: params.length,
-      givenLength: values.length
-    });
-  const preparedParams = prepareParams({
-    params,
-    values
-  });
-  const data = encodeParams(preparedParams);
-  if (data.length === 0)
-    return "0x";
-  return data;
-}
-function prepareParams({ params, values }) {
-  const preparedParams = [];
-  for (let i = 0;i < params.length; i++) {
-    preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
-  }
-  return preparedParams;
-}
-function prepareParam({ param, value }) {
-  const arrayComponents = getArrayComponents(param.type);
-  if (arrayComponents) {
-    const [length, type] = arrayComponents;
-    return encodeArray(value, { length, param: { ...param, type } });
-  }
-  if (param.type === "tuple") {
-    return encodeTuple(value, {
-      param
-    });
-  }
-  if (param.type === "address") {
-    return encodeAddress(value);
-  }
-  if (param.type === "bool") {
-    return encodeBool(value);
-  }
-  if (param.type.startsWith("uint") || param.type.startsWith("int")) {
-    const signed = param.type.startsWith("int");
-    const [, , size2 = "256"] = integerRegex.exec(param.type) ?? [];
-    return encodeNumber(value, {
-      signed,
-      size: Number(size2)
-    });
-  }
-  if (param.type.startsWith("bytes")) {
-    return encodeBytes(value, { param });
-  }
-  if (param.type === "string") {
-    return encodeString(value);
-  }
-  throw new InvalidAbiEncodingTypeError(param.type, {
-    docsPath: "/docs/contract/encodeAbiParameters"
-  });
-}
-function encodeParams(preparedParams) {
-  let staticSize = 0;
-  for (let i = 0;i < preparedParams.length; i++) {
-    const { dynamic, encoded } = preparedParams[i];
-    if (dynamic)
-      staticSize += 32;
-    else
-      staticSize += size(encoded);
-  }
-  const staticParams = [];
-  const dynamicParams = [];
-  let dynamicSize = 0;
-  for (let i = 0;i < preparedParams.length; i++) {
-    const { dynamic, encoded } = preparedParams[i];
-    if (dynamic) {
-      staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
-      dynamicParams.push(encoded);
-      dynamicSize += size(encoded);
-    } else {
-      staticParams.push(encoded);
-    }
-  }
-  return concat([...staticParams, ...dynamicParams]);
-}
-function encodeAddress(value) {
-  if (!isAddress(value))
-    throw new InvalidAddressError({ address: value });
-  return { dynamic: false, encoded: padHex(value.toLowerCase()) };
-}
-function encodeArray(value, { length, param }) {
-  const dynamic = length === null;
-  if (!Array.isArray(value))
-    throw new InvalidArrayError(value);
-  if (!dynamic && value.length !== length)
-    throw new AbiEncodingArrayLengthMismatchError({
-      expectedLength: length,
-      givenLength: value.length,
-      type: `${param.type}[${length}]`
-    });
-  let dynamicChild = false;
-  const preparedParams = [];
-  for (let i = 0;i < value.length; i++) {
-    const preparedParam = prepareParam({ param, value: value[i] });
-    if (preparedParam.dynamic)
-      dynamicChild = true;
-    preparedParams.push(preparedParam);
-  }
-  if (dynamic || dynamicChild) {
-    const data = encodeParams(preparedParams);
-    if (dynamic) {
-      const length2 = numberToHex(preparedParams.length, { size: 32 });
-      return {
-        dynamic: true,
-        encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
-      };
-    }
-    if (dynamicChild)
-      return { dynamic: true, encoded: data };
-  }
-  return {
-    dynamic: false,
-    encoded: concat(preparedParams.map(({ encoded }) => encoded))
-  };
-}
-function encodeBytes(value, { param }) {
-  const [, paramSize] = param.type.split("bytes");
-  const bytesSize = size(value);
-  if (!paramSize) {
-    let value_ = value;
-    if (bytesSize % 32 !== 0)
-      value_ = padHex(value_, {
-        dir: "right",
-        size: Math.ceil((value.length - 2) / 2 / 32) * 32
-      });
-    return {
-      dynamic: true,
-      encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
-    };
-  }
-  if (bytesSize !== Number.parseInt(paramSize, 10))
-    throw new AbiEncodingBytesSizeMismatchError({
-      expectedSize: Number.parseInt(paramSize, 10),
-      value
-    });
-  return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
-}
-function encodeBool(value) {
-  if (typeof value !== "boolean")
-    throw new BaseError(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
-  return { dynamic: false, encoded: padHex(boolToHex(value)) };
-}
-function encodeNumber(value, { signed, size: size2 = 256 }) {
-  if (typeof size2 === "number") {
-    const max = 2n ** (BigInt(size2) - (signed ? 1n : 0n)) - 1n;
-    const min = signed ? -max - 1n : 0n;
-    if (value > max || value < min)
-      throw new IntegerOutOfRangeError({
-        max: max.toString(),
-        min: min.toString(),
-        signed,
-        size: size2 / 8,
-        value: value.toString()
-      });
-  }
-  return {
-    dynamic: false,
-    encoded: numberToHex(value, {
-      size: 32,
-      signed
-    })
-  };
-}
-function encodeString(value) {
-  const hexValue = stringToHex(value);
-  const partsLength = Math.ceil(size(hexValue) / 32);
-  const parts = [];
-  for (let i = 0;i < partsLength; i++) {
-    parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
-      dir: "right"
-    }));
-  }
-  return {
-    dynamic: true,
-    encoded: concat([
-      padHex(numberToHex(size(hexValue), { size: 32 })),
-      ...parts
-    ])
-  };
-}
-function encodeTuple(value, { param }) {
-  let dynamic = false;
-  const preparedParams = [];
-  for (let i = 0;i < param.components.length; i++) {
-    const param_ = param.components[i];
-    const index = Array.isArray(value) ? i : param_.name;
-    const preparedParam = prepareParam({
-      param: param_,
-      value: value[index]
-    });
-    preparedParams.push(preparedParam);
-    if (preparedParam.dynamic)
-      dynamic = true;
-  }
-  return {
-    dynamic,
-    encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
-  };
-}
-function getArrayComponents(type) {
-  const matches = type.match(/^(.*)\[(\d+)?\]$/);
-  return matches ? [matches[2] ? Number(matches[2]) : null, matches[1]] : undefined;
-}
-var init_encodeAbiParameters = __esm(() => {
-  init_abi();
-  init_address();
-  init_base();
-  init_encoding();
-  init_isAddress();
-  init_pad();
-  init_size();
-  init_slice();
-  init_toHex();
-  init_regex();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/stringify.js
-var stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
-  const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
-  return typeof replacer === "function" ? replacer(key, value2) : value2;
-}, space);
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/errors/typedData.js
-var InvalidDomainError, InvalidPrimaryTypeError, InvalidStructTypeError;
-var init_typedData = __esm(() => {
-  init_base();
-  InvalidDomainError = class InvalidDomainError extends BaseError {
-    constructor({ domain }) {
-      super(`Invalid domain "${stringify(domain)}".`, {
-        metaMessages: ["Must be a valid EIP-712 domain."]
-      });
-    }
-  };
-  InvalidPrimaryTypeError = class InvalidPrimaryTypeError extends BaseError {
-    constructor({ primaryType, types }) {
-      super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
-        docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
-        metaMessages: ["Check that the primary type is a key in `types`."]
-      });
-    }
-  };
-  InvalidStructTypeError = class InvalidStructTypeError extends BaseError {
-    constructor({ type }) {
-      super(`Struct type "${type}" is invalid.`, {
-        metaMessages: ["Struct type must not be a Solidity type."],
-        name: "InvalidStructTypeError"
-      });
-    }
-  };
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/typedData.js
-function validateTypedData(parameters) {
-  const { domain, message, primaryType, types } = parameters;
-  const validateData = (struct, data) => {
-    for (const param of struct) {
-      const { name, type } = param;
-      const value = data[name];
-      const integerMatch = type.match(integerRegex);
-      if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
-        const [_type, base, size_] = integerMatch;
-        numberToHex(value, {
-          signed: base === "int",
-          size: Number.parseInt(size_, 10) / 8
-        });
-      }
-      if (type === "address" && typeof value === "string" && !isAddress(value))
-        throw new InvalidAddressError({ address: value });
-      const bytesMatch = type.match(bytesRegex);
-      if (bytesMatch) {
-        const [_type, size_] = bytesMatch;
-        if (size_ && size(value) !== Number.parseInt(size_, 10))
-          throw new BytesSizeMismatchError({
-            expectedSize: Number.parseInt(size_, 10),
-            givenSize: size(value)
-          });
-      }
-      const struct2 = types[type];
-      if (struct2) {
-        validateReference(type);
-        validateData(struct2, value);
-      }
-    }
-  };
-  if (types.EIP712Domain && domain) {
-    if (typeof domain !== "object")
-      throw new InvalidDomainError({ domain });
-    validateData(types.EIP712Domain, domain);
-  }
-  if (primaryType !== "EIP712Domain") {
-    if (types[primaryType])
-      validateData(types[primaryType], message);
-    else
-      throw new InvalidPrimaryTypeError({ primaryType, types });
-  }
-}
-function getTypesForEIP712Domain({ domain }) {
-  return [
-    typeof domain?.name === "string" && { name: "name", type: "string" },
-    domain?.version && { name: "version", type: "string" },
-    (typeof domain?.chainId === "number" || typeof domain?.chainId === "bigint") && {
-      name: "chainId",
-      type: "uint256"
-    },
-    domain?.verifyingContract && {
-      name: "verifyingContract",
-      type: "address"
-    },
-    domain?.salt && { name: "salt", type: "bytes32" }
-  ].filter(Boolean);
-}
-function validateReference(type) {
-  if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
-    throw new InvalidStructTypeError({ type });
-}
-var init_typedData2 = __esm(() => {
-  init_abi();
-  init_address();
-  init_typedData();
-  init_isAddress();
-  init_size();
-  init_toHex();
-  init_regex();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/utils/signature/hashTypedData.js
-function hashTypedData(parameters) {
-  const { domain = {}, message, primaryType } = parameters;
-  const types = {
-    EIP712Domain: getTypesForEIP712Domain({ domain }),
-    ...parameters.types
-  };
-  validateTypedData({
-    domain,
-    message,
-    primaryType,
-    types
-  });
-  const parts = ["0x1901"];
-  if (domain)
-    parts.push(hashDomain({
-      domain,
-      types
-    }));
-  if (primaryType !== "EIP712Domain")
-    parts.push(hashStruct({
-      data: message,
-      primaryType,
-      types
-    }));
-  return keccak256(concat(parts));
-}
-function hashDomain({ domain, types }) {
-  return hashStruct({
-    data: domain,
-    primaryType: "EIP712Domain",
-    types
-  });
-}
-function hashStruct({ data, primaryType, types }) {
-  const encoded = encodeData({
-    data,
-    primaryType,
-    types
-  });
-  return keccak256(encoded);
-}
-function encodeData({ data, primaryType, types }) {
-  const encodedTypes = [{ type: "bytes32" }];
-  const encodedValues = [hashType({ primaryType, types })];
-  for (const field of types[primaryType]) {
-    const [type, value] = encodeField({
-      types,
-      name: field.name,
-      type: field.type,
-      value: data[field.name]
-    });
-    encodedTypes.push(type);
-    encodedValues.push(value);
-  }
-  return encodeAbiParameters(encodedTypes, encodedValues);
-}
-function hashType({ primaryType, types }) {
-  const encodedHashType = toHex(encodeType({ primaryType, types }));
-  return keccak256(encodedHashType);
-}
-function encodeType({ primaryType, types }) {
-  let result = "";
-  const unsortedDeps = findTypeDependencies({ primaryType, types });
-  unsortedDeps.delete(primaryType);
-  const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
-  for (const type of deps) {
-    result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
-  }
-  return result;
-}
-function findTypeDependencies({ primaryType: primaryType_, types }, results = new Set) {
-  const match = primaryType_.match(/^\w*/u);
-  const primaryType = match?.[0];
-  if (results.has(primaryType) || types[primaryType] === undefined) {
-    return results;
-  }
-  results.add(primaryType);
-  for (const field of types[primaryType]) {
-    findTypeDependencies({ primaryType: field.type, types }, results);
-  }
-  return results;
-}
-function encodeField({ types, name, type, value }) {
-  if (types[type] !== undefined) {
-    return [
-      { type: "bytes32" },
-      keccak256(encodeData({ data: value, primaryType: type, types }))
-    ];
-  }
-  if (type === "bytes")
-    return [{ type: "bytes32" }, keccak256(value)];
-  if (type === "string")
-    return [{ type: "bytes32" }, keccak256(toHex(value))];
-  if (type.lastIndexOf("]") === type.length - 1) {
-    const parsedType = type.slice(0, type.lastIndexOf("["));
-    const typeValuePairs = value.map((item) => encodeField({
-      name,
-      type: parsedType,
-      types,
-      value: item
-    }));
-    return [
-      { type: "bytes32" },
-      keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v)))
-    ];
-  }
-  return [{ type }, value];
-}
-var init_hashTypedData = __esm(() => {
-  init_encodeAbiParameters();
-  init_toHex();
-  init_keccak256();
-  init_typedData2();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/accounts/utils/signTypedData.js
-async function signTypedData(parameters) {
-  const { privateKey, ...typedData } = parameters;
-  return await sign({
-    hash: hashTypedData(typedData),
-    privateKey,
-    to: "hex"
-  });
-}
-var init_signTypedData = __esm(() => {
-  init_hashTypedData();
-  init_sign();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/accounts/privateKeyToAccount.js
-function privateKeyToAccount(privateKey, options = {}) {
-  const { nonceManager } = options;
-  const publicKey = toHex(secp256k1.getPublicKey(privateKey.slice(2), false));
-  const address = publicKeyToAddress(publicKey);
-  const account = toAccount({
-    address,
-    nonceManager,
-    async sign({ hash }) {
-      return sign({ hash, privateKey, to: "hex" });
-    },
-    async signAuthorization(authorization) {
-      return signAuthorization({ ...authorization, privateKey });
-    },
-    async signMessage({ message }) {
-      return signMessage({ message, privateKey });
-    },
-    async signTransaction(transaction, { serializer } = {}) {
-      return signTransaction({ privateKey, transaction, serializer });
-    },
-    async signTypedData(typedData) {
-      return signTypedData({ ...typedData, privateKey });
-    }
-  });
-  return {
-    ...account,
-    publicKey,
-    source: "privateKey"
-  };
-}
-var init_privateKeyToAccount = __esm(() => {
-  init_secp256k1();
-  init_toHex();
-  init_toAccount();
-  init_publicKeyToAddress();
-  init_sign();
-  init_signAuthorization();
-  init_signMessage();
-  init_signTransaction();
-  init_signTypedData();
-});
-
-// ../../node_modules/.bun/viem@2.48.8+c6bb0886e91180fe/node_modules/viem/_esm/accounts/index.js
-var init_accounts = __esm(() => {
-  init_generatePrivateKey();
-  init_privateKeyToAccount();
-});
-
 // src/cloud/cloud-wallet.ts
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
 function ensureFlag() {
   if (!isCloudWalletEnabled()) {
     throw new CloudWalletFlagDisabledError;
@@ -5170,7 +338,6 @@ function __resetCloudWalletModuleForTests() {
 }
 var ELIZA_CLOUD_CLIENT_ADDRESS_KEY_ENV = "ELIZA_CLOUD_CLIENT_ADDRESS_KEY", CloudWalletFlagDisabledError, inflight;
 var init_cloud_wallet = __esm(() => {
-  init_accounts();
   init_config_env();
   CloudWalletFlagDisabledError = class CloudWalletFlagDisabledError extends Error {
     constructor() {
@@ -5192,4 +359,4 @@ export {
   CloudWalletFlagDisabledError
 };
 
-//# debugId=FF59B298EABCBF5564756E2164756E21
+//# debugId=B0EB8E1A353E263464756E2164756E21