@strkfarm/sdk 1.0.58 → 1.0.60

package/dist/index.browser.mjs

@@ -1,9 +1,3 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
 // src/modules/pricer.ts
 import axios2 from "axios";
 
@@ -1938,2032 +1932,7 @@ import { processMultiProof, processProof } from "@ericnordelo/strk-merkle-tree/d
 import { standardLeafHash } from "@ericnordelo/strk-merkle-tree/dist/hashes";
 import { MerkleTreeImpl } from "@ericnordelo/strk-merkle-tree/dist/merkletree";
 import { num as num2 } from "starknet";
-
-// ../node_modules/@noble/hashes/esm/_assert.js
-function number(n) {
-  if (!Number.isSafeInteger(n) || n < 0)
-    throw new Error(`Wrong positive integer: ${n}`);
-}
-function bytes(b, ...lengths) {
-  if (!(b instanceof Uint8Array))
-    throw new Error("Expected Uint8Array");
-  if (lengths.length > 0 && !lengths.includes(b.length))
-    throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
-}
-function hash(hash5) {
-  if (typeof hash5 !== "function" || typeof hash5.create !== "function")
-    throw new Error("Hash should be wrapped by utils.wrapConstructor");
-  number(hash5.outputLen);
-  number(hash5.blockLen);
-}
-function exists(instance, checkFinished = true) {
-  if (instance.destroyed)
-    throw new Error("Hash instance has been destroyed");
-  if (checkFinished && instance.finished)
-    throw new Error("Hash#digest() has already been called");
-}
-function output(out, instance) {
-  bytes(out);
-  const min = instance.outputLen;
-  if (out.length < min) {
-    throw new Error(`digestInto() expects output buffer of length at least ${min}`);
-  }
-}
-
-// ../node_modules/@noble/hashes/esm/crypto.js
-var crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
-
-// ../node_modules/@noble/hashes/esm/utils.js
-var u8a = (a) => a instanceof Uint8Array;
-var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-var rotr = (word, shift) => word << 32 - shift | word >>> shift;
-var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
-if (!isLE)
-  throw new Error("Non little-endian hardware is not supported");
-function utf8ToBytes(str) {
-  if (typeof str !== "string")
-    throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
-  return new Uint8Array(new TextEncoder().encode(str));
-}
-function toBytes(data) {
-  if (typeof data === "string")
-    data = utf8ToBytes(data);
-  if (!u8a(data))
-    throw new Error(`expected Uint8Array, got ${typeof data}`);
-  return data;
-}
-function concatBytes(...arrays) {
-  const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
-  let pad = 0;
-  arrays.forEach((a) => {
-    if (!u8a(a))
-      throw new Error("Uint8Array expected");
-    r.set(a, pad);
-    pad += a.length;
-  });
-  return r;
-}
-var Hash = class {
-  // Safe version that clones internal state
-  clone() {
-    return this._cloneInto();
-  }
-};
-var toStr = {}.toString;
-function wrapConstructor(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));
-  }
-  throw new Error("crypto.getRandomValues must be defined");
-}
-
-// ../node_modules/@noble/hashes/esm/_sha2.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);
-}
-var SHA2 = class extends Hash {
-  constructor(blockLen, outputLen, padOffset, isLE2) {
-    super();
-    this.blockLen = blockLen;
-    this.outputLen = outputLen;
-    this.padOffset = padOffset;
-    this.isLE = isLE2;
-    this.finished = false;
-    this.length = 0;
-    this.pos = 0;
-    this.destroyed = false;
-    this.buffer = new Uint8Array(blockLen);
-    this.view = createView(this.buffer);
-  }
-  update(data) {
-    exists(this);
-    const { view, buffer, blockLen } = this;
-    data = toBytes(data);
-    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) {
-    exists(this);
-    output(out, this);
-    this.finished = true;
-    const { buffer, view, blockLen, isLE: isLE2 } = this;
-    let { pos } = this;
-    buffer[pos++] = 128;
-    this.buffer.subarray(pos).fill(0);
-    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.length = length;
-    to.pos = pos;
-    to.finished = finished;
-    to.destroyed = destroyed;
-    if (length % blockLen)
-      to.buffer.set(buffer);
-    return to;
-  }
-};
-
-// ../node_modules/@noble/hashes/esm/sha256.js
-var Chi = (a, b, c) => a & b ^ ~a & c;
-var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
-var SHA256_K = /* @__PURE__ */ new Uint32Array([
-  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
-]);
-var IV = /* @__PURE__ */ new Uint32Array([
-  1779033703,
-  3144134277,
-  1013904242,
-  2773480762,
-  1359893119,
-  2600822924,
-  528734635,
-  1541459225
-]);
-var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-var SHA256 = class extends SHA2 {
-  constructor() {
-    super(64, 32, 8, false);
-    this.A = IV[0] | 0;
-    this.B = IV[1] | 0;
-    this.C = IV[2] | 0;
-    this.D = IV[3] | 0;
-    this.E = IV[4] | 0;
-    this.F = IV[5] | 0;
-    this.G = IV[6] | 0;
-    this.H = IV[7] | 0;
-  }
-  get() {
-    const { A, B, C, D, E, F, G, H } = this;
-    return [A, B, C, D, E, F, G, H];
-  }
-  // prettier-ignore
-  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() {
-    SHA256_W.fill(0);
-  }
-  destroy() {
-    this.set(0, 0, 0, 0, 0, 0, 0, 0);
-    this.buffer.fill(0);
-  }
-};
-var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
-
-// ../node_modules/@noble/curves/esm/abstract/utils.js
-var utils_exports = {};
-__export(utils_exports, {
-  bitGet: () => bitGet,
-  bitLen: () => bitLen,
-  bitMask: () => bitMask,
-  bitSet: () => bitSet,
-  bytesToHex: () => bytesToHex,
-  bytesToNumberBE: () => bytesToNumberBE,
-  bytesToNumberLE: () => bytesToNumberLE,
-  concatBytes: () => concatBytes2,
-  createHmacDrbg: () => createHmacDrbg,
-  ensureBytes: () => ensureBytes,
-  equalBytes: () => equalBytes,
-  hexToBytes: () => hexToBytes,
-  hexToNumber: () => hexToNumber,
-  numberToBytesBE: () => numberToBytesBE,
-  numberToBytesLE: () => numberToBytesLE,
-  numberToHexUnpadded: () => numberToHexUnpadded,
-  numberToVarBytesBE: () => numberToVarBytesBE,
-  utf8ToBytes: () => utf8ToBytes2,
-  validateObject: () => validateObject
-});
-var _0n = BigInt(0);
-var _1n = BigInt(1);
-var _2n = BigInt(2);
-var u8a2 = (a) => a instanceof Uint8Array;
-var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-function bytesToHex(bytes2) {
-  if (!u8a2(bytes2))
-    throw new Error("Uint8Array expected");
-  let hex = "";
-  for (let i = 0; i < bytes2.length; i++) {
-    hex += hexes[bytes2[i]];
-  }
-  return hex;
-}
-function numberToHexUnpadded(num10) {
-  const hex = num10.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 BigInt(hex === "" ? "0" : `0x${hex}`);
-}
-function hexToBytes(hex) {
-  if (typeof hex !== "string")
-    throw new Error("hex string expected, got " + typeof hex);
-  const len = hex.length;
-  if (len % 2)
-    throw new Error("padded hex string expected, got unpadded hex of length " + len);
-  const array = new Uint8Array(len / 2);
-  for (let i = 0; i < array.length; i++) {
-    const j = i * 2;
-    const hexByte = hex.slice(j, j + 2);
-    const byte = Number.parseInt(hexByte, 16);
-    if (Number.isNaN(byte) || byte < 0)
-      throw new Error("Invalid byte sequence");
-    array[i] = byte;
-  }
-  return array;
-}
-function bytesToNumberBE(bytes2) {
-  return hexToNumber(bytesToHex(bytes2));
-}
-function bytesToNumberLE(bytes2) {
-  if (!u8a2(bytes2))
-    throw new Error("Uint8Array expected");
-  return hexToNumber(bytesToHex(Uint8Array.from(bytes2).reverse()));
-}
-function numberToBytesBE(n, len) {
-  return hexToBytes(n.toString(16).padStart(len * 2, "0"));
-}
-function numberToBytesLE(n, len) {
-  return numberToBytesBE(n, len).reverse();
-}
-function numberToVarBytesBE(n) {
-  return hexToBytes(numberToHexUnpadded(n));
-}
-function ensureBytes(title, hex, expectedLength) {
-  let res;
-  if (typeof hex === "string") {
-    try {
-      res = hexToBytes(hex);
-    } catch (e) {
-      throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
-    }
-  } else if (u8a2(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} expected ${expectedLength} bytes, got ${len}`);
-  return res;
-}
-function concatBytes2(...arrays) {
-  const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
-  let pad = 0;
-  arrays.forEach((a) => {
-    if (!u8a2(a))
-      throw new Error("Uint8Array expected");
-    r.set(a, pad);
-    pad += a.length;
-  });
-  return r;
-}
-function equalBytes(b1, b2) {
-  if (b1.length !== b2.length)
-    return false;
-  for (let i = 0; i < b1.length; i++)
-    if (b1[i] !== b2[i])
-      return false;
-  return true;
-}
-function utf8ToBytes2(str) {
-  if (typeof str !== "string")
-    throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
-  return new Uint8Array(new TextEncoder().encode(str));
-}
-function bitLen(n) {
-  let len;
-  for (len = 0; n > _0n; n >>= _1n, len += 1)
-    ;
-  return len;
-}
-function bitGet(n, pos) {
-  return n >> BigInt(pos) & _1n;
-}
-var bitSet = (n, pos, value) => {
-  return n | (value ? _1n : _0n) << BigInt(pos);
-};
-var bitMask = (n) => (_2n << BigInt(n - 1)) - _1n;
-var u8n = (data) => new Uint8Array(data);
-var u8fr = (arr) => Uint8Array.from(arr);
-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()) => {
-    k = h(u8fr([0]), seed);
-    v = h();
-    if (seed.length === 0)
-      return;
-    k = h(u8fr([1]), seed);
-    v = h();
-  };
-  const gen = () => {
-    if (i++ >= 1e3)
-      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 = void 0;
-    while (!(res = pred(gen())))
-      reseed();
-    reset();
-    return res;
-  };
-  return genUntil;
-}
-var 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" || val instanceof Uint8Array,
-  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)
-};
-function validateObject(object, validators, optValidators = {}) {
-  const checkField = (fieldName, type, isOptional) => {
-    const checkVal = validatorFns[type];
-    if (typeof checkVal !== "function")
-      throw new Error(`Invalid validator "${type}", expected function`);
-    const val = object[fieldName];
-    if (isOptional && val === void 0)
-      return;
-    if (!checkVal(val, object)) {
-      throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
-    }
-  };
-  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;
-}
-
-// ../node_modules/@noble/curves/esm/abstract/modular.js
-var _0n2 = BigInt(0);
-var _1n2 = BigInt(1);
-var _2n2 = BigInt(2);
-var _3n = BigInt(3);
-var _4n = BigInt(4);
-var _5n = BigInt(5);
-var _8n = BigInt(8);
-var _9n = BigInt(9);
-var _16n = BigInt(16);
-function mod(a, b) {
-  const result = a % b;
-  return result >= _0n2 ? result : b + result;
-}
-function pow(num10, power, modulo) {
-  if (modulo <= _0n2 || power < _0n2)
-    throw new Error("Expected power/modulo > 0");
-  if (modulo === _1n2)
-    return _0n2;
-  let res = _1n2;
-  while (power > _0n2) {
-    if (power & _1n2)
-      res = res * num10 % modulo;
-    num10 = num10 * num10 % modulo;
-    power >>= _1n2;
-  }
-  return res;
-}
-function invert(number2, modulo) {
-  if (number2 === _0n2 || modulo <= _0n2) {
-    throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
-  }
-  let a = mod(number2, 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 tonelliShanks(P) {
-  const legendreC = (P - _1n2) / _2n2;
-  let Q, S, Z;
-  for (Q = P - _1n2, S = 0; Q % _2n2 === _0n2; Q /= _2n2, S++)
-    ;
-  for (Z = _2n2; Z < P && pow(Z, legendreC, P) !== P - _1n2; Z++)
-    ;
-  if (S === 1) {
-    const p1div4 = (P + _1n2) / _4n;
-    return function tonelliFast(Fp, n) {
-      const root = Fp.pow(n, p1div4);
-      if (!Fp.eql(Fp.sqr(root), n))
-        throw new Error("Cannot find square root");
-      return root;
-    };
-  }
-  const Q1div2 = (Q + _1n2) / _2n2;
-  return function tonelliSlow(Fp, n) {
-    if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE))
-      throw new Error("Cannot find square root");
-    let r = S;
-    let g = Fp.pow(Fp.mul(Fp.ONE, Z), Q);
-    let x = Fp.pow(n, Q1div2);
-    let b = Fp.pow(n, Q);
-    while (!Fp.eql(b, Fp.ONE)) {
-      if (Fp.eql(b, Fp.ZERO))
-        return Fp.ZERO;
-      let m = 1;
-      for (let t2 = Fp.sqr(b); m < r; m++) {
-        if (Fp.eql(t2, Fp.ONE))
-          break;
-        t2 = Fp.sqr(t2);
-      }
-      const ge = Fp.pow(g, _1n2 << BigInt(r - m - 1));
-      g = Fp.sqr(ge);
-      x = Fp.mul(x, ge);
-      b = Fp.mul(b, g);
-      r = m;
-    }
-    return x;
-  };
-}
-function FpSqrt(P) {
-  if (P % _4n === _3n) {
-    const p1div4 = (P + _1n2) / _4n;
-    return function sqrt3mod4(Fp, n) {
-      const root = Fp.pow(n, p1div4);
-      if (!Fp.eql(Fp.sqr(root), n))
-        throw new Error("Cannot find square root");
-      return root;
-    };
-  }
-  if (P % _8n === _5n) {
-    const c1 = (P - _5n) / _8n;
-    return function sqrt5mod8(Fp, n) {
-      const n2 = Fp.mul(n, _2n2);
-      const v = Fp.pow(n2, c1);
-      const nv = Fp.mul(n, v);
-      const i = Fp.mul(Fp.mul(nv, _2n2), 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;
-    };
-  }
-  if (P % _16n === _9n) {
-  }
-  return tonelliShanks(P);
-}
-var FIELD_FIELDS = [
-  "create",
-  "isValid",
-  "is0",
-  "neg",
-  "inv",
-  "sqrt",
-  "sqr",
-  "eql",
-  "add",
-  "sub",
-  "mul",
-  "pow",
-  "div",
-  "addN",
-  "subN",
-  "mulN",
-  "sqrN"
-];
-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(f, num10, power) {
-  if (power < _0n2)
-    throw new Error("Expected power > 0");
-  if (power === _0n2)
-    return f.ONE;
-  if (power === _1n2)
-    return num10;
-  let p = f.ONE;
-  let d = num10;
-  while (power > _0n2) {
-    if (power & _1n2)
-      p = f.mul(p, d);
-    d = f.sqr(d);
-    power >>= _1n2;
-  }
-  return p;
-}
-function FpInvertBatch(f, nums) {
-  const tmp = new Array(nums.length);
-  const lastMultiplied = nums.reduce((acc, num10, i) => {
-    if (f.is0(num10))
-      return acc;
-    tmp[i] = acc;
-    return f.mul(acc, num10);
-  }, f.ONE);
-  const inverted = f.inv(lastMultiplied);
-  nums.reduceRight((acc, num10, i) => {
-    if (f.is0(num10))
-      return acc;
-    tmp[i] = f.mul(acc, tmp[i]);
-    return f.mul(acc, num10);
-  }, inverted);
-  return tmp;
-}
-function nLength(n, nBitLength2) {
-  const _nBitLength = nBitLength2 !== void 0 ? nBitLength2 : 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(`Expected Field ORDER > 0, got ${ORDER}`);
-  const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
-  if (BYTES > 2048)
-    throw new Error("Field lengths over 2048 bytes are not supported");
-  const sqrtP = FpSqrt(ORDER);
-  const f = Object.freeze({
-    ORDER,
-    BITS,
-    BYTES,
-    MASK: bitMask(BITS),
-    ZERO: _0n2,
-    ONE: _1n2,
-    create: (num10) => mod(num10, ORDER),
-    isValid: (num10) => {
-      if (typeof num10 !== "bigint")
-        throw new Error(`Invalid field element: expected bigint, got ${typeof num10}`);
-      return _0n2 <= num10 && num10 < ORDER;
-    },
-    is0: (num10) => num10 === _0n2,
-    isOdd: (num10) => (num10 & _1n2) === _1n2,
-    neg: (num10) => mod(-num10, ORDER),
-    eql: (lhs, rhs) => lhs === rhs,
-    sqr: (num10) => mod(num10 * num10, ORDER),
-    add: (lhs, rhs) => mod(lhs + rhs, ORDER),
-    sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
-    mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
-    pow: (num10, power) => FpPow(f, num10, power),
-    div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
-    // Same as above, but doesn't normalize
-    sqrN: (num10) => num10 * num10,
-    addN: (lhs, rhs) => lhs + rhs,
-    subN: (lhs, rhs) => lhs - rhs,
-    mulN: (lhs, rhs) => lhs * rhs,
-    inv: (num10) => invert(num10, ORDER),
-    sqrt: redef.sqrt || ((n) => sqrtP(f, n)),
-    invertBatch: (lst) => FpInvertBatch(f, lst),
-    // TODO: do we really need constant cmov?
-    // We don't have const-time bigints anyway, so probably will be not very useful
-    cmov: (a, b, c) => c ? b : a,
-    toBytes: (num10) => isLE2 ? numberToBytesLE(num10, BYTES) : numberToBytesBE(num10, BYTES),
-    fromBytes: (bytes2) => {
-      if (bytes2.length !== BYTES)
-        throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`);
-      return isLE2 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2);
-    }
-  });
-  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 num10 = isLE2 ? bytesToNumberBE(key) : bytesToNumberLE(key);
-  const reduced = mod(num10, fieldOrder - _1n2) + _1n2;
-  return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
-}
-
-// ../node_modules/@noble/curves/esm/abstract/poseidon.js
-function validateOpts(opts) {
-  const { Fp, mds, reversePartialPowIdx: rev, roundConstants: rc } = opts;
-  const { roundsFull, roundsPartial, sboxPower, t } = opts;
-  validateField(Fp);
-  for (const i of ["t", "roundsFull", "roundsPartial"]) {
-    if (typeof opts[i] !== "number" || !Number.isSafeInteger(opts[i]))
-      throw new Error(`Poseidon: invalid param ${i}=${opts[i]} (${typeof opts[i]})`);
-  }
-  if (!Array.isArray(mds) || mds.length !== t)
-    throw new Error("Poseidon: wrong MDS matrix");
-  const _mds = mds.map((mdsRow) => {
-    if (!Array.isArray(mdsRow) || mdsRow.length !== t)
-      throw new Error(`Poseidon MDS matrix row: ${mdsRow}`);
-    return mdsRow.map((i) => {
-      if (typeof i !== "bigint")
-        throw new Error(`Poseidon MDS matrix value=${i}`);
-      return Fp.create(i);
-    });
-  });
-  if (rev !== void 0 && typeof rev !== "boolean")
-    throw new Error(`Poseidon: invalid param reversePartialPowIdx=${rev}`);
-  if (roundsFull % 2 !== 0)
-    throw new Error(`Poseidon roundsFull is not even: ${roundsFull}`);
-  const rounds = roundsFull + roundsPartial;
-  if (!Array.isArray(rc) || rc.length !== rounds)
-    throw new Error("Poseidon: wrong round constants");
-  const roundConstants = rc.map((rc2) => {
-    if (!Array.isArray(rc2) || rc2.length !== t)
-      throw new Error(`Poseidon wrong round constants: ${rc2}`);
-    return rc2.map((i) => {
-      if (typeof i !== "bigint" || !Fp.isValid(i))
-        throw new Error(`Poseidon wrong round constant=${i}`);
-      return Fp.create(i);
-    });
-  });
-  if (!sboxPower || ![3, 5, 7].includes(sboxPower))
-    throw new Error(`Poseidon wrong sboxPower=${sboxPower}`);
-  const _sboxPower = BigInt(sboxPower);
-  let sboxFn = (n) => FpPow(Fp, n, _sboxPower);
-  if (sboxPower === 3)
-    sboxFn = (n) => Fp.mul(Fp.sqrN(n), n);
-  else if (sboxPower === 5)
-    sboxFn = (n) => Fp.mul(Fp.sqrN(Fp.sqrN(n)), n);
-  return Object.freeze({ ...opts, rounds, sboxFn, roundConstants, mds: _mds });
-}
-function poseidon(opts) {
-  const _opts = validateOpts(opts);
-  const { Fp, mds, roundConstants, rounds, roundsPartial, sboxFn, t } = _opts;
-  const halfRoundsFull = _opts.roundsFull / 2;
-  const partialIdx = _opts.reversePartialPowIdx ? t - 1 : 0;
-  const poseidonRound = (values, isFull, idx) => {
-    values = values.map((i, j) => Fp.add(i, roundConstants[idx][j]));
-    if (isFull)
-      values = values.map((i) => sboxFn(i));
-    else
-      values[partialIdx] = sboxFn(values[partialIdx]);
-    values = mds.map((i) => i.reduce((acc, i2, j) => Fp.add(acc, Fp.mulN(i2, values[j])), Fp.ZERO));
-    return values;
-  };
-  const poseidonHash = function poseidonHash2(values) {
-    if (!Array.isArray(values) || values.length !== t)
-      throw new Error(`Poseidon: wrong values (expected array of bigints with length ${t})`);
-    values = values.map((i) => {
-      if (typeof i !== "bigint")
-        throw new Error(`Poseidon: wrong value=${i} (${typeof i})`);
-      return Fp.create(i);
-    });
-    let round = 0;
-    for (let i = 0; i < halfRoundsFull; i++)
-      values = poseidonRound(values, true, round++);
-    for (let i = 0; i < roundsPartial; i++)
-      values = poseidonRound(values, false, round++);
-    for (let i = 0; i < halfRoundsFull; i++)
-      values = poseidonRound(values, true, round++);
-    if (round !== rounds)
-      throw new Error(`Poseidon: wrong number of rounds: last round=${round}, total=${rounds}`);
-    return values;
-  };
-  poseidonHash.roundConstants = roundConstants;
-  return poseidonHash;
-}
-
-// ../node_modules/@noble/curves/esm/abstract/curve.js
-var _0n3 = BigInt(0);
-var _1n3 = BigInt(1);
-function wNAF(c, bits) {
-  const constTimeNegate = (condition, item) => {
-    const neg = item.negate();
-    return condition ? neg : item;
-  };
-  const opts = (W) => {
-    const windows = Math.ceil(bits / W) + 1;
-    const windowSize = 2 ** (W - 1);
-    return { windows, windowSize };
-  };
-  return {
-    constTimeNegate,
-    // non-const time multiplication ladder
-    unsafeLadder(elm, n) {
-      let p = c.ZERO;
-      let d = elm;
-      while (n > _0n3) {
-        if (n & _1n3)
-          p = p.add(d);
-        d = d.double();
-        n >>= _1n3;
-      }
-      return p;
-    },
-    /**
-     * Creates a wNAF precomputation window. Used for caching.
-     * Default window size is set by `utils.precompute()` and is equal to 8.
-     * Number of precomputed points depends on the curve size:
-     * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
-     * - 𝑊 is the window size
-     * - 𝑛 is the bitlength of the curve order.
-     * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
-     * @returns precomputed point tables flattened to a single array
-     */
-    precomputeWindow(elm, W) {
-      const { windows, windowSize } = opts(W);
-      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;
-    },
-    /**
-     * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
-     * @param W window size
-     * @param precomputes precomputed tables
-     * @param n scalar (we don't check here, but should be less than curve order)
-     * @returns real and fake (for const-time) points
-     */
-    wNAF(W, precomputes, n) {
-      const { windows, windowSize } = opts(W);
-      let p = c.ZERO;
-      let f = c.BASE;
-      const mask = BigInt(2 ** W - 1);
-      const maxNumber = 2 ** W;
-      const shiftBy = BigInt(W);
-      for (let window = 0; window < windows; window++) {
-        const offset = window * windowSize;
-        let wbits = Number(n & mask);
-        n >>= shiftBy;
-        if (wbits > windowSize) {
-          wbits -= maxNumber;
-          n += _1n3;
-        }
-        const offset1 = offset;
-        const offset2 = offset + Math.abs(wbits) - 1;
-        const cond1 = window % 2 !== 0;
-        const cond2 = wbits < 0;
-        if (wbits === 0) {
-          f = f.add(constTimeNegate(cond1, precomputes[offset1]));
-        } else {
-          p = p.add(constTimeNegate(cond2, precomputes[offset2]));
-        }
-      }
-      return { p, f };
-    },
-    wNAFCached(P, precomputesMap, n, transform) {
-      const W = P._WINDOW_SIZE || 1;
-      let comp = precomputesMap.get(P);
-      if (!comp) {
-        comp = this.precomputeWindow(P, W);
-        if (W !== 1) {
-          precomputesMap.set(P, transform(comp));
-        }
-      }
-      return this.wNAF(W, comp, n);
-    }
-  };
-}
-function validateBasic(curve2) {
-  validateField(curve2.Fp);
-  validateObject(curve2, {
-    n: "bigint",
-    h: "bigint",
-    Gx: "field",
-    Gy: "field"
-  }, {
-    nBitLength: "isSafeInteger",
-    nByteLength: "isSafeInteger"
-  });
-  return Object.freeze({
-    ...nLength(curve2.n, curve2.nBitLength),
-    ...curve2,
-    ...{ p: curve2.Fp.ORDER }
-  });
-}
-
-// ../node_modules/@noble/curves/esm/abstract/weierstrass.js
-function validatePointOpts(curve2) {
-  const opts = validateBasic(curve2);
-  validateObject(opts, {
-    a: "field",
-    b: "field"
-  }, {
-    allowedPrivateKeyLengths: "array",
-    wrapPrivateKey: "boolean",
-    isTorsionFree: "function",
-    clearCofactor: "function",
-    allowInfinityPoint: "boolean",
-    fromBytes: "function",
-    toBytes: "function"
-  });
-  const { endo, Fp, a } = opts;
-  if (endo) {
-    if (!Fp.eql(a, Fp.ZERO)) {
-      throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
-    }
-    if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
-      throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
-    }
-  }
-  return Object.freeze({ ...opts });
-}
-var { bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports;
-var DER = {
-  // asn.1 DER encoding utils
-  Err: class DERErr extends Error {
-    constructor(m = "") {
-      super(m);
-    }
-  },
-  _parseInt(data) {
-    const { Err: E } = DER;
-    if (data.length < 2 || data[0] !== 2)
-      throw new E("Invalid signature integer tag");
-    const len = data[1];
-    const res = data.subarray(2, len + 2);
-    if (!len || res.length !== len)
-      throw new E("Invalid signature integer: wrong length");
-    if (res[0] & 128)
-      throw new E("Invalid signature integer: negative");
-    if (res[0] === 0 && !(res[1] & 128))
-      throw new E("Invalid signature integer: unnecessary leading zero");
-    return { d: b2n(res), l: data.subarray(len + 2) };
-  },
-  toSig(hex) {
-    const { Err: E } = DER;
-    const data = typeof hex === "string" ? h2b(hex) : hex;
-    if (!(data instanceof Uint8Array))
-      throw new Error("ui8a expected");
-    let l = data.length;
-    if (l < 2 || data[0] != 48)
-      throw new E("Invalid signature tag");
-    if (data[1] !== l - 2)
-      throw new E("Invalid signature: incorrect length");
-    const { d: r, l: sBytes } = DER._parseInt(data.subarray(2));
-    const { d: s, l: rBytesLeft } = DER._parseInt(sBytes);
-    if (rBytesLeft.length)
-      throw new E("Invalid signature: left bytes after parsing");
-    return { r, s };
-  },
-  hexFromSig(sig) {
-    const slice = (s2) => Number.parseInt(s2[0], 16) & 8 ? "00" + s2 : s2;
-    const h = (num10) => {
-      const hex = num10.toString(16);
-      return hex.length & 1 ? `0${hex}` : hex;
-    };
-    const s = slice(h(sig.s));
-    const r = slice(h(sig.r));
-    const shl = s.length / 2;
-    const rhl = r.length / 2;
-    const sl = h(shl);
-    const rl = h(rhl);
-    return `30${h(rhl + shl + 4)}02${rl}${r}02${sl}${s}`;
-  }
-};
-var _0n4 = BigInt(0);
-var _1n4 = BigInt(1);
-var _2n3 = BigInt(2);
-var _3n2 = BigInt(3);
-var _4n2 = BigInt(4);
-function weierstrassPoints(opts) {
-  const CURVE2 = validatePointOpts(opts);
-  const { Fp } = CURVE2;
-  const toBytes2 = CURVE2.toBytes || ((_c, point, _isCompressed) => {
-    const a = point.toAffine();
-    return concatBytes2(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
-  });
-  const fromBytes = CURVE2.fromBytes || ((bytes2) => {
-    const tail = bytes2.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 } = CURVE2;
-    const x2 = Fp.sqr(x);
-    const x3 = Fp.mul(x2, x);
-    return Fp.add(Fp.add(x3, Fp.mul(x, a)), b);
-  }
-  if (!Fp.eql(Fp.sqr(CURVE2.Gy), weierstrassEquation(CURVE2.Gx)))
-    throw new Error("bad generator point: equation left != right");
-  function isWithinCurveOrder(num10) {
-    return typeof num10 === "bigint" && _0n4 < num10 && num10 < CURVE2.n;
-  }
-  function assertGE(num10) {
-    if (!isWithinCurveOrder(num10))
-      throw new Error("Expected valid bigint: 0 < bigint < curve.n");
-  }
-  function normPrivateKeyToScalar(key) {
-    const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE2;
-    if (lengths && typeof key !== "bigint") {
-      if (key instanceof Uint8Array)
-        key = bytesToHex(key);
-      if (typeof key !== "string" || !lengths.includes(key.length))
-        throw new Error("Invalid key");
-      key = key.padStart(nByteLength * 2, "0");
-    }
-    let num10;
-    try {
-      num10 = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
-    } catch (error) {
-      throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
-    }
-    if (wrapPrivateKey)
-      num10 = mod(num10, n);
-    assertGE(num10);
-    return num10;
-  }
-  const pointPrecomputes = /* @__PURE__ */ new Map();
-  function assertPrjPoint(other) {
-    if (!(other instanceof Point))
-      throw new Error("ProjectivePoint expected");
-  }
-  class Point {
-    constructor(px, py, pz) {
-      this.px = px;
-      this.py = py;
-      this.pz = pz;
-      if (px == null || !Fp.isValid(px))
-        throw new Error("x required");
-      if (py == null || !Fp.isValid(py))
-        throw new Error("y required");
-      if (pz == null || !Fp.isValid(pz))
-        throw new Error("z required");
-    }
-    // Does not validate if the point is on-curve.
-    // Use fromHex instead, or call assertValidity() later.
-    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;
-    }
-    /**
-     * Takes a bunch of Projective Points but executes only one
-     * inversion on all of them. Inversion is very slow operation,
-     * so this improves performance massively.
-     * Optimization: converts a list of projective points to a list of identical points with Z=1.
-     */
-    static normalizeZ(points) {
-      const toInv = Fp.invertBatch(points.map((p) => p.pz));
-      return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
-    }
-    /**
-     * Converts hash string or Uint8Array to Point.
-     * @param hex short/long ECDSA hex
-     */
-    static fromHex(hex) {
-      const P = Point.fromAffine(fromBytes(ensureBytes("pointHex", hex)));
-      P.assertValidity();
-      return P;
-    }
-    // Multiplies generator point by privateKey.
-    static fromPrivateKey(privateKey) {
-      return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));
-    }
-    // "Private method", don't use it directly
-    _setWindowSize(windowSize) {
-      this._WINDOW_SIZE = windowSize;
-      pointPrecomputes.delete(this);
-    }
-    // A point on curve is valid if it conforms to equation.
-    assertValidity() {
-      if (this.is0()) {
-        if (CURVE2.allowInfinityPoint && !Fp.is0(this.py))
-          return;
-        throw new Error("bad point: ZERO");
-      }
-      const { x, y } = this.toAffine();
-      if (!Fp.isValid(x) || !Fp.isValid(y))
-        throw new Error("bad point: x or y not FE");
-      const left = Fp.sqr(y);
-      const right = weierstrassEquation(x);
-      if (!Fp.eql(left, right))
-        throw new Error("bad point: equation left != right");
-      if (!this.isTorsionFree())
-        throw new Error("bad point: not in prime-order subgroup");
-    }
-    hasEvenY() {
-      const { y } = this.toAffine();
-      if (Fp.isOdd)
-        return !Fp.isOdd(y);
-      throw new Error("Field doesn't support isOdd");
-    }
-    /**
-     * Compare one point to another.
-     */
-    equals(other) {
-      assertPrjPoint(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;
-    }
-    /**
-     * Flips point to one corresponding to (x, -y) in Affine coordinates.
-     */
-    negate() {
-      return new Point(this.px, Fp.neg(this.py), this.pz);
-    }
-    // Renes-Costello-Batina exception-free doubling formula.
-    // There is 30% faster Jacobian formula, but it is not complete.
-    // https://eprint.iacr.org/2015/1060, algorithm 3
-    // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
-    double() {
-      const { a, b } = CURVE2;
-      const b3 = Fp.mul(b, _3n2);
-      const { px: X1, py: Y1, pz: Z1 } = this;
-      let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
-      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);
-    }
-    // Renes-Costello-Batina exception-free addition formula.
-    // There is 30% faster Jacobian formula, but it is not complete.
-    // https://eprint.iacr.org/2015/1060, algorithm 1
-    // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
-    add(other) {
-      assertPrjPoint(other);
-      const { px: X1, py: Y1, pz: Z1 } = this;
-      const { px: X2, py: Y2, pz: Z2 } = other;
-      let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
-      const a = CURVE2.a;
-      const b3 = Fp.mul(CURVE2.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, pointPrecomputes, n, (comp) => {
-        const toInv = Fp.invertBatch(comp.map((p) => p.pz));
-        return comp.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
-      });
-    }
-    /**
-     * Non-constant-time multiplication. Uses double-and-add algorithm.
-     * It's faster, but should only be used when you don't care about
-     * an exposed private key e.g. sig verification, which works over *public* keys.
-     */
-    multiplyUnsafe(n) {
-      const I = Point.ZERO;
-      if (n === _0n4)
-        return I;
-      assertGE(n);
-      if (n === _1n4)
-        return this;
-      const { endo } = CURVE2;
-      if (!endo)
-        return wnaf.unsafeLadder(this, n);
-      let { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);
-      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, endo.beta), k2p.py, k2p.pz);
-      return k1p.add(k2p);
-    }
-    /**
-     * Constant time multiplication.
-     * Uses wNAF method. Windowed method may be 10% faster,
-     * but takes 2x longer to generate and consumes 2x memory.
-     * Uses precomputes when available.
-     * Uses endomorphism for Koblitz curves.
-     * @param scalar by which the point would be multiplied
-     * @returns New point
-     */
-    multiply(scalar) {
-      assertGE(scalar);
-      let n = scalar;
-      let point, fake;
-      const { endo } = CURVE2;
-      if (endo) {
-        const { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);
-        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, endo.beta), k2p.py, k2p.pz);
-        point = k1p.add(k2p);
-        fake = f1p.add(f2p);
-      } else {
-        const { p, f } = this.wNAF(n);
-        point = p;
-        fake = f;
-      }
-      return Point.normalizeZ([point, fake])[0];
-    }
-    /**
-     * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
-     * Not using Strauss-Shamir trick: precomputation tables are faster.
-     * The trick could be useful if both P and Q are not G (not in our case).
-     * @returns non-zero affine point
-     */
-    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() ? void 0 : sum;
-    }
-    // Converts Projective point to affine (x, y) coordinates.
-    // Can accept precomputed Z^-1 - for example, from invertBatch.
-    // (x, y, z) ∋ (x=x/z, y=y/z)
-    toAffine(iz) {
-      const { px: x, py: y, pz: z } = this;
-      const is0 = this.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 };
-    }
-    isTorsionFree() {
-      const { h: cofactor, isTorsionFree } = CURVE2;
-      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 } = CURVE2;
-      if (cofactor === _1n4)
-        return this;
-      if (clearCofactor)
-        return clearCofactor(Point, this);
-      return this.multiplyUnsafe(CURVE2.h);
-    }
-    toRawBytes(isCompressed = true) {
-      this.assertValidity();
-      return toBytes2(Point, this, isCompressed);
-    }
-    toHex(isCompressed = true) {
-      return bytesToHex(this.toRawBytes(isCompressed));
-    }
-  }
-  Point.BASE = new Point(CURVE2.Gx, CURVE2.Gy, Fp.ONE);
-  Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
-  const _bits = CURVE2.nBitLength;
-  const wnaf = wNAF(Point, CURVE2.endo ? Math.ceil(_bits / 2) : _bits);
-  return {
-    CURVE: CURVE2,
-    ProjectivePoint: Point,
-    normPrivateKeyToScalar,
-    weierstrassEquation,
-    isWithinCurveOrder
-  };
-}
-function validateOpts2(curve2) {
-  const opts = validateBasic(curve2);
-  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 CURVE2 = validateOpts2(curveDef);
-  const { Fp, n: CURVE_ORDER2 } = CURVE2;
-  const compressedLen = Fp.BYTES + 1;
-  const uncompressedLen = 2 * Fp.BYTES + 1;
-  function isValidFieldElement(num10) {
-    return _0n4 < num10 && num10 < Fp.ORDER;
-  }
-  function modN(a) {
-    return mod(a, CURVE_ORDER2);
-  }
-  function invN(a) {
-    return invert(a, CURVE_ORDER2);
-  }
-  const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
-    ...CURVE2,
-    toBytes(_c, point, isCompressed) {
-      const a = point.toAffine();
-      const x = Fp.toBytes(a.x);
-      const cat = concatBytes2;
-      if (isCompressed) {
-        return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
-      } else {
-        return cat(Uint8Array.from([4]), x, Fp.toBytes(a.y));
-      }
-    },
-    fromBytes(bytes2) {
-      const len = bytes2.length;
-      const head = bytes2[0];
-      const tail = bytes2.subarray(1);
-      if (len === compressedLen && (head === 2 || head === 3)) {
-        const x = bytesToNumberBE(tail);
-        if (!isValidFieldElement(x))
-          throw new Error("Point is not on curve");
-        const y2 = weierstrassEquation(x);
-        let y = Fp.sqrt(y2);
-        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 {
-        throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
-      }
-    }
-  });
-  const numToNByteStr = (num10) => bytesToHex(numberToBytesBE(num10, CURVE2.nByteLength));
-  function isBiggerThanHalfOrder(number2) {
-    const HALF = CURVE_ORDER2 >> _1n4;
-    return number2 > HALF;
-  }
-  function normalizeS(s) {
-    return isBiggerThanHalfOrder(s) ? modN(-s) : s;
-  }
-  const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
-  class Signature2 {
-    constructor(r, s, recovery) {
-      this.r = r;
-      this.s = s;
-      this.recovery = recovery;
-      this.assertValidity();
-    }
-    // pair (bytes of r, bytes of s)
-    static fromCompact(hex) {
-      const l = CURVE2.nByteLength;
-      hex = ensureBytes("compactSignature", hex, l * 2);
-      return new Signature2(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
-    }
-    // DER encoded ECDSA signature
-    // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
-    static fromDER(hex) {
-      const { r, s } = DER.toSig(ensureBytes("DER", hex));
-      return new Signature2(r, s);
-    }
-    assertValidity() {
-      if (!isWithinCurveOrder(this.r))
-        throw new Error("r must be 0 < r < CURVE.n");
-      if (!isWithinCurveOrder(this.s))
-        throw new Error("s must be 0 < s < CURVE.n");
-    }
-    addRecoveryBit(recovery) {
-      return new Signature2(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 + CURVE2.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 + numToNByteStr(radj));
-      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;
-    }
-    // Signatures should be low-s, to prevent malleability.
-    hasHighS() {
-      return isBiggerThanHalfOrder(this.s);
-    }
-    normalizeS() {
-      return this.hasHighS() ? new Signature2(this.r, modN(-this.s), this.recovery) : this;
-    }
-    // DER-encoded
-    toDERRawBytes() {
-      return hexToBytes(this.toDERHex());
-    }
-    toDERHex() {
-      return DER.hexFromSig({ r: this.r, s: this.s });
-    }
-    // padded bytes of r, then padded bytes of s
-    toCompactRawBytes() {
-      return hexToBytes(this.toCompactHex());
-    }
-    toCompactHex() {
-      return numToNByteStr(this.r) + numToNByteStr(this.s);
-    }
-  }
-  const utils2 = {
-    isValidPrivateKey(privateKey) {
-      try {
-        normPrivateKeyToScalar(privateKey);
-        return true;
-      } catch (error) {
-        return false;
-      }
-    },
-    normPrivateKeyToScalar,
-    /**
-     * Produces cryptographically secure private key from random of size
-     * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
-     */
-    randomPrivateKey: () => {
-      const length = getMinHashLength(CURVE2.n);
-      return mapHashToField(CURVE2.randomBytes(length), CURVE2.n);
-    },
-    /**
-     * Creates precompute table for an arbitrary EC point. Makes point "cached".
-     * Allows to massively speed-up `point.multiply(scalar)`.
-     * @returns cached point
-     * @example
-     * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
-     * fast.multiply(privKey); // much faster ECDH now
-     */
-    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) {
-    const arr = item instanceof Uint8Array;
-    const str = typeof item === "string";
-    const len = (arr || str) && item.length;
-    if (arr)
-      return len === compressedLen || len === uncompressedLen;
-    if (str)
-      return len === 2 * compressedLen || len === 2 * uncompressedLen;
-    if (item instanceof Point)
-      return true;
-    return false;
-  }
-  function getSharedSecret(privateA, publicB, isCompressed = true) {
-    if (isProbPub(privateA))
-      throw new Error("first arg must be private key");
-    if (!isProbPub(publicB))
-      throw new Error("second arg must be public key");
-    const b = Point.fromHex(publicB);
-    return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
-  }
-  const bits2int2 = CURVE2.bits2int || function(bytes2) {
-    const num10 = bytesToNumberBE(bytes2);
-    const delta = bytes2.length * 8 - CURVE2.nBitLength;
-    return delta > 0 ? num10 >> BigInt(delta) : num10;
-  };
-  const bits2int_modN = CURVE2.bits2int_modN || function(bytes2) {
-    return modN(bits2int2(bytes2));
-  };
-  const ORDER_MASK = bitMask(CURVE2.nBitLength);
-  function int2octets(num10) {
-    if (typeof num10 !== "bigint")
-      throw new Error("bigint expected");
-    if (!(_0n4 <= num10 && num10 < ORDER_MASK))
-      throw new Error(`bigint expected < 2^${CURVE2.nBitLength}`);
-    return numberToBytesBE(num10, CURVE2.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: hash5, randomBytes: randomBytes2 } = CURVE2;
-    let { lowS, prehash, extraEntropy: ent } = opts;
-    if (lowS == null)
-      lowS = true;
-    msgHash = ensureBytes("msgHash", msgHash);
-    if (prehash)
-      msgHash = ensureBytes("prehashed msgHash", hash5(msgHash));
-    const h1int = bits2int_modN(msgHash);
-    const d = normPrivateKeyToScalar(privateKey);
-    const seedArgs = [int2octets(d), int2octets(h1int)];
-    if (ent != null) {
-      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 = bits2int2(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 Signature2(r, normS, recovery);
-    }
-    return { seed, k2sig };
-  }
-  const defaultSigOpts = { lowS: CURVE2.lowS, prehash: false };
-  const defaultVerOpts = { lowS: CURVE2.lowS, prehash: false };
-  function sign(msgHash, privKey, opts = defaultSigOpts) {
-    const { seed, k2sig } = prepSig(msgHash, privKey, opts);
-    const C = CURVE2;
-    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);
-    if ("strict" in opts)
-      throw new Error("options.strict was renamed to lowS");
-    const { lowS, prehash } = opts;
-    let _sig = void 0;
-    let P;
-    try {
-      if (typeof sg === "string" || sg instanceof Uint8Array) {
-        try {
-          _sig = Signature2.fromDER(sg);
-        } catch (derError) {
-          if (!(derError instanceof DER.Err))
-            throw derError;
-          _sig = Signature2.fromCompact(sg);
-        }
-      } else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") {
-        const { r: r2, s: s2 } = sg;
-        _sig = new Signature2(r2, s2);
-      } else {
-        throw new Error("PARSE");
-      }
-      P = Point.fromHex(publicKey);
-    } catch (error) {
-      if (error.message === "PARSE")
-        throw new Error(`signature must be Signature instance, Uint8Array or hex string`);
-      return false;
-    }
-    if (lowS && _sig.hasHighS())
-      return false;
-    if (prehash)
-      msgHash = CURVE2.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: CURVE2,
-    getPublicKey,
-    getSharedSecret,
-    sign,
-    verify,
-    ProjectivePoint: Point,
-    Signature: Signature2,
-    utils: utils2
-  };
-}
-
-// ../node_modules/@noble/hashes/esm/hmac.js
-var HMAC = class extends Hash {
-  constructor(hash5, _key) {
-    super();
-    this.finished = false;
-    this.destroyed = false;
-    hash(hash5);
-    const key = toBytes(_key);
-    this.iHash = hash5.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 ? hash5.create().update(key).digest() : key);
-    for (let i = 0; i < pad.length; i++)
-      pad[i] ^= 54;
-    this.iHash.update(pad);
-    this.oHash = hash5.create();
-    for (let i = 0; i < pad.length; i++)
-      pad[i] ^= 54 ^ 92;
-    this.oHash.update(pad);
-    pad.fill(0);
-  }
-  update(buf) {
-    exists(this);
-    this.iHash.update(buf);
-    return this;
-  }
-  digestInto(out) {
-    exists(this);
-    bytes(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;
-  }
-  destroy() {
-    this.destroyed = true;
-    this.oHash.destroy();
-    this.iHash.destroy();
-  }
-};
-var hmac = (hash5, key, message) => new HMAC(hash5, key).update(message).digest();
-hmac.create = (hash5, key) => new HMAC(hash5, key);
-
-// ../node_modules/@noble/curves/esm/_shortw_utils.js
-function getHash(hash5) {
-  return {
-    hash: hash5,
-    hmac: (key, ...msgs) => hmac(hash5, key, concatBytes(...msgs)),
-    randomBytes
-  };
-}
-
-// ../node_modules/@scure/starknet/lib/esm/index.js
-var CURVE_ORDER = BigInt("3618502788666131213697322783095070105526743751716087489154079457884512865583");
-var MAX_VALUE = BigInt("0x800000000000000000000000000000000000000000000000000000000000000");
-var nBitLength = 252;
-function bits2int(bytes2) {
-  while (bytes2[0] === 0)
-    bytes2 = bytes2.subarray(1);
-  const delta = bytes2.length * 8 - nBitLength;
-  const num10 = bytesToNumberBE(bytes2);
-  return delta > 0 ? num10 >> BigInt(delta) : num10;
-}
-function hex0xToBytes(hex) {
-  if (typeof hex === "string") {
-    hex = strip0x(hex);
-    if (hex.length & 1)
-      hex = "0" + hex;
-  }
-  return hexToBytes(hex);
-}
-var curve = weierstrass({
-  a: BigInt(1),
-  b: BigInt("3141592653589793238462643383279502884197169399375105820974944592307816406665"),
-  Fp: Field(BigInt("0x800000000000011000000000000000000000000000000000000000000000001")),
-  n: CURVE_ORDER,
-  nBitLength,
-  Gx: BigInt("874739451078007766457464989774322083649278607533249481151382481072868806602"),
-  Gy: BigInt("152666792071518830868575557812948353041420400780739481342941381225525861407"),
-  h: BigInt(1),
-  lowS: false,
-  ...getHash(sha256),
-  bits2int,
-  bits2int_modN: (bytes2) => {
-    const hex = bytesToNumberBE(bytes2).toString(16);
-    if (hex.length === 63)
-      bytes2 = hex0xToBytes(hex + "0");
-    return mod(bits2int(bytes2), CURVE_ORDER);
-  }
-});
-function ensureBytes2(hex) {
-  return ensureBytes("", typeof hex === "string" ? hex0xToBytes(hex) : hex);
-}
-var { CURVE, ProjectivePoint, Signature, utils } = curve;
-function extractX(bytes2) {
-  const hex = bytesToHex(bytes2.subarray(1));
-  const stripped = hex.replace(/^0+/gm, "");
-  return `0x${stripped}`;
-}
-function strip0x(hex) {
-  return hex.replace(/^0x/i, "");
-}
-var MASK_31 = 2n ** 31n - 1n;
-var PEDERSEN_POINTS = [
-  new ProjectivePoint(2089986280348253421170679821480865132823066470938446095505822317253594081284n, 1713931329540660377023406109199410414810705867260802078187082345529207694986n, 1n),
-  new ProjectivePoint(996781205833008774514500082376783249102396023663454813447423147977397232763n, 1668503676786377725805489344771023921079126552019160156920634619255970485781n, 1n),
-  new ProjectivePoint(2251563274489750535117886426533222435294046428347329203627021249169616184184n, 1798716007562728905295480679789526322175868328062420237419143593021674992973n, 1n),
-  new ProjectivePoint(2138414695194151160943305727036575959195309218611738193261179310511854807447n, 113410276730064486255102093846540133784865286929052426931474106396135072156n, 1n),
-  new ProjectivePoint(2379962749567351885752724891227938183011949129833673362440656643086021394946n, 776496453633298175483985398648758586525933812536653089401905292063708816422n, 1n)
-];
-function pedersenPrecompute(p1, p2) {
-  const out = [];
-  let p = p1;
-  for (let i = 0; i < 248; i++) {
-    out.push(p);
-    p = p.double();
-  }
-  p = p2;
-  for (let i = 0; i < 4; i++) {
-    out.push(p);
-    p = p.double();
-  }
-  return out;
-}
-var PEDERSEN_POINTS1 = pedersenPrecompute(PEDERSEN_POINTS[1], PEDERSEN_POINTS[2]);
-var PEDERSEN_POINTS2 = pedersenPrecompute(PEDERSEN_POINTS[3], PEDERSEN_POINTS[4]);
-function pedersenArg(arg) {
-  let value;
-  if (typeof arg === "bigint") {
-    value = arg;
-  } else if (typeof arg === "number") {
-    if (!Number.isSafeInteger(arg))
-      throw new Error(`Invalid pedersenArg: ${arg}`);
-    value = BigInt(arg);
-  } else {
-    value = bytesToNumberBE(ensureBytes2(arg));
-  }
-  if (!(0n <= value && value < curve.CURVE.Fp.ORDER))
-    throw new Error(`PedersenArg should be 0 <= value < CURVE.P: ${value}`);
-  return value;
-}
-function pedersenSingle(point, value, constants) {
-  let x = pedersenArg(value);
-  for (let j = 0; j < 252; j++) {
-    const pt = constants[j];
-    if (pt.equals(point))
-      throw new Error("Same point");
-    if ((x & 1n) !== 0n)
-      point = point.add(pt);
-    x >>= 1n;
-  }
-  return point;
-}
-function pedersen(x, y) {
-  let point = PEDERSEN_POINTS[0];
-  point = pedersenSingle(point, x, PEDERSEN_POINTS1);
-  point = pedersenSingle(point, y, PEDERSEN_POINTS2);
-  return extractX(point.toRawBytes(true));
-}
-var MASK_250 = bitMask(250);
-var Fp251 = Field(BigInt("3618502788666131213697322783095070105623107215331596699973092056135872020481"));
-function poseidonRoundConstant(Fp, name, idx) {
-  const val = Fp.fromBytes(sha256(utf8ToBytes(`${name}${idx}`)));
-  return Fp.create(val);
-}
-var MDS_SMALL = [
-  [3, 1, 1],
-  [1, -1, 1],
-  [1, 1, -2]
-].map((i) => i.map(BigInt));
-function poseidonBasic(opts, mds) {
-  validateField(opts.Fp);
-  if (!Number.isSafeInteger(opts.rate) || !Number.isSafeInteger(opts.capacity))
-    throw new Error(`Wrong poseidon opts: ${opts}`);
-  const m = opts.rate + opts.capacity;
-  const rounds = opts.roundsFull + opts.roundsPartial;
-  const roundConstants = [];
-  for (let i = 0; i < rounds; i++) {
-    const row = [];
-    for (let j = 0; j < m; j++)
-      row.push(poseidonRoundConstant(opts.Fp, "Hades", m * i + j));
-    roundConstants.push(row);
-  }
-  const res = poseidon({
-    ...opts,
-    t: m,
-    sboxPower: 3,
-    reversePartialPowIdx: true,
-    mds,
-    roundConstants
-  });
-  res.m = m;
-  res.rate = opts.rate;
-  res.capacity = opts.capacity;
-  return res;
-}
-var poseidonSmall = poseidonBasic({ Fp: Fp251, rate: 2, capacity: 1, roundsFull: 8, roundsPartial: 83 }, MDS_SMALL);
-
-// src/utils/oz-merkle.ts
+import * as starknet from "@scure/starknet";
 function hash_leaf(leaf) {
   if (leaf.data.length < 1) {
     throw new Error("Invalid leaf data");
@@ -3976,7 +1945,7 @@ function hash_leaf(leaf) {
   return `0x${num2.toHexString(value).replace(/^0x/, "").padStart(64, "0")}`;
 }
 function pedersen_hash(a, b) {
-  return BigInt(pedersen(a, b).toString());
+  return BigInt(starknet.pedersen(a, b).toString());
 }
 var StandardMerkleTree = class _StandardMerkleTree extends MerkleTreeImpl {
   constructor(tree, values, leafEncoding) {
@@ -4133,6 +2102,7 @@ function getMainnetConfig(rpcUrl = "https://starknet-mainnet.public.blastapi.io"
     provider: new RpcProvider2({
       nodeUrl: rpcUrl,
       blockIdentifier
+      // specVersion
     }),
     stage: "production",
     network: "mainnet" /* mainnet */
@@ -4162,7 +2132,7 @@ var getRiskExplaination = (riskType) => {
 };
 var getRiskColor = (risk) => {
   const value = risk.value;
-  if (value <= 1) return "light_green_2";
+  if (value <= 2) return "light_green_2";
   if (value < 3) return "yellow";
   return "red";
 };
@@ -4190,8 +2160,18 @@ var VesuProtocol = {
   name: "Vesu",
   logo: "https://static-assets-8zct.onrender.com/integrations/vesu/logo.png"
 };
+var EndurProtocol = {
+  name: "Endur",
+  logo: "http://endur.fi/logo.png"
+};
+var ExtendedProtocol = {
+  name: "Extended",
+  logo: "https://static-assets-8zct.onrender.com/integrations/extended/extended.svg"
+};
 var Protocols = {
-  VESU: VesuProtocol
+  VESU: VesuProtocol,
+  ENDUR: EndurProtocol,
+  EXTENDED: ExtendedProtocol
 };
 
 // src/interfaces/initializable.ts
@@ -17888,7 +15868,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
           quote.buyAmount.toString(),
           tokenToBuyInfo.decimals
         ).multipliedBy(0.9999);
-        const output2 = await this.avnu.getSwapInfo(
+        const output = await this.avnu.getSwapInfo(
           quote,
           this.address.address,
           0,
@@ -17896,9 +15876,9 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
           minAmountOut.toWei()
         );
         logger.verbose(
-          `${_EkuboCLVault.name}: getSwapInfoToHandleUnused => swap info found: ${JSON.stringify(output2)}`
+          `${_EkuboCLVault.name}: getSwapInfoToHandleUnused => swap info found: ${JSON.stringify(output)}`
         );
-        return output2;
+        return output;
       }
     }
     throw new Error("Failed to get swap info");
@@ -20453,10 +18433,10 @@ var SenseiStrategies = [
 ];
 
 // src/strategies/universal-adapters/baseAdapter.ts
-import { hash as hash2, num as num6, shortString } from "starknet";
+import { hash, num as num6, shortString } from "starknet";
 
 // src/strategies/universal-adapters/adapter-utils.ts
-var SIMPLE_SANITIZER = ContractAddr.from("0x11b59e89b35dfceb3e48ec18c01f8ec569592026c275bcb58e22af9f4dedaac");
+var SIMPLE_SANITIZER = ContractAddr.from("0x3798dc4f83fdfad199e5236e3656cf2fb79bc50c00504d0dd41522e0f042072");
 function toBigInt(value) {
   if (typeof value === "string") {
     return BigInt(value);
@@ -20479,7 +18459,7 @@ var BaseAdapter = class extends CacheClass {
         // sanitizer address
         target.toBigInt(),
         // contract
-        toBigInt(hash2.getSelectorFromName(method)),
+        toBigInt(hash.getSelectorFromName(method)),
         // method name
         BigInt(packedArguments.length),
         ...packedArguments
@@ -20489,7 +18469,7 @@ var BaseAdapter = class extends CacheClass {
 };
 
 // src/strategies/universal-adapters/common-adapter.ts
-import { hash as hash3, uint256 as uint2566 } from "starknet";
+import { hash as hash2, uint256 as uint2566 } from "starknet";
 var CommonAdapter = class extends BaseAdapter {
   constructor(config) {
     super();
@@ -20519,7 +18499,7 @@ var CommonAdapter = class extends BaseAdapter {
       sanitizer: SIMPLE_SANITIZER,
       call: {
         contractAddress: this.config.manager,
-        selector: hash3.getSelectorFromName("flash_loan"),
+        selector: hash2.getSelectorFromName("flash_loan"),
         calldata: [
           this.config.manager.toBigInt(),
           // receiver
@@ -20558,7 +18538,7 @@ var CommonAdapter = class extends BaseAdapter {
         sanitizer: SIMPLE_SANITIZER,
         call: {
           contractAddress: token,
-          selector: hash3.getSelectorFromName("approve"),
+          selector: hash2.getSelectorFromName("approve"),
           calldata: [
             spender.toBigInt(),
             // spender
@@ -20571,10 +18551,39 @@ var CommonAdapter = class extends BaseAdapter {
       };
     };
   }
+  getBringLiquidityAdapter(id) {
+    return () => ({
+      leaf: this.constructSimpleLeafData({
+        id,
+        target: this.config.vaultAddress,
+        method: "bring_liquidity",
+        packedArguments: []
+      }),
+      callConstructor: this.getBringLiquidityCall().bind(this)
+    });
+  }
+  getBringLiquidityCall() {
+    return (params) => {
+      const uint256Amount = uint2566.bnToUint256(params.amount.toWei());
+      return {
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: this.config.vaultAddress,
+          selector: hash2.getSelectorFromName("bring_liquidity"),
+          calldata: [
+            toBigInt(uint256Amount.low.toString()),
+            // amount low
+            toBigInt(uint256Amount.high.toString())
+            // amount high
+          ]
+        }
+      };
+    };
+  }
 };
 
 // src/strategies/universal-adapters/vesu-adapter.ts
-import { CairoCustomEnum as CairoCustomEnum2, Contract as Contract8, hash as hash4, RpcProvider as RpcProvider4, uint256 as uint2567 } from "starknet";
+import { CairoCustomEnum as CairoCustomEnum2, Contract as Contract8, hash as hash3, RpcProvider as RpcProvider4, uint256 as uint2567 } from "starknet";
 
 // src/data/vesu-singleton.abi.json
 var vesu_singleton_abi_default = [
@@ -22857,13 +20866,13 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
         toBigInt(positionData.length),
         ...positionData
       ];
-      const output2 = this.constructSimpleLeafData({
+      const output = this.constructSimpleLeafData({
         id: this.config.id,
         target: this.VESU_SINGLETON,
         method: "modify_position",
         packedArguments
       });
-      return { leaf: output2, callConstructor: this.getModifyPositionCall.bind(this) };
+      return { leaf: output, callConstructor: this.getModifyPositionCall.bind(this) };
     };
     this.getModifyPositionCall = (params) => {
       const _collateral = {
@@ -22900,7 +20909,7 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
         sanitizer: SIMPLE_SANITIZER,
         call: {
           contractAddress: this.VESU_SINGLETON,
-          selector: hash4.getSelectorFromName("modify_position"),
+          selector: hash3.getSelectorFromName("modify_position"),
           calldata: [
             ...call.calldata
           ]
@@ -22956,8 +20965,8 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
     if (cacheData) {
       return cacheData;
     }
-    const output2 = await this.getVesuSingletonContract(config).call("ltv_config", [this.config.poolId.address, this.config.collateral.address.address, this.config.debt.address.address]);
-    this.setCache(CACHE_KEY, Number(output2.max_ltv) / 1e18, 3e5);
+    const output = await this.getVesuSingletonContract(config).call("ltv_config", [this.config.poolId.address, this.config.collateral.address.address, this.config.debt.address.address]);
+    this.setCache(CACHE_KEY, Number(output.max_ltv) / 1e18, 3e5);
     return this.getCache(CACHE_KEY);
   }
   async getPositions(config) {
@@ -22969,7 +20978,7 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
     if (cacheData) {
       return cacheData;
     }
-    const output2 = await this.getVesuSingletonContract(config).call("position_unsafe", [
+    const output = await this.getVesuSingletonContract(config).call("position_unsafe", [
       this.config.poolId.address,
       this.config.collateral.address.address,
       this.config.debt.address.address,
@@ -22977,8 +20986,8 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
     ]);
     const token1Price = await this.pricer.getPrice(this.config.collateral.symbol);
     const token2Price = await this.pricer.getPrice(this.config.debt.symbol);
-    const collateralAmount = Web3Number.fromWei(output2["1"].toString(), this.config.collateral.decimals);
-    const debtAmount = Web3Number.fromWei(output2["2"].toString(), this.config.debt.decimals);
+    const collateralAmount = Web3Number.fromWei(output["1"].toString(), this.config.collateral.decimals);
+    const debtAmount = Web3Number.fromWei(output["2"].toString(), this.config.debt.decimals);
     const value = [{
       amount: collateralAmount,
       token: this.config.collateral,
@@ -23002,14 +21011,14 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
     if (cacheData) {
       return cacheData;
     }
-    const output2 = await this.getVesuSingletonContract(config).call("check_collateralization_unsafe", [
+    const output = await this.getVesuSingletonContract(config).call("check_collateralization_unsafe", [
       this.config.poolId.address,
       this.config.collateral.address.address,
       this.config.debt.address.address,
       this.config.vaultAllocator.address
     ]);
-    const collateralAmount = Web3Number.fromWei(output2["1"].toString(), 18);
-    const debtAmount = Web3Number.fromWei(output2["2"].toString(), 18);
+    const collateralAmount = Web3Number.fromWei(output["1"].toString(), 18);
+    const debtAmount = Web3Number.fromWei(output["2"].toString(), 18);
     const value = [{
       token: this.config.collateral,
       usdValue: collateralAmount.toNumber(),
@@ -23026,8 +21035,8 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
     const collateralizationProm = this.getCollateralization(this.networkConfig);
     const positionsProm = this.getPositions(this.networkConfig);
     const ltvProm = this.getLTVConfig(this.networkConfig);
-    const output2 = await Promise.all([collateralizationProm, positionsProm, ltvProm]);
-    const [collateralization, positions, ltv] = output2;
+    const output = await Promise.all([collateralizationProm, positionsProm, ltvProm]);
+    const [collateralization, positions, ltv] = output;
     const collateralTokenAmount = positions[0].amount;
     const collateralUSDAmount = collateralization[0].usdValue;
     const collateralPrice = collateralUSDAmount / collateralTokenAmount.toNumber();
@@ -23088,7 +21097,7 @@ var VesuAdapter = class _VesuAdapter extends BaseAdapter {
   }
 };
 
-// src/strategies/universal-strategy.ts
+// src/strategies/universal-strategy.tsx
 import { CallData, Contract as Contract9, num as num9, uint256 as uint2568 } from "starknet";
 
 // src/data/universal-vault.abi.json
@@ -25294,7 +23303,13 @@ var vault_manager_abi_default = [
   }
 ];
 
-// src/strategies/universal-strategy.ts
+// src/strategies/universal-strategy.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var AUMTypes = /* @__PURE__ */ ((AUMTypes2) => {
+  AUMTypes2["FINALISED"] = "finalised";
+  AUMTypes2["DEFISPRING"] = "defispring";
+  return AUMTypes2;
+})(AUMTypes || {});
 var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
   constructor(config, pricer, metadata) {
     super(config);
@@ -25379,6 +23394,19 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     ]);
     return [call1, call2];
   }
+  async withdrawCall(amountInfo, receiver, owner) {
+    assert(
+      amountInfo.tokenInfo.address.eq(this.asset().address),
+      "Withdraw token mismatch"
+    );
+    const shares = await this.contract.call("convert_to_shares", [uint2568.bnToUint256(amountInfo.amount.toWei())]);
+    const call = this.contract.populate("request_redeem", [
+      uint2568.bnToUint256(shares.toString()),
+      receiver.address,
+      owner.address
+    ]);
+    return [call];
+  }
   /**
    * Calculates the Total Value Locked (TVL) for a specific user.
    * @param user - Address of the user
@@ -25425,14 +23453,24 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     const collateral2APY = Number(collateralAsset2.supplyApy.value) / 1e18;
     const debt2APY = Number(debtAsset2.borrowApr.value) / 1e18;
     const positions = await this.getVaultPositions();
+    logger.verbose(`${this.metadata.name}::netAPY: positions: ${JSON.stringify(positions)}`);
+    if (positions.every((p) => p.amount.isZero())) {
+      return { net: 0, splits: [{
+        apy: 0,
+        id: "base"
+      }, {
+        apy: 0,
+        id: "defispring"
+      }] };
+    }
     const weights = positions.map((p, index) => p.usdValue * (index % 2 == 0 ? 1 : -1));
     const baseAPYs = [collateral1APY, debt1APY, collateral2APY, debt2APY];
     assert(positions.length == baseAPYs.length, "Positions and APYs length mismatch");
     const rewardAPYs = [Number(collateralAsset1.defiSpringSupplyApr.value) / 1e18, 0, Number(collateralAsset2.defiSpringSupplyApr.value) / 1e18, 0];
     const baseAPY = this.computeAPY(baseAPYs, weights);
     const rewardAPY = this.computeAPY(rewardAPYs, weights);
-    const apys = [...baseAPYs, ...rewardAPYs];
     const netAPY = baseAPY + rewardAPY;
+    logger.verbose(`${this.metadata.name}::netAPY: net: ${netAPY}, baseAPY: ${baseAPY}, rewardAPY: ${rewardAPY}`);
     return { net: netAPY, splits: [{
       apy: baseAPY,
       id: "base"
@@ -25467,6 +23505,16 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
       usdValue
     };
   }
+  async getUnusedBalance() {
+    const balance = await new ERC20(this.config).balanceOf(this.asset().address, this.metadata.additionalInfo.vaultAllocator, this.asset().decimals);
+    const price = await this.pricer.getPrice(this.metadata.depositTokens[0].symbol);
+    const usdValue = Number(balance.toFixed(6)) * price.price;
+    return {
+      tokenInfo: this.asset(),
+      amount: balance,
+      usdValue
+    };
+  }
   async getAUM() {
     const currentAUM = await this.contract.call("aum", []);
     const lastReportTime = await this.contract.call("last_report_timestamp", []);
@@ -25474,16 +23522,33 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     const [vesuAdapter1, vesuAdapter2] = this.getVesuAdapters();
     const leg1AUM = await vesuAdapter1.getPositions(this.config);
     const leg2AUM = await vesuAdapter2.getPositions(this.config);
-    const balance = await new ERC20(this.config).balanceOf(this.asset().address, this.metadata.additionalInfo.vaultAllocator, this.asset().decimals);
-    logger.verbose(`${this.getTag()} unused balance: ${balance}`);
-    const aumToken = leg1AUM[0].amount.plus(leg2AUM[0].usdValue / token1Price.price).minus(leg1AUM[1].usdValue / token1Price.price).minus(leg2AUM[1].amount).plus(balance);
+    const balance = await this.getUnusedBalance();
+    logger.verbose(`${this.getTag()} unused balance: ${balance.amount.toNumber()}`);
+    const vesuAum = leg1AUM[0].amount.plus(leg2AUM[0].usdValue / token1Price.price).minus(leg1AUM[1].usdValue / token1Price.price).minus(leg2AUM[1].amount);
+    logger.verbose(`${this.getTag()} Vesu AUM: leg1: ${leg1AUM[0].amount.toNumber()}, ${leg1AUM[1].amount.toNumber()}, leg2: ${leg2AUM[0].amount.toNumber()}, ${leg2AUM[1].amount.toNumber()}`);
+    const zeroAmt = Web3Number.fromWei("0", this.asset().decimals);
+    const net = {
+      tokenInfo: this.asset(),
+      amount: zeroAmt,
+      usdValue: 0
+    };
+    const prevAum = Web3Number.fromWei(currentAUM.toString(), this.asset().decimals);
+    if (vesuAum.isZero()) {
+      return { net, splits: [{
+        aum: zeroAmt,
+        id: "finalised" /* FINALISED */
+      }, {
+        aum: zeroAmt,
+        id: "defispring" /* DEFISPRING */
+      }], prevAum };
+    }
+    const aumToken = vesuAum.plus(balance.amount);
     logger.verbose(`${this.getTag()} Actual AUM: ${aumToken}`);
     const netAPY = await this.netAPY();
     const defispringAPY = netAPY.splits.find((s) => s.id === "defispring")?.apy || 0;
     if (!defispringAPY) throw new Error("DefiSpring APY not found");
     const timeDiff = Math.round(Date.now() / 1e3) - Number(lastReportTime);
     const growthRate = timeDiff * defispringAPY / (365 * 24 * 60 * 60);
-    const prevAum = Web3Number.fromWei(currentAUM.toString(), this.asset().decimals);
     const rewardAssets = prevAum.multipliedBy(growthRate);
     logger.verbose(`${this.getTag()} DefiSpring AUM time difference: ${timeDiff}`);
     logger.verbose(`${this.getTag()} Current AUM: ${currentAUM}`);
@@ -25491,16 +23556,13 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     logger.verbose(`${this.getTag()} rewards AUM: ${rewardAssets}`);
     const newAUM = aumToken.plus(rewardAssets);
     logger.verbose(`${this.getTag()} New AUM: ${newAUM}`);
-    const net = {
-      tokenInfo: this.asset(),
-      amount: newAUM,
-      usdValue: newAUM.multipliedBy(token1Price.price).toNumber()
-    };
+    net.amount = newAUM;
+    net.usdValue = newAUM.multipliedBy(token1Price.price).toNumber();
     const splits = [{
-      id: "finalised",
+      id: "finalised" /* FINALISED */,
       aum: aumToken
     }, {
-      id: "defispring",
+      id: "defispring" /* DEFISPRING */,
       aum: rewardAssets
     }];
     return { net, splits, prevAum };
@@ -25551,19 +23613,19 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
       debtAmount: params.debtAmount,
       isBorrow: params.isDeposit
     }));
-    const output2 = [{
+    const output = [{
       proofs: manage5Info.proofs,
       manageCall: manageCall5,
       step: STEP2_ID
     }];
     if (approveAmount.gt(0)) {
-      output2.unshift({
+      output.unshift({
         proofs: manage4Info.proofs,
         manageCall: manageCall4,
         step: STEP1_ID
       });
     }
-    return output2;
+    return output;
   }
   getTag() {
     return `${_UniversalStrategy.name}:${this.metadata.name}`;
@@ -25680,18 +23742,23 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     logger.verbose(`${this.getTag()}:: leg1DepositAmount: ${params.leg1DepositAmount.toString()} ${vesuAdapter1.config.collateral.symbol}`);
     logger.verbose(`${this.getTag()}:: borrow1Amount: ${borrow1Amount.toString()} ${vesuAdapter1.config.debt.symbol}`);
     logger.verbose(`${this.getTag()}:: borrow2Amount: ${borrow2Amount.toString()} ${vesuAdapter2.config.debt.symbol}`);
-    const callSet1 = this.getVesuModifyPositionCalls({
+    let callSet1 = this.getVesuModifyPositionCalls({
       isLeg1: true,
       isDeposit: params.isDeposit,
       depositAmount: params.leg1DepositAmount.plus(borrow2Amount),
       debtAmount: borrow1Amount
     });
-    const callSet2 = this.getVesuModifyPositionCalls({
+    let callSet2 = this.getVesuModifyPositionCalls({
       isLeg1: false,
       isDeposit: params.isDeposit,
       depositAmount: borrow1Amount,
       debtAmount: borrow2Amount
     });
+    if (!params.isDeposit) {
+      let temp = callSet2;
+      callSet2 = [...callSet1];
+      callSet1 = [...temp];
+    }
     const allActions = [...callSet1.map((i) => i.manageCall), ...callSet2.map((i) => i.manageCall)];
     const flashloanCalldata = CallData.compile([
       [...callSet1.map((i) => i.proofs), ...callSet2.map((i) => i.proofs)],
@@ -25709,6 +23776,18 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     const manageCall = this.getManageCall(["flash_loan_init" /* FLASH_LOAN */], [manageCall1]);
     return manageCall;
   }
+  async getBringLiquidityCall(params) {
+    const manage1Info = this.getProofs("approve_bring_liquidity" /* APPROVE_BRING_LIQUIDITY */);
+    const manageCall1 = manage1Info.callConstructor({
+      amount: params.amount
+    });
+    const manage2Info = this.getProofs("bring_liquidity" /* BRING_LIQUIDITY */);
+    const manageCall2 = manage2Info.callConstructor({
+      amount: params.amount
+    });
+    const manageCall = this.getManageCall(["approve_bring_liquidity" /* APPROVE_BRING_LIQUIDITY */, "bring_liquidity" /* BRING_LIQUIDITY */], [manageCall1, manageCall2]);
+    return manageCall;
+  }
   async getRebalanceCall(params) {
     let callSet1 = this.getVesuModifyPositionCalls({
       isLeg1: true,
@@ -25743,6 +23822,8 @@ var UNIVERSAL_MANAGE_IDS = /* @__PURE__ */ ((UNIVERSAL_MANAGE_IDS2) => {
   UNIVERSAL_MANAGE_IDS2["VESU_LEG2"] = "vesu_leg2";
   UNIVERSAL_MANAGE_IDS2["APPROVE_TOKEN1"] = "approve_token1";
   UNIVERSAL_MANAGE_IDS2["APPROVE_TOKEN2"] = "approve_token2";
+  UNIVERSAL_MANAGE_IDS2["APPROVE_BRING_LIQUIDITY"] = "approve_bring_liquidity";
+  UNIVERSAL_MANAGE_IDS2["BRING_LIQUIDITY"] = "bring_liquidity";
   return UNIVERSAL_MANAGE_IDS2;
 })(UNIVERSAL_MANAGE_IDS || {});
 var UNIVERSAL_ADAPTERS = /* @__PURE__ */ ((UNIVERSAL_ADAPTERS2) => {
@@ -25757,7 +23838,9 @@ function getLooperSettings(token1Symbol, token2Symbol, vaultSettings, pool1, poo
   const commonAdapter = new CommonAdapter({
     manager: vaultSettings.manager,
     asset: USDCToken.address,
-    id: "flash_loan_init" /* FLASH_LOAN */
+    id: "flash_loan_init" /* FLASH_LOAN */,
+    vaultAddress: vaultSettings.vaultAddress,
+    vaultAllocator: vaultSettings.vaultAllocator
   });
   const vesuAdapterUSDCETH = new VesuAdapter({
     poolId: pool1,
@@ -25788,13 +23871,17 @@ function getLooperSettings(token1Symbol, token2Symbol, vaultSettings, pool1, poo
   vaultSettings.leafAdapters.push(vesuAdapterETHUSDC.getModifyPosition.bind(vesuAdapterETHUSDC));
   vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(USDCToken.address, vesuAdapterUSDCETH.VESU_SINGLETON, "approve_token1" /* APPROVE_TOKEN1 */).bind(commonAdapter));
   vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(ETHToken.address, vesuAdapterETHUSDC.VESU_SINGLETON, "approve_token2" /* APPROVE_TOKEN2 */).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(USDCToken.address, vaultSettings.vaultAddress, "approve_bring_liquidity" /* APPROVE_BRING_LIQUIDITY */).bind(commonAdapter));
+  vaultSettings.leafAdapters.push(commonAdapter.getBringLiquidityAdapter("bring_liquidity" /* BRING_LIQUIDITY */).bind(commonAdapter));
   return vaultSettings;
 }
 var _riskFactor4 = [
   { type: "Smart Contract Risk" /* SMART_CONTRACT_RISK */, value: 0.5, weight: 25, reason: "Audited by Zellic" },
-  { type: "Liquidation Risk" /* LIQUIDATION_RISK */, value: 1, weight: 50, reason: "Liquidation risk is mitigated btable price feed on Starknet" }
+  { type: "Liquidation Risk" /* LIQUIDATION_RISK */, value: 1.5, weight: 50, reason: "Liquidation risk is mitigated by stable price feed on Starknet" },
+  { type: "Technical Risk" /* TECHNICAL_RISK */, value: 1, weight: 50, reason: "Technical failures like risk monitoring failures" }
 ];
 var usdcVaultSettings = {
+  vaultAddress: ContractAddr.from("0x7e6498cf6a1bfc7e6fc89f1831865e2dacb9756def4ec4b031a9138788a3b5e"),
   manager: ContractAddr.from("0xf41a2b1f498a7f9629db0b8519259e66e964260a23d20003f3e42bb1997a07"),
   vaultAllocator: ContractAddr.from("0x228cca1005d3f2b55cbaba27cb291dacf1b9a92d1d6b1638195fbd3d0c1e3ba"),
   redeemRequestNFT: ContractAddr.from("0x906d03590010868cbf7590ad47043959d7af8e782089a605d9b22567b64fda"),
@@ -25805,6 +23892,7 @@ var usdcVaultSettings = {
   minHealthFactor: 1.25
 };
 var wbtcVaultSettings = {
+  vaultAddress: ContractAddr.from("0x5a4c1651b913aa2ea7afd9024911603152a19058624c3e425405370d62bf80c"),
   manager: ContractAddr.from("0xef8a664ffcfe46a6af550766d27c28937bf1b77fb4ab54d8553e92bca5ba34"),
   vaultAllocator: ContractAddr.from("0x1e01c25f0d9494570226ad28a7fa856c0640505e809c366a9fab4903320e735"),
   redeemRequestNFT: ContractAddr.from("0x4fec59a12f8424281c1e65a80b5de51b4e754625c60cddfcd00d46941ec37b2"),
@@ -25814,10 +23902,176 @@ var wbtcVaultSettings = {
   targetHealthFactor: 1.3,
   minHealthFactor: 1.25
 };
+var ethVaultSettings = {
+  vaultAddress: ContractAddr.from("0x446c22d4d3f5cb52b4950ba832ba1df99464c6673a37c092b1d9622650dbd8"),
+  manager: ContractAddr.from("0x494888b37206616bd09d759dcda61e5118470b9aa7f58fb84f21c778a7b8f97"),
+  vaultAllocator: ContractAddr.from("0x4acc0ad6bea58cb578d60ff7c31f06f44369a7a9a7bbfffe4701f143e427bd"),
+  redeemRequestNFT: ContractAddr.from("0x2e6cd71e5060a254d4db00655e420db7bf89da7755bb0d5f922e2f00c76ac49"),
+  aumOracle: ContractAddr.from("0x4b747f2e75c057bed9aa2ce46fbdc2159dc684c15bd32d4f95983a6ecf39a05"),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.3,
+  minHealthFactor: 1.25
+};
+var strkVaultSettings = {
+  vaultAddress: ContractAddr.from("0x55d012f57e58c96e0a5c7ebbe55853989d01e6538b15a95e7178aca4af05c21"),
+  manager: ContractAddr.from("0xcc6a5153ca56293405506eb20826a379d982cd738008ef7e808454d318fb81"),
+  vaultAllocator: ContractAddr.from("0xf29d2f82e896c0ed74c9eff220af34ac148e8b99846d1ace9fbb02c9191d01"),
+  redeemRequestNFT: ContractAddr.from("0x46902423bd632c428376b84fcee9cac5dbe016214e93a8103bcbde6e1de656b"),
+  aumOracle: ContractAddr.from("0x6d7dbfad4bb51715da211468389a623da00c0625f8f6efbea822ee5ac5231f4"),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.3,
+  minHealthFactor: 1.25
+};
+var usdtVaultSettings = {
+  vaultAddress: ContractAddr.from("0x1c4933d1880c6778585e597154eaca7b428579d72f3aae425ad2e4d26c6bb3"),
+  manager: ContractAddr.from("0x39bb9843503799b552b7ed84b31c06e4ff10c0537edcddfbf01fe944b864029"),
+  vaultAllocator: ContractAddr.from("0x56437d18c43727ac971f6c7086031cad7d9d6ccb340f4f3785a74cc791c931a"),
+  redeemRequestNFT: ContractAddr.from("0x5af0c2a657eaa8e23ed78e855dac0c51e4f69e2cf91a18c472041a1f75bb41f"),
+  aumOracle: ContractAddr.from("0x7018f8040c8066a4ab929e6760ae52dd43b6a3a289172f514750a61fcc565cc"),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.3,
+  minHealthFactor: 1.25
+};
+function MetaVaultDescription() {
+  const logos = {
+    vesu: Protocols.VESU.logo,
+    endur: Protocols.ENDUR.logo,
+    extended: Protocols.EXTENDED.logo,
+    ekubo: "https://dummyimage.com/64x64/ffffff/000000&text=K"
+  };
+  const sources = [
+    { key: "vesu", name: "Vesu", status: "Live", description: "Integrated liquidity venue used for automated routing to capture the best available yield." },
+    { key: "endur", name: "Endur", status: "Coming soon", description: "Planned integration to tap into STRK staking\u2013backed yields via our LST pipeline." },
+    { key: "extended", name: "Extended", status: "Coming soon", description: "Expanding coverage to additional money markets and vaults across the ecosystem." }
+    // { key: "ekubo", name: "Ekubo", status: "Coming soon", description: "Concentrated liquidity strategies targeted for optimized fee APR harvesting." },
+  ];
+  const containerStyle = {
+    maxWidth: "800px",
+    margin: "0 auto",
+    backgroundColor: "#111",
+    color: "#eee",
+    fontFamily: "Arial, sans-serif",
+    borderRadius: "12px"
+  };
+  const cardStyle = {
+    border: "1px solid #333",
+    borderRadius: "10px",
+    padding: "12px",
+    marginBottom: "12px",
+    backgroundColor: "#1a1a1a"
+  };
+  const logoStyle = {
+    width: "24px",
+    height: "24px",
+    borderRadius: "8px",
+    border: "1px solid #444",
+    backgroundColor: "#222"
+  };
+  return /* @__PURE__ */ jsxs3("div", { style: containerStyle, children: [
+    /* @__PURE__ */ jsx4("h1", { style: { fontSize: "18px", marginBottom: "10px" }, children: "Meta Vault \u2014 Automated Yield Router" }),
+    /* @__PURE__ */ jsx4("p", { style: { fontSize: "14px", lineHeight: "1.5", marginBottom: "16px" }, children: "This Evergreen vault is a tokenized Meta Vault, auto-compounding strategy that continuously allocates your deposited asset to the best available yield source in the ecosystem. Depositors receive vault shares that represent a proportional claim on the underlying assets and accrued yield. Allocation shifts are handled programmatically based on on-chain signals and risk filters, minimizing idle capital and maximizing net APY." }),
+    /* @__PURE__ */ jsx4("div", { style: { backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }, children: /* @__PURE__ */ jsxs3("p", { style: { fontSize: "13px", color: "#ccc" }, children: [
+      /* @__PURE__ */ jsx4("strong", { children: "Withdrawals:" }),
+      " Requests can take up to ",
+      /* @__PURE__ */ jsx4("strong", { children: "1-2 hours" }),
+      " to process as the vault unwinds and settles routing."
+    ] }) }),
+    /* @__PURE__ */ jsx4("h2", { style: { fontSize: "18px", marginBottom: "10px" }, children: "Supported Yield Sources" }),
+    sources.map((s) => /* @__PURE__ */ jsx4("div", { style: cardStyle, children: /* @__PURE__ */ jsxs3("div", { style: { display: "flex", gap: "10px", alignItems: "flex-start" }, children: [
+      /* @__PURE__ */ jsx4("img", { src: logos[s.key], alt: `${s.name} logo`, style: logoStyle }),
+      /* @__PURE__ */ jsx4("div", { style: { flex: 1 }, children: /* @__PURE__ */ jsxs3("div", { style: { display: "flex", justifyContent: "space-between", alignItems: "center" }, children: [
+        /* @__PURE__ */ jsx4("h3", { style: { fontSize: "15px", margin: 0 }, children: s.name }),
+        /* @__PURE__ */ jsx4(StatusBadge, { status: s.status })
+      ] }) })
+    ] }) }, s.key))
+  ] });
+}
+function StatusBadge({ status }) {
+  const isSoon = String(status).toLowerCase() !== "live";
+  const badgeStyle = {
+    fontSize: "12px",
+    padding: "2px 6px",
+    borderRadius: "12px",
+    border: "1px solid",
+    color: isSoon ? "rgb(196 196 195)" : "#6aff7d",
+    borderColor: isSoon ? "#484848" : "#6aff7d",
+    backgroundColor: isSoon ? "#424242" : "#002b1a"
+  };
+  return /* @__PURE__ */ jsx4("span", { style: badgeStyle, children: status });
+}
+function getDescription(tokenSymbol) {
+  return MetaVaultDescription();
+}
+function getFAQs() {
+  return [
+    {
+      question: "What is the Meta Vault?",
+      answer: "The Meta Vault is a tokenized strategy that automatically allocates your deposited assets to the best available yield source in the ecosystem. It optimizes returns while minimizing idle capital."
+    },
+    {
+      question: "How does yield allocation work?",
+      answer: "The vault continuously monitors supported protocols and routes liquidity to the source offering the highest net yield after accounting for fees, slippage, and gas costs. Reallocations are performed automatically."
+    },
+    {
+      question: "Which yield sources are supported?",
+      answer: /* @__PURE__ */ jsxs3("span", { children: [
+        "Currently, ",
+        /* @__PURE__ */ jsx4("strong", { children: "Vesu" }),
+        " is live. Future integrations include",
+        " ",
+        /* @__PURE__ */ jsx4("strong", { children: "Endur" }),
+        ", ",
+        /* @__PURE__ */ jsx4("strong", { children: "Extended" }),
+        ", and",
+        " ",
+        /* @__PURE__ */ jsx4("strong", { children: "Ekubo" }),
+        " (all coming soon)."
+      ] })
+    },
+    {
+      question: "What do I receive when I deposit?",
+      answer: "Depositors receive vault tokens representing their proportional share of the vault. These tokens entitle holders to both the principal and accrued yield."
+    },
+    {
+      question: "How long do withdrawals take?",
+      answer: "Withdrawals may take up to 1-2 hours to process, as the vault unwinds and settles liquidity routing across integrated protocols."
+    },
+    {
+      question: "Is the Meta Vault non-custodial?",
+      answer: "Yes. The Meta Vault operates entirely on-chain. Users always maintain control of their vault tokens, and the strategy is fully transparent."
+    },
+    {
+      question: "How is risk managed?",
+      answer: "Integrations are supported with active risk monitoring like liquidation risk. Only vetted protocols are included to balance yield with safety. However, usual Defi risks like smart contract risk, extreme volatile market risk, etc. are still present."
+    },
+    {
+      question: "Are there any fees?",
+      answer: "Troves charges a performance of 10% on the yield generated. The APY shown is net of this fee. This fee is only applied to the profits earned, ensuring that users retain their initial capital."
+    }
+  ];
+}
+function getContractDetails(settings) {
+  return [
+    { address: settings.vaultAddress, name: "Vault" },
+    { address: settings.manager, name: "Vault Manager" },
+    { address: settings.vaultAllocator, name: "Vault Allocator" },
+    { address: settings.redeemRequestNFT, name: "Redeem Request NFT" },
+    { address: settings.aumOracle, name: "AUM Oracle" }
+  ];
+}
+var investmentSteps = [
+  "Deposit funds into the vault",
+  "Vault manager allocates funds to optimal yield sources",
+  "Vault manager reports asset under management (AUM) regularly to the vault",
+  "Request withdrawal and vault manager processes it in 1-2 hours"
+];
 var UniversalStrategies = [
   {
     name: "USDC Evergreen",
-    description: "A universal strategy for managing USDC assets",
+    description: getDescription("USDC"),
     address: ContractAddr.from("0x7e6498cf6a1bfc7e6fc89f1831865e2dacb9756def4ec4b031a9138788a3b5e"),
     launchBlock: 0,
     type: "ERC4626",
@@ -25830,13 +24084,13 @@ var UniversalStrategies = [
     },
     protocols: [Protocols.VESU],
     maxTVL: Web3Number.fromWei(0, 6),
-    contractDetails: [],
-    faqs: [],
-    investmentSteps: []
+    contractDetails: getContractDetails(usdcVaultSettings),
+    faqs: getFAQs(),
+    investmentSteps
   },
   {
     name: "WBTC Evergreen",
-    description: "A universal strategy for managing WBTC assets",
+    description: getDescription("WBTC"),
     address: ContractAddr.from("0x5a4c1651b913aa2ea7afd9024911603152a19058624c3e425405370d62bf80c"),
     launchBlock: 0,
     type: "ERC4626",
@@ -25849,12 +24103,70 @@ var UniversalStrategies = [
     },
     protocols: [Protocols.VESU],
     maxTVL: Web3Number.fromWei(0, 8),
-    contractDetails: [],
-    faqs: [],
-    investmentSteps: []
+    contractDetails: getContractDetails(wbtcVaultSettings),
+    faqs: getFAQs(),
+    investmentSteps
+  },
+  {
+    name: "ETH Evergreen",
+    description: getDescription("ETH"),
+    address: ContractAddr.from("0x446c22d4d3f5cb52b4950ba832ba1df99464c6673a37c092b1d9622650dbd8"),
+    launchBlock: 0,
+    type: "ERC4626",
+    depositTokens: [Global.getDefaultTokens().find((token) => token.symbol === "ETH")],
+    additionalInfo: getLooperSettings("ETH", "WBTC", ethVaultSettings, VesuPools.Genesis, VesuPools.Genesis),
+    risk: {
+      riskFactor: _riskFactor4,
+      netRisk: _riskFactor4.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor4.reduce((acc, curr) => acc + curr.weight, 0),
+      notARisks: getNoRiskTags(_riskFactor4)
+    },
+    protocols: [Protocols.VESU],
+    maxTVL: Web3Number.fromWei(0, 18),
+    contractDetails: getContractDetails(ethVaultSettings),
+    faqs: getFAQs(),
+    investmentSteps
+  },
+  {
+    name: "STRK Evergreen",
+    description: getDescription("STRK"),
+    address: ContractAddr.from("0x55d012f57e58c96e0a5c7ebbe55853989d01e6538b15a95e7178aca4af05c21"),
+    launchBlock: 0,
+    type: "ERC4626",
+    depositTokens: [Global.getDefaultTokens().find((token) => token.symbol === "STRK")],
+    additionalInfo: getLooperSettings("STRK", "ETH", strkVaultSettings, VesuPools.Genesis, VesuPools.Genesis),
+    risk: {
+      riskFactor: _riskFactor4,
+      netRisk: _riskFactor4.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor4.reduce((acc, curr) => acc + curr.weight, 0),
+      notARisks: getNoRiskTags(_riskFactor4)
+    },
+    protocols: [Protocols.VESU],
+    maxTVL: Web3Number.fromWei(0, 18),
+    contractDetails: getContractDetails(strkVaultSettings),
+    faqs: getFAQs(),
+    investmentSteps
+  },
+  {
+    name: "USDT Evergreen",
+    description: getDescription("USDT"),
+    address: ContractAddr.from("0x1c4933d1880c6778585e597154eaca7b428579d72f3aae425ad2e4d26c6bb3"),
+    launchBlock: 0,
+    type: "ERC4626",
+    depositTokens: [Global.getDefaultTokens().find((token) => token.symbol === "USDT")],
+    additionalInfo: getLooperSettings("USDT", "ETH", usdtVaultSettings, VesuPools.Genesis, VesuPools.Genesis),
+    risk: {
+      riskFactor: _riskFactor4,
+      netRisk: _riskFactor4.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor4.reduce((acc, curr) => acc + curr.weight, 0),
+      notARisks: getNoRiskTags(_riskFactor4)
+    },
+    protocols: [Protocols.VESU],
+    maxTVL: Web3Number.fromWei(0, 6),
+    contractDetails: getContractDetails(usdtVaultSettings),
+    faqs: getFAQs(),
+    investmentSteps
   }
 ];
 export {
+  AUMTypes,
   AutoCompounderSTRK,
   AvnuWrapper,
   BaseAdapter,
@@ -25896,26 +24208,3 @@ export {
   getRiskExplaination,
   highlightTextWithLinks
 };
-/*! Bundled license information:
-
-@noble/hashes/esm/utils.js:
-  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-
-@noble/curves/esm/abstract/utils.js:
-  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-
-@noble/curves/esm/abstract/modular.js:
-  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-
-@noble/curves/esm/abstract/poseidon.js:
-  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-
-@noble/curves/esm/abstract/curve.js:
-  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-
-@noble/curves/esm/abstract/weierstrass.js:
-  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-
-@noble/curves/esm/_shortw_utils.js:
-  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-*/