@strkfarm/sdk 1.0.57 → 1.0.59

package/dist/index.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";
 
@@ -1987,2033 +1981,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(hash6) {
-  if (typeof hash6 !== "function" || typeof hash6.create !== "function")
-    throw new Error("Hash should be wrapped by utils.wrapConstructor");
-  number(hash6.outputLen);
-  number(hash6.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/cryptoNode.js
-import * as nc from "crypto";
-var crypto = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : 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(num11) {
-  const hex = num11.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(num11, 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 * num11 % modulo;
-    num11 = num11 * num11 % 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, num11, power) {
-  if (power < _0n2)
-    throw new Error("Expected power > 0");
-  if (power === _0n2)
-    return f.ONE;
-  if (power === _1n2)
-    return num11;
-  let p = f.ONE;
-  let d = num11;
-  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, num11, i) => {
-    if (f.is0(num11))
-      return acc;
-    tmp[i] = acc;
-    return f.mul(acc, num11);
-  }, f.ONE);
-  const inverted = f.inv(lastMultiplied);
-  nums.reduceRight((acc, num11, i) => {
-    if (f.is0(num11))
-      return acc;
-    tmp[i] = f.mul(acc, tmp[i]);
-    return f.mul(acc, num11);
-  }, 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: (num11) => mod(num11, ORDER),
-    isValid: (num11) => {
-      if (typeof num11 !== "bigint")
-        throw new Error(`Invalid field element: expected bigint, got ${typeof num11}`);
-      return _0n2 <= num11 && num11 < ORDER;
-    },
-    is0: (num11) => num11 === _0n2,
-    isOdd: (num11) => (num11 & _1n2) === _1n2,
-    neg: (num11) => mod(-num11, ORDER),
-    eql: (lhs, rhs) => lhs === rhs,
-    sqr: (num11) => mod(num11 * num11, ORDER),
-    add: (lhs, rhs) => mod(lhs + rhs, ORDER),
-    sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
-    mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
-    pow: (num11, power) => FpPow(f, num11, power),
-    div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
-    // Same as above, but doesn't normalize
-    sqrN: (num11) => num11 * num11,
-    addN: (lhs, rhs) => lhs + rhs,
-    subN: (lhs, rhs) => lhs - rhs,
-    mulN: (lhs, rhs) => lhs * rhs,
-    inv: (num11) => invert(num11, 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: (num11) => isLE2 ? numberToBytesLE(num11, BYTES) : numberToBytesBE(num11, 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 num11 = isLE2 ? bytesToNumberBE(key) : bytesToNumberLE(key);
-  const reduced = mod(num11, 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 = (num11) => {
-      const hex = num11.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(num11) {
-    return typeof num11 === "bigint" && _0n4 < num11 && num11 < CURVE2.n;
-  }
-  function assertGE(num11) {
-    if (!isWithinCurveOrder(num11))
-      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 num11;
-    try {
-      num11 = 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)
-      num11 = mod(num11, n);
-    assertGE(num11);
-    return num11;
-  }
-  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(num11) {
-    return _0n4 < num11 && num11 < 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 = (num11) => bytesToHex(numberToBytesBE(num11, 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 num11 = bytesToNumberBE(bytes2);
-    const delta = bytes2.length * 8 - CURVE2.nBitLength;
-    return delta > 0 ? num11 >> BigInt(delta) : num11;
-  };
-  const bits2int_modN = CURVE2.bits2int_modN || function(bytes2) {
-    return modN(bits2int2(bytes2));
-  };
-  const ORDER_MASK = bitMask(CURVE2.nBitLength);
-  function int2octets(num11) {
-    if (typeof num11 !== "bigint")
-      throw new Error("bigint expected");
-    if (!(_0n4 <= num11 && num11 < ORDER_MASK))
-      throw new Error(`bigint expected < 2^${CURVE2.nBitLength}`);
-    return numberToBytesBE(num11, 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: hash6, randomBytes: randomBytes4 } = CURVE2;
-    let { lowS, prehash, extraEntropy: ent } = opts;
-    if (lowS == null)
-      lowS = true;
-    msgHash = ensureBytes("msgHash", msgHash);
-    if (prehash)
-      msgHash = ensureBytes("prehashed msgHash", hash6(msgHash));
-    const h1int = bits2int_modN(msgHash);
-    const d = normPrivateKeyToScalar(privateKey);
-    const seedArgs = [int2octets(d), int2octets(h1int)];
-    if (ent != null) {
-      const e = ent === true ? randomBytes4(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(hash6, _key) {
-    super();
-    this.finished = false;
-    this.destroyed = false;
-    hash(hash6);
-    const key = toBytes(_key);
-    this.iHash = hash6.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 ? hash6.create().update(key).digest() : key);
-    for (let i = 0; i < pad.length; i++)
-      pad[i] ^= 54;
-    this.iHash.update(pad);
-    this.oHash = hash6.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 = (hash6, key, message) => new HMAC(hash6, key).update(message).digest();
-hmac.create = (hash6, key) => new HMAC(hash6, key);
-
-// ../node_modules/@noble/curves/esm/_shortw_utils.js
-function getHash(hash6) {
-  return {
-    hash: hash6,
-    hmac: (key, ...msgs) => hmac(hash6, 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 num11 = bytesToNumberBE(bytes2);
-  return delta > 0 ? num11 >> BigInt(delta) : num11;
-}
-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, constants3) {
-  let x = pedersenArg(value);
-  for (let j = 0; j < 252; j++) {
-    const pt = constants3[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");
@@ -4026,7 +1994,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) {
@@ -4183,6 +2151,7 @@ function getMainnetConfig(rpcUrl = "https://starknet-mainnet.public.blastapi.io"
     provider: new RpcProvider2({
       nodeUrl: rpcUrl,
       blockIdentifier
+      // specVersion
     }),
     stage: "production",
     network: "mainnet" /* mainnet */
@@ -17938,7 +15907,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,
@@ -17946,9 +15915,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");
@@ -20503,7 +18472,7 @@ 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");
@@ -20529,7 +18498,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
@@ -20539,7 +18508,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();
@@ -20569,7 +18538,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
@@ -20608,7 +18577,7 @@ var CommonAdapter = class extends BaseAdapter {
         sanitizer: SIMPLE_SANITIZER,
         call: {
           contractAddress: token,
-          selector: hash3.getSelectorFromName("approve"),
+          selector: hash2.getSelectorFromName("approve"),
           calldata: [
             spender.toBigInt(),
             // spender
@@ -20624,7 +18593,7 @@ var CommonAdapter = class extends BaseAdapter {
 };
 
 // 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 = [
@@ -22907,13 +20876,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 = {
@@ -22950,7 +20919,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
           ]
@@ -23006,8 +20975,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) {
@@ -23019,7 +20988,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,
@@ -23027,8 +20996,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,
@@ -23052,14 +21021,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(),
@@ -23076,8 +21045,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();
@@ -25345,6 +23314,11 @@ var vault_manager_abi_default = [
 ];
 
 // src/strategies/universal-strategy.ts
+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);
@@ -25429,6 +23403,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
@@ -25475,14 +23462,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"
@@ -25517,6 +23514,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", []);
@@ -25524,14 +23531,32 @@ 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 aumToken = leg1AUM[0].amount.plus(leg2AUM[0].usdValue / token1Price.price).minus(leg1AUM[1].usdValue / token1Price.price).minus(leg2AUM[1].amount);
+    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);
+    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}`);
@@ -25539,16 +23564,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 };
@@ -25599,19 +23621,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}`;
@@ -25846,6 +23868,7 @@ var usdcVaultSettings = {
   manager: ContractAddr.from("0xf41a2b1f498a7f9629db0b8519259e66e964260a23d20003f3e42bb1997a07"),
   vaultAllocator: ContractAddr.from("0x228cca1005d3f2b55cbaba27cb291dacf1b9a92d1d6b1638195fbd3d0c1e3ba"),
   redeemRequestNFT: ContractAddr.from("0x906d03590010868cbf7590ad47043959d7af8e782089a605d9b22567b64fda"),
+  aumOracle: ContractAddr.from("0x6faf45ed185dec13ef723c9ead4266cab98d06f2cb237e331b1fa5c2aa79afe"),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.3,
@@ -25855,6 +23878,37 @@ var wbtcVaultSettings = {
   manager: ContractAddr.from("0xef8a664ffcfe46a6af550766d27c28937bf1b77fb4ab54d8553e92bca5ba34"),
   vaultAllocator: ContractAddr.from("0x1e01c25f0d9494570226ad28a7fa856c0640505e809c366a9fab4903320e735"),
   redeemRequestNFT: ContractAddr.from("0x4fec59a12f8424281c1e65a80b5de51b4e754625c60cddfcd00d46941ec37b2"),
+  aumOracle: ContractAddr.from("0x2edf4edbed3f839e7f07dcd913e92299898ff4cf0ba532f8c572c66c5b331b2"),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.3,
+  minHealthFactor: 1.25
+};
+var ethVaultSettings = {
+  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 = {
+  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 = {
+  manager: ContractAddr.from("0x39bb9843503799b552b7ed84b31c06e4ff10c0537edcddfbf01fe944b864029"),
+  vaultAllocator: ContractAddr.from("0x56437d18c43727ac971f6c7086031cad7d9d6ccb340f4f3785a74cc791c931a"),
+  redeemRequestNFT: ContractAddr.from("0x5af0c2a657eaa8e23ed78e855dac0c51e4f69e2cf91a18c472041a1f75bb41f"),
+  aumOracle: ContractAddr.from("0x7018f8040c8066a4ab929e6760ae52dd43b6a3a289172f514750a61fcc565cc"),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.3,
@@ -25898,6 +23952,63 @@ var UniversalStrategies = [
     contractDetails: [],
     faqs: [],
     investmentSteps: []
+  },
+  {
+    name: "ETH Evergreen",
+    description: "A universal strategy for managing ETH assets",
+    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: [],
+    faqs: [],
+    investmentSteps: []
+  },
+  {
+    name: "STRK Evergreen",
+    description: "A universal strategy for managing STRK assets",
+    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: [],
+    faqs: [],
+    investmentSteps: []
+  },
+  {
+    name: "USDT Evergreen",
+    description: "A universal strategy for managing USDT assets",
+    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: [],
+    faqs: [],
+    investmentSteps: []
   }
 ];
 
@@ -26004,16 +24115,16 @@ var PricerRedis = class extends Pricer {
 
 // src/node/deployer.ts
 import assert2 from "assert";
-import { TransactionExecutionStatus, constants as constants2, extractContractHashes, json, num as num10, transaction } from "starknet";
+import { TransactionExecutionStatus, constants as constants3, extractContractHashes, json, num as num10, transaction } from "starknet";
 import { readFileSync as readFileSync2, existsSync, writeFileSync as writeFileSync2 } from "fs";
 
 // src/utils/store.ts
 import fs, { readFileSync, writeFileSync } from "fs";
-import { Account as Account3, constants } from "starknet";
-import * as crypto3 from "crypto";
+import { Account as Account3, constants as constants2 } from "starknet";
+import * as crypto2 from "crypto";
 
 // src/utils/encrypt.ts
-import * as crypto2 from "crypto";
+import * as crypto from "crypto";
 var PasswordJsonCryptoUtil = class {
   constructor() {
     this.algorithm = "aes-256-gcm";
@@ -26029,14 +24140,14 @@ var PasswordJsonCryptoUtil = class {
   }
   // Number of iterations for PBKDF2
   deriveKey(password, salt) {
-    return crypto2.pbkdf2Sync(password, salt, this.pbkdf2Iterations, this.keyLength, "sha256");
+    return crypto.pbkdf2Sync(password, salt, this.pbkdf2Iterations, this.keyLength, "sha256");
   }
   encrypt(data, password) {
     const jsonString = JSON.stringify(data);
-    const salt = crypto2.randomBytes(this.saltLength);
-    const iv = crypto2.randomBytes(this.ivLength);
+    const salt = crypto.randomBytes(this.saltLength);
+    const iv = crypto.randomBytes(this.ivLength);
     const key = this.deriveKey(password, salt);
-    const cipher = crypto2.createCipheriv(this.algorithm, key, iv, { authTagLength: this.tagLength });
+    const cipher = crypto.createCipheriv(this.algorithm, key, iv, { authTagLength: this.tagLength });
     let encrypted = cipher.update(jsonString, "utf8", "hex");
     encrypted += cipher.final("hex");
     const tag = cipher.getAuthTag();
@@ -26049,7 +24160,7 @@ var PasswordJsonCryptoUtil = class {
     const tag = data.subarray(this.saltLength + this.ivLength, this.saltLength + this.ivLength + this.tagLength);
     const encrypted = data.subarray(this.saltLength + this.ivLength + this.tagLength);
     const key = this.deriveKey(password, salt);
-    const decipher = crypto2.createDecipheriv(this.algorithm, key, iv, { authTagLength: this.tagLength });
+    const decipher = crypto.createDecipheriv(this.algorithm, key, iv, { authTagLength: this.tagLength });
     decipher.setAuthTag(tag);
     try {
       let decrypted = decipher.update(encrypted.toString("hex"), "hex", "utf8");
@@ -26070,7 +24181,7 @@ function getDefaultStoreConfig(network) {
     SECRET_FILE_FOLDER: `${process.env.HOME}/.starknet-store`,
     NETWORK: network,
     ACCOUNTS_FILE_NAME: "accounts.json",
-    PASSWORD: crypto3.randomBytes(16).toString("hex")
+    PASSWORD: crypto2.randomBytes(16).toString("hex")
   };
 }
 var Store = class _Store {
@@ -26094,7 +24205,7 @@ var Store = class _Store {
     logger.warn(`This not stored anywhere, please you backup this password for future use`);
     logger.warn(`\u26A0\uFE0F=========================================\u26A0\uFE0F`);
   }
-  getAccount(accountKey, txVersion = constants.TRANSACTION_VERSION.V2) {
+  getAccount(accountKey, txVersion = constants2.TRANSACTION_VERSION.V2) {
     const accounts = this.loadAccounts();
     logger.verbose(`nAccounts loaded for network: ${Object.keys(accounts).length}`);
     const data = accounts[accountKey];
@@ -26188,7 +24299,7 @@ function getAccount(accountKey, config, password = process.env.ACCOUNT_SECURE_PA
     ...storeConfig,
     PASSWORD: password
   });
-  return store.getAccount(accountKey);
+  return store.getAccount(accountKey, "0x3");
 }
 async function myDeclare(contract_name, package_name = "strkfarm", config, acc) {
   const provider2 = config.provider;
@@ -26238,7 +24349,7 @@ async function deployContract(contract_name, classHash, constructorData, config,
     classHash,
     constructorCalldata: constructorData
   });
-  console.log("Deploy fee", contract_name, Number(fee.suggestedMaxFee) / 10 ** 18, "ETH");
+  console.log("Deploy fee", contract_name, Number(fee.overall_fee) / 10 ** 18, "ETH");
   const tx = await acc.deployContract({
     classHash,
     constructorCalldata: constructorData
@@ -26280,7 +24391,7 @@ async function prepareMultiDeployContracts(contracts, config, acc) {
 }
 async function executeDeployCalls(contractsInfo, acc, provider2) {
   for (let contractInfo of contractsInfo) {
-    assert2(num10.toHexString(contractInfo.call.contractAddress) == num10.toHexString(constants2.UDC.ADDRESS), "Must be pointed at UDC address");
+    assert2(num10.toHexString(contractInfo.call.contractAddress) == num10.toHexString(constants3.UDC.ADDRESS), "Must be pointed at UDC address");
   }
   const allCalls = contractsInfo.map((info) => info.call);
   await executeTransactions(allCalls, acc, provider2, `Deploying contracts: ${contractsInfo.map((info) => info.contract_name).join(", ")}`);
@@ -26319,6 +24430,7 @@ var Deployer = {
 };
 var deployer_default = Deployer;
 export {
+  AUMTypes,
   AutoCompounderSTRK,
   AvnuWrapper,
   BaseAdapter,
@@ -26371,26 +24483,3 @@ export {
   highlightTextWithLinks,
   logger
 };
-/*! 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) *)
-*/