@strkfarm/sdk 1.0.62 → 1.0.64

package/dist/index.browser.global.js

@@ -60,7 +60,7 @@ var strkfarm_risk_engine = (() => {
             fractionGroupSize: 0
           };
           function BigNumber3(n, b) {
-            var c, e, i, num4, len, str, x = this;
+            var c, e, i, num2, len, str, x = this;
             if (!(x instanceof BigNumber3)) {
               if (ERRORS) raise(26, "constructor call without new", n);
               return new BigNumber3(n, b);
@@ -73,7 +73,7 @@ var strkfarm_risk_engine = (() => {
                 id = 0;
                 return;
               }
-              if ((num4 = typeof n == "number") && n * 0 == 0) {
+              if ((num2 = typeof n == "number") && n * 0 == 0) {
                 x.s = 1 / n < 0 ? (n = -n, -1) : 1;
                 if (n === ~~n) {
                   for (e = 0, i = n; i >= 10; i /= 10, e++) ;
@@ -84,7 +84,7 @@ var strkfarm_risk_engine = (() => {
                 }
                 str = n + "";
               } else {
-                if (!isNumeric.test(str = n + "")) return parseNumeric(x, str, num4);
+                if (!isNumeric.test(str = n + "")) return parseNumeric(x, str, num2);
                 x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;
               }
             } else {
@@ -94,15 +94,15 @@ var strkfarm_risk_engine = (() => {
                 x = new BigNumber3(n instanceof BigNumber3 ? n : str);
                 return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);
               }
-              if ((num4 = typeof n == "number") && n * 0 != 0 || !new RegExp("^-?" + (c = "[" + ALPHABET.slice(0, b) + "]+") + "(?:\\." + c + ")?$", b < 37 ? "i" : "").test(str)) {
-                return parseNumeric(x, str, num4, b);
+              if ((num2 = typeof n == "number") && n * 0 != 0 || !new RegExp("^-?" + (c = "[" + ALPHABET.slice(0, b) + "]+") + "(?:\\." + c + ")?$", b < 37 ? "i" : "").test(str)) {
+                return parseNumeric(x, str, num2, b);
               }
-              if (num4) {
+              if (num2) {
                 x.s = 1 / n < 0 ? (str = str.slice(1), -1) : 1;
                 if (ERRORS && str.replace(/^0\.0*|\./, "").length > 15) {
                   raise(id, tooManyDigits, n);
                 }
-                num4 = false;
+                num2 = false;
               } else {
                 x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;
               }
@@ -121,7 +121,7 @@ var strkfarm_risk_engine = (() => {
             str = str.slice(i, len + 1);
             if (str) {
               len = str.length;
-              if (num4 && ERRORS && len > 15 && (n > MAX_SAFE_INTEGER || n !== mathfloor(n))) {
+              if (num2 && ERRORS && len > 15 && (n > MAX_SAFE_INTEGER || n !== mathfloor(n))) {
                 raise(id, tooManyDigits, x.s * n);
               }
               e = e - i - 1;
@@ -584,12 +584,12 @@ var strkfarm_risk_engine = (() => {
           }
           parseNumeric = /* @__PURE__ */ (function() {
             var basePrefix = /^(-?)0([xbo])(?=\w[\w.]*$)/i, dotAfter = /^([^.]+)\.$/, dotBefore = /^\.([^.]+)$/, isInfinityOrNaN = /^-?(Infinity|NaN)$/, whitespaceOrPlus = /^\s*\+(?=[\w.])|^\s+|\s+$/g;
-            return function(x, str, num4, b) {
-              var base2, s = num4 ? str : str.replace(whitespaceOrPlus, "");
+            return function(x, str, num2, b) {
+              var base2, s = num2 ? str : str.replace(whitespaceOrPlus, "");
               if (isInfinityOrNaN.test(s)) {
                 x.s = isNaN(s) ? null : s < 0 ? -1 : 1;
               } else {
-                if (!num4) {
+                if (!num2) {
                   s = s.replace(basePrefix, function(m, p1, p2) {
                     base2 = (p2 = p2.toLowerCase()) == "x" ? 16 : p2 == "b" ? 2 : 8;
                     return !b || b == base2 ? p1 : m;
@@ -2694,18 +2694,18 @@ var strkfarm_risk_engine = (() => {
         }
         for (let i = 0; i < 3; i++) {
           const trailingOK = i == 2;
-          const num4 = parseDigits(parts[i], 1, 2, trailingOK);
-          if (num4 === null) {
+          const num2 = parseDigits(parts[i], 1, 2, trailingOK);
+          if (num2 === null) {
             return null;
           }
-          result[i] = num4;
+          result[i] = num2;
         }
         return result;
       }
       function parseMonth(token) {
         token = String(token).substr(0, 3).toLowerCase();
-        const num4 = MONTH_TO_NUM[token];
-        return num4 >= 0 ? num4 : null;
+        const num2 = MONTH_TO_NUM[token];
+        return num2 >= 0 ? num2 : null;
       }
       function parseDate(str) {
         if (!str) {
@@ -4919,14 +4919,14 @@ var strkfarm_risk_engine = (() => {
       var gPO = (typeof Reflect === "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) {
         return O.__proto__;
       } : null);
-      function addNumericSeparator(num4, str) {
-        if (num4 === Infinity || num4 === -Infinity || num4 !== num4 || num4 && num4 > -1e3 && num4 < 1e3 || $test.call(/e/, str)) {
+      function addNumericSeparator(num2, str) {
+        if (num2 === Infinity || num2 === -Infinity || num2 !== num2 || num2 && num2 > -1e3 && num2 < 1e3 || $test.call(/e/, str)) {
           return str;
         }
         var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
-        if (typeof num4 === "number") {
-          var int = num4 < 0 ? -$floor(-num4) : $floor(num4);
-          if (int !== num4) {
+        if (typeof num2 === "number") {
+          var int = num2 < 0 ? -$floor(-num2) : $floor(num2);
+          if (int !== num2) {
             var intStr = String(int);
             var dec = $slice.call(str, intStr.length + 1);
             return $replace.call(intStr, sepRegex, "$&_") + "." + $replace.call($replace.call(dec, /([0-9]{3})/g, "$&_"), /_$/, "");
@@ -8439,18 +8439,18 @@ var strkfarm_risk_engine = (() => {
         return res;
       }
       // @__NO_SIDE_EFFECTS__
-      function radix(num4) {
-        /* @__PURE__ */ assertNumber2(num4);
+      function radix(num2) {
+        /* @__PURE__ */ assertNumber2(num2);
         return {
           encode: (bytes3) => {
             if (!isBytes10(bytes3))
               throw new Error("radix.encode input should be Uint8Array");
-            return /* @__PURE__ */ convertRadix(Array.from(bytes3), 2 ** 8, num4);
+            return /* @__PURE__ */ convertRadix(Array.from(bytes3), 2 ** 8, num2);
           },
           decode: (digits) => {
             if (!Array.isArray(digits) || digits.length && typeof digits[0] !== "number")
               throw new Error("radix.decode input should be array of numbers");
-            return Uint8Array.from(/* @__PURE__ */ convertRadix(digits, num4, 2 ** 8));
+            return Uint8Array.from(/* @__PURE__ */ convertRadix(digits, num2, 2 ** 8));
           }
         };
       }
@@ -8749,8 +8749,8 @@ var strkfarm_risk_engine = (() => {
         }
         return hex;
       }
-      function numberToHexUnpadded4(num4) {
-        const hex = num4.toString(16);
+      function numberToHexUnpadded4(num2) {
+        const hex = num2.toString(16);
         return hex.length & 1 ? `0${hex}` : hex;
       }
       function hexToNumber4(hex) {
@@ -10293,8 +10293,8 @@ var strkfarm_risk_engine = (() => {
         return hex;
       }
       exports.bytesToHex = bytesToHex4;
-      function numberToHexUnpadded4(num4) {
-        const hex = num4.toString(16);
+      function numberToHexUnpadded4(num2) {
+        const hex = num2.toString(16);
         return hex.length & 1 ? `0${hex}` : hex;
       }
       exports.numberToHexUnpadded = numberToHexUnpadded4;
@@ -10530,7 +10530,7 @@ var strkfarm_risk_engine = (() => {
         return result >= _0n16 ? result : b + result;
       }
       exports.mod = mod4;
-      function pow3(num4, power, modulo) {
+      function pow3(num2, power, modulo) {
         if (modulo <= _0n16 || power < _0n16)
           throw new Error("Expected power/modulo > 0");
         if (modulo === _1n16)
@@ -10538,8 +10538,8 @@ var strkfarm_risk_engine = (() => {
         let res = _1n16;
         while (power > _0n16) {
           if (power & _1n16)
-            res = res * num4 % modulo;
-          num4 = num4 * num4 % modulo;
+            res = res * num2 % modulo;
+          num2 = num2 * num2 % modulo;
           power >>= _1n16;
         }
         return res;
@@ -10645,7 +10645,7 @@ var strkfarm_risk_engine = (() => {
         return tonelliShanks4(P);
       }
       exports.FpSqrt = FpSqrt4;
-      var isNegativeLE = (num4, modulo) => (mod4(num4, modulo) & _1n16) === _1n16;
+      var isNegativeLE = (num2, modulo) => (mod4(num2, modulo) & _1n16) === _1n16;
       exports.isNegativeLE = isNegativeLE;
       var FIELD_FIELDS4 = [
         "create",
@@ -10680,15 +10680,15 @@ var strkfarm_risk_engine = (() => {
         return (0, utils_js_1.validateObject)(field, opts);
       }
       exports.validateField = validateField4;
-      function FpPow4(f, num4, power) {
+      function FpPow4(f, num2, power) {
         if (power < _0n16)
           throw new Error("Expected power > 0");
         if (power === _0n16)
           return f.ONE;
         if (power === _1n16)
-          return num4;
+          return num2;
         let p = f.ONE;
-        let d = num4;
+        let d = num2;
         while (power > _0n16) {
           if (power & _1n16)
             p = f.mul(p, d);
@@ -10700,18 +10700,18 @@ var strkfarm_risk_engine = (() => {
       exports.FpPow = FpPow4;
       function FpInvertBatch4(f, nums) {
         const tmp = new Array(nums.length);
-        const lastMultiplied = nums.reduce((acc, num4, i) => {
-          if (f.is0(num4))
+        const lastMultiplied = nums.reduce((acc, num2, i) => {
+          if (f.is0(num2))
             return acc;
           tmp[i] = acc;
-          return f.mul(acc, num4);
+          return f.mul(acc, num2);
         }, f.ONE);
         const inverted = f.inv(lastMultiplied);
-        nums.reduceRight((acc, num4, i) => {
-          if (f.is0(num4))
+        nums.reduceRight((acc, num2, i) => {
+          if (f.is0(num2))
             return acc;
           tmp[i] = f.mul(acc, tmp[i]);
-          return f.mul(acc, num4);
+          return f.mul(acc, num2);
         }, inverted);
         return tmp;
       }
@@ -10748,34 +10748,34 @@ var strkfarm_risk_engine = (() => {
           MASK: (0, utils_js_1.bitMask)(BITS),
           ZERO: _0n16,
           ONE: _1n16,
-          create: (num4) => mod4(num4, ORDER),
-          isValid: (num4) => {
-            if (typeof num4 !== "bigint")
-              throw new Error(`Invalid field element: expected bigint, got ${typeof num4}`);
-            return _0n16 <= num4 && num4 < ORDER;
+          create: (num2) => mod4(num2, ORDER),
+          isValid: (num2) => {
+            if (typeof num2 !== "bigint")
+              throw new Error(`Invalid field element: expected bigint, got ${typeof num2}`);
+            return _0n16 <= num2 && num2 < ORDER;
           },
-          is0: (num4) => num4 === _0n16,
-          isOdd: (num4) => (num4 & _1n16) === _1n16,
-          neg: (num4) => mod4(-num4, ORDER),
+          is0: (num2) => num2 === _0n16,
+          isOdd: (num2) => (num2 & _1n16) === _1n16,
+          neg: (num2) => mod4(-num2, ORDER),
           eql: (lhs, rhs) => lhs === rhs,
-          sqr: (num4) => mod4(num4 * num4, ORDER),
+          sqr: (num2) => mod4(num2 * num2, ORDER),
           add: (lhs, rhs) => mod4(lhs + rhs, ORDER),
           sub: (lhs, rhs) => mod4(lhs - rhs, ORDER),
           mul: (lhs, rhs) => mod4(lhs * rhs, ORDER),
-          pow: (num4, power) => FpPow4(f, num4, power),
+          pow: (num2, power) => FpPow4(f, num2, power),
           div: (lhs, rhs) => mod4(lhs * invert4(rhs, ORDER), ORDER),
           // Same as above, but doesn't normalize
-          sqrN: (num4) => num4 * num4,
+          sqrN: (num2) => num2 * num2,
           addN: (lhs, rhs) => lhs + rhs,
           subN: (lhs, rhs) => lhs - rhs,
           mulN: (lhs, rhs) => lhs * rhs,
-          inv: (num4) => invert4(num4, ORDER),
+          inv: (num2) => invert4(num2, ORDER),
           sqrt: redef.sqrt || ((n) => sqrtP(f, n)),
           invertBatch: (lst) => FpInvertBatch4(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: (num4) => isLE4 ? (0, utils_js_1.numberToBytesLE)(num4, BYTES) : (0, utils_js_1.numberToBytesBE)(num4, BYTES),
+          toBytes: (num2) => isLE4 ? (0, utils_js_1.numberToBytesLE)(num2, BYTES) : (0, utils_js_1.numberToBytesBE)(num2, BYTES),
           fromBytes: (bytes3) => {
             if (bytes3.length !== BYTES)
               throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes3.length}`);
@@ -10805,8 +10805,8 @@ var strkfarm_risk_engine = (() => {
         const minLen = nLength4(groupOrder).nByteLength + 8;
         if (minLen < 24 || hashLen < minLen || hashLen > 1024)
           throw new Error(`hashToPrivateScalar: expected ${minLen}-1024 bytes of input, got ${hashLen}`);
-        const num4 = isLE4 ? (0, utils_js_1.bytesToNumberLE)(hash4) : (0, utils_js_1.bytesToNumberBE)(hash4);
-        return mod4(num4, groupOrder - _1n16) + _1n16;
+        const num2 = isLE4 ? (0, utils_js_1.bytesToNumberLE)(hash4) : (0, utils_js_1.bytesToNumberBE)(hash4);
+        return mod4(num2, groupOrder - _1n16) + _1n16;
       }
       exports.hashToPrivateScalar = hashToPrivateScalar;
       function getFieldBytesLength4(fieldOrder) {
@@ -10827,8 +10827,8 @@ var strkfarm_risk_engine = (() => {
         const minLen = getMinHashLength4(fieldOrder);
         if (len < 16 || len < minLen || len > 1024)
           throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
-        const num4 = isLE4 ? (0, utils_js_1.bytesToNumberBE)(key) : (0, utils_js_1.bytesToNumberLE)(key);
-        const reduced = mod4(num4, fieldOrder - _1n16) + _1n16;
+        const num2 = isLE4 ? (0, utils_js_1.bytesToNumberBE)(key) : (0, utils_js_1.bytesToNumberLE)(key);
+        const reduced = mod4(num2, fieldOrder - _1n16) + _1n16;
         return isLE4 ? (0, utils_js_1.numberToBytesLE)(reduced, fieldLen) : (0, utils_js_1.numberToBytesBE)(reduced, fieldLen);
       }
       exports.mapHashToField = mapHashToField4;
@@ -11149,8 +11149,8 @@ var strkfarm_risk_engine = (() => {
         },
         hexFromSig(sig) {
           const slice = (s2) => Number.parseInt(s2[0], 16) & 8 ? "00" + s2 : s2;
-          const h = (num4) => {
-            const hex = num4.toString(16);
+          const h = (num2) => {
+            const hex = num2.toString(16);
             return hex.length & 1 ? `0${hex}` : hex;
           };
           const s = slice(h(sig.s));
@@ -11188,11 +11188,11 @@ var strkfarm_risk_engine = (() => {
         }
         if (!Fp2.eql(Fp2.sqr(CURVE2.Gy), weierstrassEquation(CURVE2.Gx)))
           throw new Error("bad generator point: equation left != right");
-        function isWithinCurveOrder(num4) {
-          return typeof num4 === "bigint" && _0n16 < num4 && num4 < CURVE2.n;
+        function isWithinCurveOrder(num2) {
+          return typeof num2 === "bigint" && _0n16 < num2 && num2 < CURVE2.n;
         }
-        function assertGE(num4) {
-          if (!isWithinCurveOrder(num4))
+        function assertGE(num2) {
+          if (!isWithinCurveOrder(num2))
             throw new Error("Expected valid bigint: 0 < bigint < curve.n");
         }
         function normPrivateKeyToScalar(key) {
@@ -11204,16 +11204,16 @@ var strkfarm_risk_engine = (() => {
               throw new Error("Invalid key");
             key = key.padStart(nByteLength * 2, "0");
           }
-          let num4;
+          let num2;
           try {
-            num4 = typeof key === "bigint" ? key : ut.bytesToNumberBE((0, utils_js_1.ensureBytes)("private key", key, nByteLength));
+            num2 = typeof key === "bigint" ? key : ut.bytesToNumberBE((0, utils_js_1.ensureBytes)("private key", key, nByteLength));
           } catch (error2) {
             throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
           }
           if (wrapPrivateKey)
-            num4 = mod4.mod(num4, n);
-          assertGE(num4);
-          return num4;
+            num2 = mod4.mod(num2, n);
+          assertGE(num2);
+          return num2;
         }
         const pointPrecomputes2 = /* @__PURE__ */ new Map();
         function assertPrjPoint(other) {
@@ -11575,8 +11575,8 @@ var strkfarm_risk_engine = (() => {
         const { Fp: Fp2, n: CURVE_ORDER3 } = CURVE2;
         const compressedLen = Fp2.BYTES + 1;
         const uncompressedLen = 2 * Fp2.BYTES + 1;
-        function isValidFieldElement(num4) {
-          return _0n16 < num4 && num4 < Fp2.ORDER;
+        function isValidFieldElement(num2) {
+          return _0n16 < num2 && num2 < Fp2.ORDER;
         }
         function modN(a) {
           return mod4.mod(a, CURVE_ORDER3);
@@ -11620,7 +11620,7 @@ var strkfarm_risk_engine = (() => {
             }
           }
         });
-        const numToNByteStr = (num4) => ut.bytesToHex(ut.numberToBytesBE(num4, CURVE2.nByteLength));
+        const numToNByteStr = (num2) => ut.bytesToHex(ut.numberToBytesBE(num2, CURVE2.nByteLength));
         function isBiggerThanHalfOrder(number3) {
           const HALF = CURVE_ORDER3 >> _1n16;
           return number3 > HALF;
@@ -11754,20 +11754,20 @@ var strkfarm_risk_engine = (() => {
           return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
         }
         const bits2int3 = CURVE2.bits2int || function(bytes3) {
-          const num4 = ut.bytesToNumberBE(bytes3);
+          const num2 = ut.bytesToNumberBE(bytes3);
           const delta = bytes3.length * 8 - CURVE2.nBitLength;
-          return delta > 0 ? num4 >> BigInt(delta) : num4;
+          return delta > 0 ? num2 >> BigInt(delta) : num2;
         };
         const bits2int_modN = CURVE2.bits2int_modN || function(bytes3) {
           return modN(bits2int3(bytes3));
         };
         const ORDER_MASK = ut.bitMask(CURVE2.nBitLength);
-        function int2octets(num4) {
-          if (typeof num4 !== "bigint")
+        function int2octets(num2) {
+          if (typeof num2 !== "bigint")
             throw new Error("bigint expected");
-          if (!(_0n16 <= num4 && num4 < ORDER_MASK))
+          if (!(_0n16 <= num2 && num2 < ORDER_MASK))
             throw new Error(`bigint expected < 2^${CURVE2.nBitLength}`);
-          return ut.numberToBytesBE(num4, CURVE2.nByteLength);
+          return ut.numberToBytesBE(num2, CURVE2.nByteLength);
         }
         function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
           if (["recovered", "canonical"].some((k) => k in opts))
@@ -12102,8 +12102,8 @@ var strkfarm_risk_engine = (() => {
         while (bytes3[0] === 0)
           bytes3 = bytes3.subarray(1);
         const delta = bytes3.length * 8 - nBitLength3;
-        const num4 = u.bytesToNumberBE(bytes3);
-        return delta > 0 ? num4 >> BigInt(delta) : num4;
+        const num2 = u.bytesToNumberBE(bytes3);
+        return delta > 0 ? num2 >> BigInt(delta) : num2;
       }
       function hex0xToBytes3(hex) {
         if (typeof hex === "string") {
@@ -12157,8 +12157,8 @@ var strkfarm_risk_engine = (() => {
       }
       function checkMessage2(msgHash) {
         const bytes3 = ensureBytes5(msgHash);
-        const num4 = u.bytesToNumberBE(bytes3);
-        if (num4 >= exports.MAX_VALUE)
+        const num2 = u.bytesToNumberBE(bytes3);
+        if (num2 >= exports.MAX_VALUE)
           throw new Error(`msgHash should be [0, ${exports.MAX_VALUE})`);
         return bytes3;
       }
@@ -12420,7 +12420,7 @@ var strkfarm_risk_engine = (() => {
         const result = a % b;
         return result >= _0n16 ? result : b + result;
       }
-      function pow3(num4, power, modulo) {
+      function pow3(num2, power, modulo) {
         if (modulo <= _0n16 || power < _0n16)
           throw new Error("Expected power/modulo > 0");
         if (modulo === _1n16)
@@ -12428,8 +12428,8 @@ var strkfarm_risk_engine = (() => {
         let res = _1n16;
         while (power > _0n16) {
           if (power & _1n16)
-            res = res * num4 % modulo;
-          num4 = num4 * num4 % modulo;
+            res = res * num2 % modulo;
+          num2 = num2 * num2 % modulo;
           power >>= _1n16;
         }
         return res;
@@ -12530,7 +12530,7 @@ var strkfarm_risk_engine = (() => {
         }
         return tonelliShanks4(P);
       }
-      var isNegativeLE = (num4, modulo) => (mod4(num4, modulo) & _1n16) === _1n16;
+      var isNegativeLE = (num2, modulo) => (mod4(num2, modulo) & _1n16) === _1n16;
       exports.isNegativeLE = isNegativeLE;
       var FIELD_FIELDS4 = [
         "create",
@@ -12564,15 +12564,15 @@ var strkfarm_risk_engine = (() => {
         }, initial);
         return (0, utils_js_1.validateObject)(field, opts);
       }
-      function FpPow4(f, num4, power) {
+      function FpPow4(f, num2, power) {
         if (power < _0n16)
           throw new Error("Expected power > 0");
         if (power === _0n16)
           return f.ONE;
         if (power === _1n16)
-          return num4;
+          return num2;
         let p = f.ONE;
-        let d = num4;
+        let d = num2;
         while (power > _0n16) {
           if (power & _1n16)
             p = f.mul(p, d);
@@ -12583,18 +12583,18 @@ var strkfarm_risk_engine = (() => {
       }
       function FpInvertBatch4(f, nums) {
         const tmp = new Array(nums.length);
-        const lastMultiplied = nums.reduce((acc, num4, i) => {
-          if (f.is0(num4))
+        const lastMultiplied = nums.reduce((acc, num2, i) => {
+          if (f.is0(num2))
             return acc;
           tmp[i] = acc;
-          return f.mul(acc, num4);
+          return f.mul(acc, num2);
         }, f.ONE);
         const inverted = f.inv(lastMultiplied);
-        nums.reduceRight((acc, num4, i) => {
-          if (f.is0(num4))
+        nums.reduceRight((acc, num2, i) => {
+          if (f.is0(num2))
             return acc;
           tmp[i] = f.mul(acc, tmp[i]);
-          return f.mul(acc, num4);
+          return f.mul(acc, num2);
         }, inverted);
         return tmp;
       }
@@ -12627,34 +12627,34 @@ var strkfarm_risk_engine = (() => {
           MASK: (0, utils_js_1.bitMask)(BITS),
           ZERO: _0n16,
           ONE: _1n16,
-          create: (num4) => mod4(num4, ORDER),
-          isValid: (num4) => {
-            if (typeof num4 !== "bigint")
-              throw new Error(`Invalid field element: expected bigint, got ${typeof num4}`);
-            return _0n16 <= num4 && num4 < ORDER;
+          create: (num2) => mod4(num2, ORDER),
+          isValid: (num2) => {
+            if (typeof num2 !== "bigint")
+              throw new Error(`Invalid field element: expected bigint, got ${typeof num2}`);
+            return _0n16 <= num2 && num2 < ORDER;
           },
-          is0: (num4) => num4 === _0n16,
-          isOdd: (num4) => (num4 & _1n16) === _1n16,
-          neg: (num4) => mod4(-num4, ORDER),
+          is0: (num2) => num2 === _0n16,
+          isOdd: (num2) => (num2 & _1n16) === _1n16,
+          neg: (num2) => mod4(-num2, ORDER),
           eql: (lhs, rhs) => lhs === rhs,
-          sqr: (num4) => mod4(num4 * num4, ORDER),
+          sqr: (num2) => mod4(num2 * num2, ORDER),
           add: (lhs, rhs) => mod4(lhs + rhs, ORDER),
           sub: (lhs, rhs) => mod4(lhs - rhs, ORDER),
           mul: (lhs, rhs) => mod4(lhs * rhs, ORDER),
-          pow: (num4, power) => FpPow4(f, num4, power),
+          pow: (num2, power) => FpPow4(f, num2, power),
           div: (lhs, rhs) => mod4(lhs * invert4(rhs, ORDER), ORDER),
           // Same as above, but doesn't normalize
-          sqrN: (num4) => num4 * num4,
+          sqrN: (num2) => num2 * num2,
           addN: (lhs, rhs) => lhs + rhs,
           subN: (lhs, rhs) => lhs - rhs,
           mulN: (lhs, rhs) => lhs * rhs,
-          inv: (num4) => invert4(num4, ORDER),
+          inv: (num2) => invert4(num2, ORDER),
           sqrt: redef.sqrt || ((n) => sqrtP(f, n)),
           invertBatch: (lst) => FpInvertBatch4(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: (num4) => isLE4 ? (0, utils_js_1.numberToBytesLE)(num4, BYTES) : (0, utils_js_1.numberToBytesBE)(num4, BYTES),
+          toBytes: (num2) => isLE4 ? (0, utils_js_1.numberToBytesLE)(num2, BYTES) : (0, utils_js_1.numberToBytesBE)(num2, BYTES),
           fromBytes: (bytes3) => {
             if (bytes3.length !== BYTES)
               throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes3.length}`);
@@ -12681,8 +12681,8 @@ var strkfarm_risk_engine = (() => {
         const minLen = nLength4(groupOrder).nByteLength + 8;
         if (minLen < 24 || hashLen < minLen || hashLen > 1024)
           throw new Error(`hashToPrivateScalar: expected ${minLen}-1024 bytes of input, got ${hashLen}`);
-        const num4 = isLE4 ? (0, utils_js_1.bytesToNumberLE)(hash4) : (0, utils_js_1.bytesToNumberBE)(hash4);
-        return mod4(num4, groupOrder - _1n16) + _1n16;
+        const num2 = isLE4 ? (0, utils_js_1.bytesToNumberLE)(hash4) : (0, utils_js_1.bytesToNumberBE)(hash4);
+        return mod4(num2, groupOrder - _1n16) + _1n16;
       }
       function getFieldBytesLength4(fieldOrder) {
         if (typeof fieldOrder !== "bigint")
@@ -12700,8 +12700,8 @@ var strkfarm_risk_engine = (() => {
         const minLen = getMinHashLength4(fieldOrder);
         if (len < 16 || len < minLen || len > 1024)
           throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
-        const num4 = isLE4 ? (0, utils_js_1.bytesToNumberBE)(key) : (0, utils_js_1.bytesToNumberLE)(key);
-        const reduced = mod4(num4, fieldOrder - _1n16) + _1n16;
+        const num2 = isLE4 ? (0, utils_js_1.bytesToNumberBE)(key) : (0, utils_js_1.bytesToNumberLE)(key);
+        const reduced = mod4(num2, fieldOrder - _1n16) + _1n16;
         return isLE4 ? (0, utils_js_1.numberToBytesLE)(reduced, fieldLen) : (0, utils_js_1.numberToBytesBE)(reduced, fieldLen);
       }
     }
@@ -13022,8 +13022,8 @@ var strkfarm_risk_engine = (() => {
         },
         hexFromSig(sig) {
           const slice = (s2) => Number.parseInt(s2[0], 16) & 8 ? "00" + s2 : s2;
-          const h = (num4) => {
-            const hex = num4.toString(16);
+          const h = (num2) => {
+            const hex = num2.toString(16);
             return hex.length & 1 ? `0${hex}` : hex;
           };
           const s = slice(h(sig.s));
@@ -13061,11 +13061,11 @@ var strkfarm_risk_engine = (() => {
         }
         if (!Fp2.eql(Fp2.sqr(CURVE2.Gy), weierstrassEquation(CURVE2.Gx)))
           throw new Error("bad generator point: equation left != right");
-        function isWithinCurveOrder(num4) {
-          return typeof num4 === "bigint" && _0n16 < num4 && num4 < CURVE2.n;
+        function isWithinCurveOrder(num2) {
+          return typeof num2 === "bigint" && _0n16 < num2 && num2 < CURVE2.n;
         }
-        function assertGE(num4) {
-          if (!isWithinCurveOrder(num4))
+        function assertGE(num2) {
+          if (!isWithinCurveOrder(num2))
             throw new Error("Expected valid bigint: 0 < bigint < curve.n");
         }
         function normPrivateKeyToScalar(key) {
@@ -13077,16 +13077,16 @@ var strkfarm_risk_engine = (() => {
               throw new Error("Invalid key");
             key = key.padStart(nByteLength * 2, "0");
           }
-          let num4;
+          let num2;
           try {
-            num4 = typeof key === "bigint" ? key : ut.bytesToNumberBE((0, utils_js_1.ensureBytes)("private key", key, nByteLength));
+            num2 = typeof key === "bigint" ? key : ut.bytesToNumberBE((0, utils_js_1.ensureBytes)("private key", key, nByteLength));
           } catch (error2) {
             throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
           }
           if (wrapPrivateKey)
-            num4 = mod4.mod(num4, n);
-          assertGE(num4);
-          return num4;
+            num2 = mod4.mod(num2, n);
+          assertGE(num2);
+          return num2;
         }
         const pointPrecomputes2 = /* @__PURE__ */ new Map();
         function assertPrjPoint(other) {
@@ -13447,8 +13447,8 @@ var strkfarm_risk_engine = (() => {
         const { Fp: Fp2, n: CURVE_ORDER3 } = CURVE2;
         const compressedLen = Fp2.BYTES + 1;
         const uncompressedLen = 2 * Fp2.BYTES + 1;
-        function isValidFieldElement(num4) {
-          return _0n16 < num4 && num4 < Fp2.ORDER;
+        function isValidFieldElement(num2) {
+          return _0n16 < num2 && num2 < Fp2.ORDER;
         }
         function modN(a) {
           return mod4.mod(a, CURVE_ORDER3);
@@ -13498,7 +13498,7 @@ var strkfarm_risk_engine = (() => {
             }
           }
         });
-        const numToNByteStr = (num4) => ut.bytesToHex(ut.numberToBytesBE(num4, CURVE2.nByteLength));
+        const numToNByteStr = (num2) => ut.bytesToHex(ut.numberToBytesBE(num2, CURVE2.nByteLength));
         function isBiggerThanHalfOrder(number3) {
           const HALF = CURVE_ORDER3 >> _1n16;
           return number3 > HALF;
@@ -13632,20 +13632,20 @@ var strkfarm_risk_engine = (() => {
           return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
         }
         const bits2int3 = CURVE2.bits2int || function(bytes3) {
-          const num4 = ut.bytesToNumberBE(bytes3);
+          const num2 = ut.bytesToNumberBE(bytes3);
           const delta = bytes3.length * 8 - CURVE2.nBitLength;
-          return delta > 0 ? num4 >> BigInt(delta) : num4;
+          return delta > 0 ? num2 >> BigInt(delta) : num2;
         };
         const bits2int_modN = CURVE2.bits2int_modN || function(bytes3) {
           return modN(bits2int3(bytes3));
         };
         const ORDER_MASK = ut.bitMask(CURVE2.nBitLength);
-        function int2octets(num4) {
-          if (typeof num4 !== "bigint")
+        function int2octets(num2) {
+          if (typeof num2 !== "bigint")
             throw new Error("bigint expected");
-          if (!(_0n16 <= num4 && num4 < ORDER_MASK))
+          if (!(_0n16 <= num2 && num2 < ORDER_MASK))
             throw new Error(`bigint expected < 2^${CURVE2.nBitLength}`);
-          return ut.numberToBytesBE(num4, CURVE2.nByteLength);
+          return ut.numberToBytesBE(num2, CURVE2.nByteLength);
         }
         function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
           if (["recovered", "canonical"].some((k) => k in opts))
@@ -21543,8 +21543,8 @@ ${r2}}` : "}", l2;
         }
         if (enums && element.type in enums && enums[element.type]) {
           const variantNum = Number(responseIterator.next().value);
-          const rawEnum = enums[element.type].variants.reduce((acc, variant, num4) => {
-            if (num4 === variantNum) {
+          const rawEnum = enums[element.type].variants.reduce((acc, variant, num2) => {
+            if (num2 === variantNum) {
               acc[variant.name] = parseResponseValue2(
                 responseIterator,
                 { name: "", type: variant.type },
@@ -22458,8 +22458,8 @@ ${r2}}` : "}", l2;
       var parseIntAsNumberOrBigInt2 = (str) => {
         if (!json.isInteger(str))
           return parseFloat(str);
-        const num4 = parseInt(str, 10);
-        return Number.isSafeInteger(num4) ? num4 : BigInt(str);
+        const num2 = parseInt(str, 10);
+        return Number.isSafeInteger(num2) ? num2 : BigInt(str);
       };
       var parse22 = (str) => json.parse(String(str), void 0, parseIntAsNumberOrBigInt2);
       var parseAlwaysAsBig2 = (str) => json.parse(String(str), void 0, json.parseNumberAndBigInt);
@@ -31580,8 +31580,8 @@ ${r2}}` : "}", l2;
     }
     return hex;
   }
-  function numberToHexUnpadded(num4) {
-    const hex = num4.toString(16);
+  function numberToHexUnpadded(num2) {
+    const hex = num2.toString(16);
     return hex.length & 1 ? `0${hex}` : hex;
   }
   function hexToNumber(hex) {
@@ -32682,8 +32682,8 @@ ${r2}}` : "}", l2;
     }
     return hex;
   }
-  function numberToHexUnpadded2(num4) {
-    const hex = num4.toString(16);
+  function numberToHexUnpadded2(num2) {
+    const hex = num2.toString(16);
     return hex.length & 1 ? `0${hex}` : hex;
   }
   function hexToNumber2(hex) {
@@ -32892,7 +32892,7 @@ ${r2}}` : "}", l2;
     const result = a % b;
     return result >= _0n5 ? result : b + result;
   }
-  function pow(num4, power, modulo) {
+  function pow(num2, power, modulo) {
     if (modulo <= _0n5 || power < _0n5)
       throw new Error("Expected power/modulo > 0");
     if (modulo === _1n5)
@@ -32900,8 +32900,8 @@ ${r2}}` : "}", l2;
     let res = _1n5;
     while (power > _0n5) {
       if (power & _1n5)
-        res = res * num4 % modulo;
-      num4 = num4 * num4 % modulo;
+        res = res * num2 % modulo;
+      num2 = num2 * num2 % modulo;
       power >>= _1n5;
     }
     return res;
@@ -33026,15 +33026,15 @@ ${r2}}` : "}", l2;
     }, initial);
     return validateObject2(field, opts);
   }
-  function FpPow(f, num4, power) {
+  function FpPow(f, num2, power) {
     if (power < _0n5)
       throw new Error("Expected power > 0");
     if (power === _0n5)
       return f.ONE;
     if (power === _1n5)
-      return num4;
+      return num2;
     let p = f.ONE;
-    let d = num4;
+    let d = num2;
     while (power > _0n5) {
       if (power & _1n5)
         p = f.mul(p, d);
@@ -33045,18 +33045,18 @@ ${r2}}` : "}", l2;
   }
   function FpInvertBatch(f, nums) {
     const tmp = new Array(nums.length);
-    const lastMultiplied = nums.reduce((acc, num4, i) => {
-      if (f.is0(num4))
+    const lastMultiplied = nums.reduce((acc, num2, i) => {
+      if (f.is0(num2))
         return acc;
       tmp[i] = acc;
-      return f.mul(acc, num4);
+      return f.mul(acc, num2);
     }, f.ONE);
     const inverted = f.inv(lastMultiplied);
-    nums.reduceRight((acc, num4, i) => {
-      if (f.is0(num4))
+    nums.reduceRight((acc, num2, i) => {
+      if (f.is0(num2))
         return acc;
       tmp[i] = f.mul(acc, tmp[i]);
-      return f.mul(acc, num4);
+      return f.mul(acc, num2);
     }, inverted);
     return tmp;
   }
@@ -33079,34 +33079,34 @@ ${r2}}` : "}", l2;
       MASK: bitMask2(BITS),
       ZERO: _0n5,
       ONE: _1n5,
-      create: (num4) => mod(num4, ORDER),
-      isValid: (num4) => {
-        if (typeof num4 !== "bigint")
-          throw new Error(`Invalid field element: expected bigint, got ${typeof num4}`);
-        return _0n5 <= num4 && num4 < ORDER;
+      create: (num2) => mod(num2, ORDER),
+      isValid: (num2) => {
+        if (typeof num2 !== "bigint")
+          throw new Error(`Invalid field element: expected bigint, got ${typeof num2}`);
+        return _0n5 <= num2 && num2 < ORDER;
       },
-      is0: (num4) => num4 === _0n5,
-      isOdd: (num4) => (num4 & _1n5) === _1n5,
-      neg: (num4) => mod(-num4, ORDER),
+      is0: (num2) => num2 === _0n5,
+      isOdd: (num2) => (num2 & _1n5) === _1n5,
+      neg: (num2) => mod(-num2, ORDER),
       eql: (lhs, rhs) => lhs === rhs,
-      sqr: (num4) => mod(num4 * num4, ORDER),
+      sqr: (num2) => mod(num2 * num2, ORDER),
       add: (lhs, rhs) => mod(lhs + rhs, ORDER),
       sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
       mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
-      pow: (num4, power) => FpPow(f, num4, power),
+      pow: (num2, power) => FpPow(f, num2, power),
       div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
       // Same as above, but doesn't normalize
-      sqrN: (num4) => num4 * num4,
+      sqrN: (num2) => num2 * num2,
       addN: (lhs, rhs) => lhs + rhs,
       subN: (lhs, rhs) => lhs - rhs,
       mulN: (lhs, rhs) => lhs * rhs,
-      inv: (num4) => invert(num4, ORDER),
+      inv: (num2) => invert(num2, 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: (num4) => isLE4 ? numberToBytesLE2(num4, BYTES) : numberToBytesBE2(num4, BYTES),
+      toBytes: (num2) => isLE4 ? numberToBytesLE2(num2, BYTES) : numberToBytesBE2(num2, BYTES),
       fromBytes: (bytes3) => {
         if (bytes3.length !== BYTES)
           throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes3.length}`);
@@ -33131,8 +33131,8 @@ ${r2}}` : "}", l2;
     const minLen = getMinHashLength(fieldOrder);
     if (len < 16 || len < minLen || len > 1024)
       throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
-    const num4 = isLE4 ? bytesToNumberBE2(key) : bytesToNumberLE2(key);
-    const reduced = mod(num4, fieldOrder - _1n5) + _1n5;
+    const num2 = isLE4 ? bytesToNumberBE2(key) : bytesToNumberLE2(key);
+    const reduced = mod(num2, fieldOrder - _1n5) + _1n5;
     return isLE4 ? numberToBytesLE2(reduced, fieldLen) : numberToBytesBE2(reduced, fieldLen);
   }
 
@@ -33403,8 +33403,8 @@ ${r2}}` : "}", l2;
     },
     hexFromSig(sig) {
       const slice = (s2) => Number.parseInt(s2[0], 16) & 8 ? "00" + s2 : s2;
-      const h = (num4) => {
-        const hex = num4.toString(16);
+      const h = (num2) => {
+        const hex = num2.toString(16);
         return hex.length & 1 ? `0${hex}` : hex;
       };
       const s = slice(h(sig.s));
@@ -33442,11 +33442,11 @@ ${r2}}` : "}", l2;
     }
     if (!Fp2.eql(Fp2.sqr(CURVE2.Gy), weierstrassEquation(CURVE2.Gx)))
       throw new Error("bad generator point: equation left != right");
-    function isWithinCurveOrder(num4) {
-      return typeof num4 === "bigint" && _0n7 < num4 && num4 < CURVE2.n;
+    function isWithinCurveOrder(num2) {
+      return typeof num2 === "bigint" && _0n7 < num2 && num2 < CURVE2.n;
     }
-    function assertGE(num4) {
-      if (!isWithinCurveOrder(num4))
+    function assertGE(num2) {
+      if (!isWithinCurveOrder(num2))
         throw new Error("Expected valid bigint: 0 < bigint < curve.n");
     }
     function normPrivateKeyToScalar(key) {
@@ -33458,16 +33458,16 @@ ${r2}}` : "}", l2;
           throw new Error("Invalid key");
         key = key.padStart(nByteLength * 2, "0");
       }
-      let num4;
+      let num2;
       try {
-        num4 = typeof key === "bigint" ? key : bytesToNumberBE2(ensureBytes2("private key", key, nByteLength));
+        num2 = typeof key === "bigint" ? key : bytesToNumberBE2(ensureBytes2("private key", key, nByteLength));
       } catch (error2) {
         throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
       }
       if (wrapPrivateKey)
-        num4 = mod(num4, n);
-      assertGE(num4);
-      return num4;
+        num2 = mod(num2, n);
+      assertGE(num2);
+      return num2;
     }
     const pointPrecomputes2 = /* @__PURE__ */ new Map();
     function assertPrjPoint(other) {
@@ -33828,8 +33828,8 @@ ${r2}}` : "}", l2;
     const { Fp: Fp2, n: CURVE_ORDER3 } = CURVE2;
     const compressedLen = Fp2.BYTES + 1;
     const uncompressedLen = 2 * Fp2.BYTES + 1;
-    function isValidFieldElement(num4) {
-      return _0n7 < num4 && num4 < Fp2.ORDER;
+    function isValidFieldElement(num2) {
+      return _0n7 < num2 && num2 < Fp2.ORDER;
     }
     function modN(a) {
       return mod(a, CURVE_ORDER3);
@@ -33873,7 +33873,7 @@ ${r2}}` : "}", l2;
         }
       }
     });
-    const numToNByteStr = (num4) => bytesToHex2(numberToBytesBE2(num4, CURVE2.nByteLength));
+    const numToNByteStr = (num2) => bytesToHex2(numberToBytesBE2(num2, CURVE2.nByteLength));
     function isBiggerThanHalfOrder(number3) {
       const HALF = CURVE_ORDER3 >> _1n7;
       return number3 > HALF;
@@ -34007,20 +34007,20 @@ ${r2}}` : "}", l2;
       return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
     }
     const bits2int3 = CURVE2.bits2int || function(bytes3) {
-      const num4 = bytesToNumberBE2(bytes3);
+      const num2 = bytesToNumberBE2(bytes3);
       const delta = bytes3.length * 8 - CURVE2.nBitLength;
-      return delta > 0 ? num4 >> BigInt(delta) : num4;
+      return delta > 0 ? num2 >> BigInt(delta) : num2;
     };
     const bits2int_modN = CURVE2.bits2int_modN || function(bytes3) {
       return modN(bits2int3(bytes3));
     };
     const ORDER_MASK = bitMask2(CURVE2.nBitLength);
-    function int2octets(num4) {
-      if (typeof num4 !== "bigint")
+    function int2octets(num2) {
+      if (typeof num2 !== "bigint")
         throw new Error("bigint expected");
-      if (!(_0n7 <= num4 && num4 < ORDER_MASK))
+      if (!(_0n7 <= num2 && num2 < ORDER_MASK))
         throw new Error(`bigint expected < 2^${CURVE2.nBitLength}`);
-      return numberToBytesBE2(num4, CURVE2.nByteLength);
+      return numberToBytesBE2(num2, CURVE2.nByteLength);
     }
     function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
       if (["recovered", "canonical"].some((k) => k in opts))
@@ -34211,8 +34211,8 @@ ${r2}}` : "}", l2;
     while (bytes3[0] === 0)
       bytes3 = bytes3.subarray(1);
     const delta = bytes3.length * 8 - nBitLength;
-    const num4 = bytesToNumberBE2(bytes3);
-    return delta > 0 ? num4 >> BigInt(delta) : num4;
+    const num2 = bytesToNumberBE2(bytes3);
+    return delta > 0 ? num2 >> BigInt(delta) : num2;
   }
   function hex0xToBytes(hex) {
     if (typeof hex === "string") {
@@ -34264,8 +34264,8 @@ ${r2}}` : "}", l2;
   }
   function checkMessage(msgHash) {
     const bytes3 = ensureBytes3(msgHash);
-    const num4 = bytesToNumberBE2(bytes3);
-    if (num4 >= MAX_VALUE)
+    const num2 = bytesToNumberBE2(bytes3);
+    if (num2 >= MAX_VALUE)
       throw new Error(`msgHash should be [0, ${MAX_VALUE})`);
     return bytes3;
   }
@@ -34488,7 +34488,7 @@ ${r2}}` : "}", l2;
     const result = a % b;
     return result >= _0n8 ? result : b + result;
   }
-  function pow2(num4, power, modulo) {
+  function pow2(num2, power, modulo) {
     if (modulo <= _0n8 || power < _0n8)
       throw new Error("Expected power/modulo > 0");
     if (modulo === _1n8)
@@ -34496,8 +34496,8 @@ ${r2}}` : "}", l2;
     let res = _1n8;
     while (power > _0n8) {
       if (power & _1n8)
-        res = res * num4 % modulo;
-      num4 = num4 * num4 % modulo;
+        res = res * num2 % modulo;
+      num2 = num2 * num2 % modulo;
       power >>= _1n8;
     }
     return res;
@@ -34630,15 +34630,15 @@ ${r2}}` : "}", l2;
     }, initial);
     return validateObject(field, opts);
   }
-  function FpPow2(f, num4, power) {
+  function FpPow2(f, num2, power) {
     if (power < _0n8)
       throw new Error("Expected power > 0");
     if (power === _0n8)
       return f.ONE;
     if (power === _1n8)
-      return num4;
+      return num2;
     let p = f.ONE;
-    let d = num4;
+    let d = num2;
     while (power > _0n8) {
       if (power & _1n8)
         p = f.mul(p, d);
@@ -34649,18 +34649,18 @@ ${r2}}` : "}", l2;
   }
   function FpInvertBatch2(f, nums) {
     const tmp = new Array(nums.length);
-    const lastMultiplied = nums.reduce((acc, num4, i) => {
-      if (f.is0(num4))
+    const lastMultiplied = nums.reduce((acc, num2, i) => {
+      if (f.is0(num2))
         return acc;
       tmp[i] = acc;
-      return f.mul(acc, num4);
+      return f.mul(acc, num2);
     }, f.ONE);
     const inverted = f.inv(lastMultiplied);
-    nums.reduceRight((acc, num4, i) => {
-      if (f.is0(num4))
+    nums.reduceRight((acc, num2, i) => {
+      if (f.is0(num2))
         return acc;
       tmp[i] = f.mul(acc, tmp[i]);
-      return f.mul(acc, num4);
+      return f.mul(acc, num2);
     }, inverted);
     return tmp;
   }
@@ -34683,34 +34683,34 @@ ${r2}}` : "}", l2;
       MASK: bitMask(BITS),
       ZERO: _0n8,
       ONE: _1n8,
-      create: (num4) => mod2(num4, ORDER),
-      isValid: (num4) => {
-        if (typeof num4 !== "bigint")
-          throw new Error(`Invalid field element: expected bigint, got ${typeof num4}`);
-        return _0n8 <= num4 && num4 < ORDER;
+      create: (num2) => mod2(num2, ORDER),
+      isValid: (num2) => {
+        if (typeof num2 !== "bigint")
+          throw new Error(`Invalid field element: expected bigint, got ${typeof num2}`);
+        return _0n8 <= num2 && num2 < ORDER;
       },
-      is0: (num4) => num4 === _0n8,
-      isOdd: (num4) => (num4 & _1n8) === _1n8,
-      neg: (num4) => mod2(-num4, ORDER),
+      is0: (num2) => num2 === _0n8,
+      isOdd: (num2) => (num2 & _1n8) === _1n8,
+      neg: (num2) => mod2(-num2, ORDER),
       eql: (lhs, rhs) => lhs === rhs,
-      sqr: (num4) => mod2(num4 * num4, ORDER),
+      sqr: (num2) => mod2(num2 * num2, ORDER),
       add: (lhs, rhs) => mod2(lhs + rhs, ORDER),
       sub: (lhs, rhs) => mod2(lhs - rhs, ORDER),
       mul: (lhs, rhs) => mod2(lhs * rhs, ORDER),
-      pow: (num4, power) => FpPow2(f, num4, power),
+      pow: (num2, power) => FpPow2(f, num2, power),
       div: (lhs, rhs) => mod2(lhs * invert2(rhs, ORDER), ORDER),
       // Same as above, but doesn't normalize
-      sqrN: (num4) => num4 * num4,
+      sqrN: (num2) => num2 * num2,
       addN: (lhs, rhs) => lhs + rhs,
       subN: (lhs, rhs) => lhs - rhs,
       mulN: (lhs, rhs) => lhs * rhs,
-      inv: (num4) => invert2(num4, ORDER),
+      inv: (num2) => invert2(num2, ORDER),
       sqrt: redef.sqrt || ((n) => sqrtP(f, n)),
       invertBatch: (lst) => FpInvertBatch2(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: (num4) => isLE4 ? numberToBytesLE(num4, BYTES) : numberToBytesBE(num4, BYTES),
+      toBytes: (num2) => isLE4 ? numberToBytesLE(num2, BYTES) : numberToBytesBE(num2, BYTES),
       fromBytes: (bytes3) => {
         if (bytes3.length !== BYTES)
           throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes3.length}`);
@@ -34735,8 +34735,8 @@ ${r2}}` : "}", l2;
     const minLen = getMinHashLength2(fieldOrder);
     if (len < 16 || len < minLen || len > 1024)
       throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
-    const num4 = isLE4 ? bytesToNumberBE(key) : bytesToNumberLE(key);
-    const reduced = mod2(num4, fieldOrder - _1n8) + _1n8;
+    const num2 = isLE4 ? bytesToNumberBE(key) : bytesToNumberLE(key);
+    const reduced = mod2(num2, fieldOrder - _1n8) + _1n8;
     return isLE4 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
   }
 
@@ -35032,8 +35032,8 @@ ${r2}}` : "}", l2;
     },
     hexFromSig(sig) {
       const slice = (s2) => Number.parseInt(s2[0], 16) & 8 ? "00" + s2 : s2;
-      const h = (num4) => {
-        const hex = num4.toString(16);
+      const h = (num2) => {
+        const hex = num2.toString(16);
         return hex.length & 1 ? `0${hex}` : hex;
       };
       const s = slice(h(sig.s));
@@ -35071,11 +35071,11 @@ ${r2}}` : "}", l2;
     }
     if (!Fp2.eql(Fp2.sqr(CURVE2.Gy), weierstrassEquation(CURVE2.Gx)))
       throw new Error("bad generator point: equation left != right");
-    function isWithinCurveOrder(num4) {
-      return typeof num4 === "bigint" && _0n10 < num4 && num4 < CURVE2.n;
+    function isWithinCurveOrder(num2) {
+      return typeof num2 === "bigint" && _0n10 < num2 && num2 < CURVE2.n;
     }
-    function assertGE(num4) {
-      if (!isWithinCurveOrder(num4))
+    function assertGE(num2) {
+      if (!isWithinCurveOrder(num2))
         throw new Error("Expected valid bigint: 0 < bigint < curve.n");
     }
     function normPrivateKeyToScalar(key) {
@@ -35087,16 +35087,16 @@ ${r2}}` : "}", l2;
           throw new Error("Invalid key");
         key = key.padStart(nByteLength * 2, "0");
       }
-      let num4;
+      let num2;
       try {
-        num4 = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
+        num2 = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
       } catch (error2) {
         throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
       }
       if (wrapPrivateKey)
-        num4 = mod2(num4, n);
-      assertGE(num4);
-      return num4;
+        num2 = mod2(num2, n);
+      assertGE(num2);
+      return num2;
     }
     const pointPrecomputes2 = /* @__PURE__ */ new Map();
     function assertPrjPoint(other) {
@@ -35457,8 +35457,8 @@ ${r2}}` : "}", l2;
     const { Fp: Fp2, n: CURVE_ORDER3 } = CURVE2;
     const compressedLen = Fp2.BYTES + 1;
     const uncompressedLen = 2 * Fp2.BYTES + 1;
-    function isValidFieldElement(num4) {
-      return _0n10 < num4 && num4 < Fp2.ORDER;
+    function isValidFieldElement(num2) {
+      return _0n10 < num2 && num2 < Fp2.ORDER;
     }
     function modN(a) {
       return mod2(a, CURVE_ORDER3);
@@ -35508,7 +35508,7 @@ ${r2}}` : "}", l2;
         }
       }
     });
-    const numToNByteStr = (num4) => bytesToHex(numberToBytesBE(num4, CURVE2.nByteLength));
+    const numToNByteStr = (num2) => bytesToHex(numberToBytesBE(num2, CURVE2.nByteLength));
     function isBiggerThanHalfOrder(number3) {
       const HALF = CURVE_ORDER3 >> _1n10;
       return number3 > HALF;
@@ -35642,20 +35642,20 @@ ${r2}}` : "}", l2;
       return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
     }
     const bits2int3 = CURVE2.bits2int || function(bytes3) {
-      const num4 = bytesToNumberBE(bytes3);
+      const num2 = bytesToNumberBE(bytes3);
       const delta = bytes3.length * 8 - CURVE2.nBitLength;
-      return delta > 0 ? num4 >> BigInt(delta) : num4;
+      return delta > 0 ? num2 >> BigInt(delta) : num2;
     };
     const bits2int_modN = CURVE2.bits2int_modN || function(bytes3) {
       return modN(bits2int3(bytes3));
     };
     const ORDER_MASK = bitMask(CURVE2.nBitLength);
-    function int2octets(num4) {
-      if (typeof num4 !== "bigint")
+    function int2octets(num2) {
+      if (typeof num2 !== "bigint")
         throw new Error("bigint expected");
-      if (!(_0n10 <= num4 && num4 < ORDER_MASK))
+      if (!(_0n10 <= num2 && num2 < ORDER_MASK))
         throw new Error(`bigint expected < 2^${CURVE2.nBitLength}`);
-      return numberToBytesBE(num4, CURVE2.nByteLength);
+      return numberToBytesBE(num2, CURVE2.nByteLength);
     }
     function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
       if (["recovered", "canonical"].some((k) => k in opts))
@@ -35873,8 +35873,8 @@ ${r2}}` : "}", l2;
   }
   var NUMBER_REGEX = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
   function isSafeNumber(value, config2) {
-    const num4 = Number.parseFloat(value);
-    const parsed = String(num4);
+    const num2 = Number.parseFloat(value);
+    const parsed = String(num2);
     if (value === parsed) {
       return true;
     }
@@ -35907,11 +35907,11 @@ ${r2}}` : "}", l2;
     if (isInteger(value)) {
       return UnsafeNumberReason.truncate_integer;
     }
-    const num4 = Number.parseFloat(value);
-    if (!Number.isFinite(num4)) {
+    const num2 = Number.parseFloat(value);
+    if (!Number.isFinite(num2)) {
       return UnsafeNumberReason.overflow;
     }
-    if (num4 === 0) {
+    if (num2 === 0) {
       return UnsafeNumberReason.underflow;
     }
     return UnsafeNumberReason.truncate_float;
@@ -43049,8 +43049,8 @@ ${indent}}` : "}";
     }
     if (enums && element.type in enums && enums[element.type]) {
       const variantNum = Number(responseIterator.next().value);
-      const rawEnum = enums[element.type].variants.reduce((acc, variant, num4) => {
-        if (num4 === variantNum) {
+      const rawEnum = enums[element.type].variants.reduce((acc, variant, num2) => {
+        if (num2 === variantNum) {
           acc[variant.name] = parseResponseValue(
             responseIterator,
             { name: "", type: variant.type },
@@ -43958,8 +43958,8 @@ ${indent}}` : "}";
   var parseIntAsNumberOrBigInt = (str) => {
     if (!isInteger(str))
       return parseFloat(str);
-    const num4 = parseInt(str, 10);
-    return Number.isSafeInteger(num4) ? num4 : BigInt(str);
+    const num2 = parseInt(str, 10);
+    return Number.isSafeInteger(num2) ? num2 : BigInt(str);
   };
   var parse2 = (str) => parse(String(str), void 0, parseIntAsNumberOrBigInt);
   var parseAlwaysAsBig = (str) => parse(String(str), void 0, parseNumberAndBigInt);
@@ -47435,7 +47435,7 @@ ${indent}}` : "}";
     name: "WBTC",
     symbol: "WBTC",
     logo: "https://assets.troves.fi/integrations/tokens/wbtc.svg",
-    address: ContractAddr.from("0x3fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac"),
+    address: ContractAddr.from("0x03fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac"),
     decimals: 8,
     coingeckId: void 0,
     displayDecimals: 6,
@@ -47451,6 +47451,26 @@ ${indent}}` : "}";
     displayDecimals: 6,
     priceCheckAmount: 1e-4
     // 112000 * 0.0001 = $11.2
+  }, {
+    name: "solvBTC",
+    symbol: "solvBTC",
+    logo: "https://assets.strkfarm.com/integrations/tokens/solvbtc.svg",
+    address: ContractAddr.from("0x0593e034dda23eea82d2ba9a30960ed42cf4a01502cc2351dc9b9881f9931a68"),
+    decimals: 18,
+    coingeckId: void 0,
+    displayDecimals: 6,
+    priceCheckAmount: 1e-4
+    // 112000 * 0.0001 = $11.2
+  }, {
+    name: "LBTC",
+    symbol: "LBTC",
+    logo: "https://assets.strkfarm.com/integrations/tokens/lbtc.svg",
+    address: ContractAddr.from("0x036834a40984312f7f7de8d31e3f6305b325389eaeea5b1c0664b2fb936461a4"),
+    decimals: 8,
+    coingeckId: void 0,
+    displayDecimals: 6,
+    priceCheckAmount: 1e-4
+    // 112000 * 0.0001 = $11.2
   }];
   var tokens = defaultTokens;
   var _Global = class _Global {
@@ -49667,8 +49687,8 @@ ${indent}}` : "}";
       throw new Error(prefix + "expected safe integer, got type=" + typeof value);
     }
   }
-  function numberToHexUnpadded3(num4) {
-    const hex = abignumber(num4).toString(16);
+  function numberToHexUnpadded3(num2) {
+    const hex = abignumber(num2).toString(16);
     return hex.length & 1 ? "0" + hex : hex;
   }
   function hexToNumber3(hex) {
@@ -49956,15 +49976,15 @@ ${indent}}` : "}";
     validateObject3(field, opts);
     return field;
   }
-  function FpPow3(Fp2, num4, power) {
+  function FpPow3(Fp2, num2, power) {
     if (power < _0n13)
       throw new Error("invalid exponent, negatives unsupported");
     if (power === _0n13)
       return Fp2.ONE;
     if (power === _1n13)
-      return num4;
+      return num2;
     let p = Fp2.ONE;
-    let d = num4;
+    let d = num2;
     while (power > _0n13) {
       if (power & _1n13)
         p = Fp2.mul(p, d);
@@ -49975,18 +49995,18 @@ ${indent}}` : "}";
   }
   function FpInvertBatch3(Fp2, nums, passZero = false) {
     const inverted = new Array(nums.length).fill(passZero ? Fp2.ZERO : void 0);
-    const multipliedAcc = nums.reduce((acc, num4, i) => {
-      if (Fp2.is0(num4))
+    const multipliedAcc = nums.reduce((acc, num2, i) => {
+      if (Fp2.is0(num2))
         return acc;
       inverted[i] = acc;
-      return Fp2.mul(acc, num4);
+      return Fp2.mul(acc, num2);
     }, Fp2.ONE);
     const invertedAcc = Fp2.inv(multipliedAcc);
-    nums.reduceRight((acc, num4, i) => {
-      if (Fp2.is0(num4))
+    nums.reduceRight((acc, num2, i) => {
+      if (Fp2.is0(num2))
         return acc;
       inverted[i] = Fp2.mul(acc, inverted[i]);
-      return Fp2.mul(acc, num4);
+      return Fp2.mul(acc, num2);
     }, invertedAcc);
     return inverted;
   }
@@ -50044,32 +50064,32 @@ ${indent}}` : "}";
       this._sqrt = void 0;
       Object.preventExtensions(this);
     }
-    create(num4) {
-      return mod3(num4, this.ORDER);
+    create(num2) {
+      return mod3(num2, this.ORDER);
     }
-    isValid(num4) {
-      if (typeof num4 !== "bigint")
-        throw new Error("invalid field element: expected bigint, got " + typeof num4);
-      return _0n13 <= num4 && num4 < this.ORDER;
+    isValid(num2) {
+      if (typeof num2 !== "bigint")
+        throw new Error("invalid field element: expected bigint, got " + typeof num2);
+      return _0n13 <= num2 && num2 < this.ORDER;
     }
-    is0(num4) {
-      return num4 === _0n13;
+    is0(num2) {
+      return num2 === _0n13;
     }
     // is valid and invertible
-    isValidNot0(num4) {
-      return !this.is0(num4) && this.isValid(num4);
+    isValidNot0(num2) {
+      return !this.is0(num2) && this.isValid(num2);
     }
-    isOdd(num4) {
-      return (num4 & _1n13) === _1n13;
+    isOdd(num2) {
+      return (num2 & _1n13) === _1n13;
     }
-    neg(num4) {
-      return mod3(-num4, this.ORDER);
+    neg(num2) {
+      return mod3(-num2, this.ORDER);
     }
     eql(lhs, rhs) {
       return lhs === rhs;
     }
-    sqr(num4) {
-      return mod3(num4 * num4, this.ORDER);
+    sqr(num2) {
+      return mod3(num2 * num2, this.ORDER);
     }
     add(lhs, rhs) {
       return mod3(lhs + rhs, this.ORDER);
@@ -50080,15 +50100,15 @@ ${indent}}` : "}";
     mul(lhs, rhs) {
       return mod3(lhs * rhs, this.ORDER);
     }
-    pow(num4, power) {
-      return FpPow3(this, num4, power);
+    pow(num2, power) {
+      return FpPow3(this, num2, power);
     }
     div(lhs, rhs) {
       return mod3(lhs * invert3(rhs, this.ORDER), this.ORDER);
     }
     // Same as above, but doesn't normalize
-    sqrN(num4) {
-      return num4 * num4;
+    sqrN(num2) {
+      return num2 * num2;
     }
     addN(lhs, rhs) {
       return lhs + rhs;
@@ -50099,16 +50119,16 @@ ${indent}}` : "}";
     mulN(lhs, rhs) {
       return lhs * rhs;
     }
-    inv(num4) {
-      return invert3(num4, this.ORDER);
+    inv(num2) {
+      return invert3(num2, this.ORDER);
     }
-    sqrt(num4) {
+    sqrt(num2) {
       if (!this._sqrt)
         this._sqrt = FpSqrt3(this.ORDER);
-      return this._sqrt(this, num4);
+      return this._sqrt(this, num2);
     }
-    toBytes(num4) {
-      return this.isLE ? numberToBytesLE3(num4, this.BYTES) : numberToBytesBE3(num4, this.BYTES);
+    toBytes(num2) {
+      return this.isLE ? numberToBytesLE3(num2, this.BYTES) : numberToBytesBE3(num2, this.BYTES);
     }
     fromBytes(bytes3, skipValidation = false) {
       abytes3(bytes3);
@@ -50162,8 +50182,8 @@ ${indent}}` : "}";
     const minLen = getMinHashLength3(fieldOrder);
     if (len < 16 || len < minLen || len > 1024)
       throw new Error("expected " + minLen + "-1024 bytes of input, got " + len);
-    const num4 = isLE4 ? bytesToNumberLE3(key) : bytesToNumberBE3(key);
-    const reduced = mod3(num4, fieldOrder - _1n13) + _1n13;
+    const num2 = isLE4 ? bytesToNumberLE3(key) : bytesToNumberBE3(key);
+    const reduced = mod3(num2, fieldOrder - _1n13) + _1n13;
     return isLE4 ? numberToBytesLE3(reduced, fieldLen) : numberToBytesBE3(reduced, fieldLen);
   }
 
@@ -50569,7 +50589,7 @@ ${indent}}` : "}";
   }
 
   // node_modules/.pnpm/@noble+curves@2.0.0/node_modules/@noble/curves/abstract/weierstrass.js
-  var divNearest2 = (num4, den) => (num4 + (num4 >= 0 ? den : -den) / _2n11) / den;
+  var divNearest2 = (num2, den) => (num2 + (num2 >= 0 ? den : -den) / _2n11) / den;
   function _splitEndoScalar(k, basis, n) {
     const [[a1, b1], [a2, b2]] = basis;
     const c1 = divNearest2(b2 * k, n);
@@ -50669,11 +50689,11 @@ ${indent}}` : "}";
     // - add zero byte if exists
     // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
     _int: {
-      encode(num4) {
+      encode(num2) {
         const { Err: E } = DER3;
-        if (num4 < _0n15)
+        if (num2 < _0n15)
           throw new E("integer: negative integers are not allowed");
-        let hex = numberToHexUnpadded3(num4);
+        let hex = numberToHexUnpadded3(num2);
         if (Number.parseInt(hex[0], 16) & 8)
           hex = "00" + hex;
         if (hex.length & 1)
@@ -51157,8 +51177,8 @@ ${indent}}` : "}";
     const lengths = Object.assign(getWLengths(Point3.Fp, Fn), { seed: getMinHashLength3(Fn.ORDER) });
     function isValidSecretKey(secretKey) {
       try {
-        const num4 = Fn.fromBytes(secretKey);
-        return Fn.isValidNot0(num4);
+        const num2 = Fn.fromBytes(secretKey);
+        return Fn.isValidNot0(num2);
       } catch (error2) {
         return false;
       }
@@ -51234,10 +51254,10 @@ ${indent}}` : "}";
       const HALF = CURVE_ORDER3 >> _1n15;
       return number3 > HALF;
     }
-    function validateRS(title, num4) {
-      if (!Fn.isValidNot0(num4))
+    function validateRS(title, num2) {
+      if (!Fn.isValidNot0(num2))
         throw new Error(`invalid signature ${title}: out of range 1..Point.Fn.ORDER`);
-      return num4;
+      return num2;
     }
     function assertSmallCofactor() {
       if (hasLargeCofactor)
@@ -51335,17 +51355,17 @@ ${indent}}` : "}";
     const bits2int3 = ecdsaOpts.bits2int || function bits2int_def(bytes3) {
       if (bytes3.length > 8192)
         throw new Error("input is too large");
-      const num4 = bytesToNumberBE3(bytes3);
+      const num2 = bytesToNumberBE3(bytes3);
       const delta = bytes3.length * 8 - fnBits;
-      return delta > 0 ? num4 >> BigInt(delta) : num4;
+      return delta > 0 ? num2 >> BigInt(delta) : num2;
     };
     const bits2int_modN = ecdsaOpts.bits2int_modN || function bits2int_modN_def(bytes3) {
       return Fn.create(bits2int3(bytes3));
     };
     const ORDER_MASK = bitMask3(fnBits);
-    function int2octets(num4) {
-      aInRange("num < 2^" + fnBits, num4, _0n15, ORDER_MASK);
-      return Fn.toBytes(num4);
+    function int2octets(num2) {
+      aInRange("num < 2^" + fnBits, num2, _0n15, ORDER_MASK);
+      return Fn.toBytes(num2);
     }
     function validateMsgAndHash(message, prehash) {
       abytes3(message, void 0, "message");
@@ -51712,8 +51732,8 @@ ${indent}}` : "}";
     while (bytes3[0] === 0)
       bytes3 = bytes3.subarray(1);
     const delta = bytes3.length * 8 - nBitLength2;
-    const num4 = bytesToNumberBE3(bytes3);
-    return delta > 0 ? num4 >> BigInt(delta) : num4;
+    const num2 = bytesToNumberBE3(bytes3);
+    return delta > 0 ? num2 >> BigInt(delta) : num2;
   }
   function hex0xToBytes2(hex) {
     if (typeof hex === "string") {
@@ -53786,11 +53806,12 @@ ${indent}}` : "}";
       return rewards.sort((a, b) => b.endDate.getTime() - a.endDate.getTime());
     }
   };
+  var VESU_REWARDS_CONTRACT = ContractAddr.from("0x0387f3eb1d98632fbe3440a9f1385Aec9d87b6172491d3Dd81f1c35A7c61048F");
   var VesuHarvests = class _VesuHarvests extends Harvests {
     async getHarvests(addr) {
       const result = await fetch(`https://api.vesu.xyz/users/${addr.address}/strk-rewards/calldata`);
       const data = await result.json();
-      const rewardsContract = ContractAddr.from("0x0387f3eb1d98632fbe3440a9f1385Aec9d87b6172491d3Dd81f1c35A7c61048F");
+      const rewardsContract = VESU_REWARDS_CONTRACT;
       const cls = await this.config.provider.getClassAt(rewardsContract.address);
       const contract = new Contract(cls.abi, rewardsContract.address, this.config.provider);
       const _claimed_amount = await contract.call("amount_already_claimed", [addr.address]);
@@ -65440,8 +65461,8 @@ ${indent}}` : "}";
         upperTick: _EkuboCLVault.i129ToNumber(result.bounds.upper)
       };
     }
-    static div2Power128(num4) {
-      return Number(BigInt(num4.toString()) * BigInt(1e18) / BigInt(2 ** 128)) / 1e18;
+    static div2Power128(num2) {
+      return Number(BigInt(num2.toString()) * BigInt(1e18) / BigInt(2 ** 128)) / 1e18;
     }
     static priceToTick(price, isRoundDown, tickSpacing) {
       const value = isRoundDown ? Math.floor(Math.log(price) / Math.log(1.000001)) : Math.ceil(Math.log(price) / Math.log(1.000001));
@@ -66148,14 +66169,31 @@ ${indent}}` : "}";
     name: "Ekubo",
     logo: "https://app.ekubo.org/favicon.ico"
   };
-  var _riskFactor2 = [
-    { type: "Smart Contract Risk" /* SMART_CONTRACT_RISK */, value: 0.5, weight: 34, reason: "Audited smart contracts" },
-    { type: "Impermanent Loss Risk" /* IMPERMANENT_LOSS */, value: 0.75, weight: 33, reason: "Low risk due to co-related assets" },
-    { type: "Market Risk" /* MARKET_RISK */, value: 0.75, weight: 33, reason: "Low risk due to co-related assets" }
+  var _corelatedPoolRiskFactors = [
+    { type: "Smart Contract Risk" /* SMART_CONTRACT_RISK */, value: 2 /* WELL_AUDITED */, weight: 34, reason: "Audited smart contracts" },
+    { type: "Impermanent Loss Risk" /* IMPERMANENT_LOSS */, value: 1 /* HIGHLY_CORRELATED */, weight: 33, reason: "Low risk due to co-related assets" },
+    { type: "Market Risk" /* MARKET_RISK */, value: 1 /* VERY_LOW_VOLATILITY */, weight: 33, reason: "Low risk due to co-related assets" }
+  ];
+  var mediumVolatilityPoolRiskFactors = [
+    { type: "Smart Contract Risk" /* SMART_CONTRACT_RISK */, value: 2 /* WELL_AUDITED */, weight: 34, reason: "Audited smart contracts" },
+    { type: "Impermanent Loss Risk" /* IMPERMANENT_LOSS */, value: 3 /* NON_CORRELATED */, weight: 33, reason: "Low risk due to co-related assets" },
+    { type: "Market Risk" /* MARKET_RISK */, value: 3 /* MODERATE_VOLATILITY */, weight: 33, reason: "Low risk due to co-related assets" }
   ];
-  var _riskFactorStable = [
-    { type: "Smart Contract Risk" /* SMART_CONTRACT_RISK */, value: 0.5, weight: 25 }
+  var highVolatilityPoolRiskFactors = [
+    { type: "Smart Contract Risk" /* SMART_CONTRACT_RISK */, value: 2 /* WELL_AUDITED */, weight: 34, reason: "Audited smart contracts" },
+    { type: "Impermanent Loss Risk" /* IMPERMANENT_LOSS */, value: 3 /* NON_CORRELATED */, weight: 33, reason: "Low risk due to co-related assets" },
+    { type: "Market Risk" /* MARKET_RISK */, value: 4 /* HIGH_VOLATILITY */, weight: 33, reason: "Low risk due to co-related assets" }
   ];
+  var mediumRisk = {
+    riskFactor: mediumVolatilityPoolRiskFactors,
+    netRisk: mediumVolatilityPoolRiskFactors.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / mediumVolatilityPoolRiskFactors.reduce((acc, curr) => acc + curr.weight, 0),
+    notARisks: getNoRiskTags(mediumVolatilityPoolRiskFactors)
+  };
+  var highRisk = {
+    riskFactor: highVolatilityPoolRiskFactors,
+    netRisk: highVolatilityPoolRiskFactors.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / highVolatilityPoolRiskFactors.reduce((acc, curr) => acc + curr.weight, 0),
+    notARisks: getNoRiskTags(highVolatilityPoolRiskFactors)
+  };
   var AUDIT_URL2 = "https://assets.troves.fi/strkfarm/audit_report_vesu_and_ekubo_strats.pdf";
   var faqs2 = [
     {
@@ -66170,6 +66208,10 @@ ${indent}}` : "}";
       question: "What happens during withdrawal?",
       answer: "During withdrawal, you may receive either or both tokens depending on market conditions and prevailing prices."
     },
+    {
+      question: "Are there any deposit/withdrawal fees?",
+      answer: "No, there are no deposit/withdrawal fees. However, there is a performance fee varying between 10-20% of the fees and rewards generated. The exact fee is determined by the strategy and the APY shown is net of this fee."
+    },
     {
       question: "Is the strategy audited?",
       answer: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { children: [
@@ -66204,9 +66246,9 @@ ${indent}}` : "}";
     auditUrl: AUDIT_URL2,
     maxTVL: Web3Number.fromWei("0", 18),
     risk: {
-      riskFactor: _riskFactor2,
-      netRisk: _riskFactor2.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor2.reduce((acc, curr) => acc + curr.weight, 0),
-      notARisks: getNoRiskTags(_riskFactor2)
+      riskFactor: _corelatedPoolRiskFactors,
+      netRisk: _corelatedPoolRiskFactors.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _corelatedPoolRiskFactors.reduce((acc, curr) => acc + curr.weight, 0),
+      notARisks: getNoRiskTags(_corelatedPoolRiskFactors)
     },
     apyMethodology: "APY based on 7-day historical performance, including fees and rewards.",
     additionalInfo: {
@@ -66222,7 +66264,8 @@ ${indent}}` : "}";
         customShouldRebalance: async (currentPrice) => true,
         minWaitHours: 24,
         direction: "uponly"
-      }
+      },
+      quoteAsset: Global.getDefaultTokens().find((t) => t.symbol === "STRK")
     },
     faqs: [
       ...faqs2,
@@ -66239,68 +66282,165 @@ ${indent}}` : "}";
     contractDetails: [],
     investmentSteps: []
   };
-  var EkuboCLVaultStrategies = [
-    xSTRKSTRK,
+  var ETHUSDCRe7Strategy = {
+    ...xSTRKSTRK,
+    name: "Ekubo ETH/USDC",
+    description: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, {}),
+    address: ContractAddr.from(
+      "0x160d8fa4569ef6a12e6bf47cb943d7b5ebba8a41a69a14c1d943050ba5ff947"
+    ),
+    launchBlock: 1501761,
+    // must be same order as poolKey token0 and token1
+    depositTokens: [
+      Global.getDefaultTokens().find((t) => t.symbol === "ETH"),
+      Global.getDefaultTokens().find((t) => t.symbol === "USDC")
+    ],
+    additionalInfo: {
+      newBounds: "Managed by Re7",
+      truePrice: 1,
+      feeBps: 1e3,
+      rebalanceConditions: {
+        customShouldRebalance: async (currentPrice) => currentPrice > 0.99 && currentPrice < 1.01,
+        minWaitHours: 6,
+        direction: "any"
+      },
+      quoteAsset: Global.getDefaultTokens().find((t) => t.symbol === "USDC")
+    },
+    faqs: [
+      ...faqs2,
+      {
+        question: "Who is the curator of this strategy?",
+        answer: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { children: [
+          "Re7 Labs is the curator of this strategy. Re7 Labs is a well-known Web3 asset management firm. This strategy is completely managed by them, including ownership of the vault. Troves is developer of the smart contracts and maintains infrastructure to help users access these strategies. You can find more information about them on their website ",
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("a", { href: "https://www.re7labs.xyz", style: { textDecoration: "underline", marginLeft: "2px" }, target: "_blank", children: "here" }),
+          "."
+        ] })
+      }
+    ],
+    risk: highRisk,
+    points: [],
+    curator: { name: "Re7 Labs", logo: "https://www.re7labs.xyz/favicon.ico" }
+  };
+  var RE7Strategies = [
+    ETHUSDCRe7Strategy,
     {
-      ...xSTRKSTRK,
+      ...ETHUSDCRe7Strategy,
       name: "Ekubo USDC/USDT",
       description: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, {}),
       address: ContractAddr.from(
-        "0xd647ed735f0db52f2a5502b6e06ed21dc4284a43a36af4b60d3c80fbc56c91"
+        "0x3a4f8debaf12af97bb911099bc011d63d6c208d4c5ba8e15d7f437785b0aaa2"
       ),
-      launchBlock: 1385576,
+      launchBlock: 1501761,
       // must be same order as poolKey token0 and token1
       depositTokens: [
         Global.getDefaultTokens().find((t) => t.symbol === "USDC"),
         Global.getDefaultTokens().find((t) => t.symbol === "USDT")
       ],
-      additionalInfo: {
-        newBounds: {
-          lower: -1,
-          upper: 1
-        },
-        truePrice: 1,
-        feeBps: 1e3,
-        rebalanceConditions: {
-          customShouldRebalance: async (currentPrice) => currentPrice > 0.99 && currentPrice < 1.01,
-          minWaitHours: 6,
-          direction: "any"
-        }
-      }
+      risk: xSTRKSTRK.risk
     },
     {
-      ...xSTRKSTRK,
+      ...ETHUSDCRe7Strategy,
       name: "Ekubo STRK/USDC",
       description: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, {}),
       address: ContractAddr.from(
-        "0xb7bd37121041261446d8eedec618955a4490641034942da688e8cbddea7b23"
+        "0x351b36d0d9d8b40010658825adeeddb1397436cd41acd0ff6c6e23aaa8b5b30"
       ),
-      launchBlock: 1492136,
+      launchBlock: 1501762,
       // must be same order as poolKey token0 and token1
       depositTokens: [
         Global.getDefaultTokens().find((t) => t.symbol === "STRK"),
         Global.getDefaultTokens().find((t) => t.symbol === "USDC")
       ],
-      maxTVL: Web3Number.fromWei("0", 6),
-      additionalInfo: {
-        newBounds: "Managed by Re7",
-        feeBps: 1e3,
-        rebalanceConditions: {
-          customShouldRebalance: async (currentPrice) => true,
-          minWaitHours: 6,
-          direction: "any"
-        }
-      }
+      risk: highRisk
+    },
+    {
+      ...ETHUSDCRe7Strategy,
+      name: "Ekubo STRK/ETH",
+      description: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, {}),
+      address: ContractAddr.from(
+        "0x4ce3024b0ee879009112d7b0e073f8a87153dd35b029347d4247ffe48d28f51"
+      ),
+      launchBlock: 1501763,
+      // must be same order as poolKey token0 and token1
+      depositTokens: [
+        Global.getDefaultTokens().find((t) => t.symbol === "STRK"),
+        Global.getDefaultTokens().find((t) => t.symbol === "ETH")
+      ],
+      risk: highRisk
+    },
+    {
+      ...ETHUSDCRe7Strategy,
+      name: "Ekubo WBTC/USDC",
+      description: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, {}),
+      address: ContractAddr.from(
+        "0x2bcaef2eb7706875a5fdc6853dd961a0590f850bc3a031c59887189b5e84ba1"
+      ),
+      launchBlock: 1501764,
+      // must be same order as poolKey token0 and token1
+      depositTokens: [
+        Global.getDefaultTokens().find((t) => t.symbol === "WBTC"),
+        Global.getDefaultTokens().find((t) => t.symbol === "USDC")
+      ],
+      risk: mediumRisk
+    },
+    {
+      ...ETHUSDCRe7Strategy,
+      name: "Ekubo tBTC/USDC",
+      description: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, {}),
+      address: ContractAddr.from(
+        "0x4aad891a2d4432fba06b6558631bb13f6bbd7f6f33ab8c3111e344889ea4456"
+      ),
+      launchBlock: 1501764,
+      // must be same order as poolKey token0 and token1
+      depositTokens: [
+        Global.getDefaultTokens().find((t) => t.symbol === "tBTC"),
+        Global.getDefaultTokens().find((t) => t.symbol === "USDC")
+      ],
+      risk: mediumRisk
+    },
+    {
+      ...ETHUSDCRe7Strategy,
+      name: "Ekubo WBTC/ETH",
+      description: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, {}),
+      address: ContractAddr.from(
+        "0x1c9232b8186d9317652f05055615f18a120c2ad9e5ee96c39e031c257fb945b"
+      ),
+      launchBlock: 1501765,
+      // must be same order as poolKey token0 and token1
+      depositTokens: [
+        Global.getDefaultTokens().find((t) => t.symbol === "WBTC"),
+        Global.getDefaultTokens().find((t) => t.symbol === "ETH")
+      ],
+      risk: mediumRisk
+    },
+    {
+      ...ETHUSDCRe7Strategy,
+      name: "Ekubo WBTC/STRK",
+      description: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, {}),
+      address: ContractAddr.from(
+        "0x1248e385c23a929a015ec298a26560fa7745bbd6e41a886550e337b02714b1b"
+      ),
+      launchBlock: 1501766,
+      // must be same order as poolKey token0 and token1
+      depositTokens: [
+        Global.getDefaultTokens().find((t) => t.symbol === "WBTC"),
+        Global.getDefaultTokens().find((t) => t.symbol === "STRK")
+      ],
+      risk: highRisk
     }
   ];
+  var EkuboCLVaultStrategies = [
+    xSTRKSTRK,
+    ...RE7Strategies
+  ];
   EkuboCLVaultStrategies.forEach((s) => {
     s.contractDetails = [
       {
         address: s.address,
         name: "Vault",
         sourceCodeUrl: "https://github.com/strkfarm/strkfarm-contracts/tree/main/src/strategies/cl_vault"
-      },
-      ...COMMON_CONTRACTS
+      }
+      // ...COMMON_CONTRACTS
     ];
     s.docs = "https://docs.troves.fi/p/ekubo-cl-vaults";
     s.description = /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { children: [
@@ -68268,7 +68408,7 @@ ${indent}}` : "}";
     name: "Endur",
     logo: "https://app.endur.fi/logo.png"
   };
-  var _riskFactor3 = [
+  var _riskFactor2 = [
     { type: "Smart Contract Risk" /* SMART_CONTRACT_RISK */, value: 0.5, weight: 25, reason: "Audited by CSC" },
     { type: "Depeg Risk" /* DEPEG_RISK */, value: 0.25, weight: 25, reason: "Depending on prevailing market conditions and trading activity, xSTRK may lose its peg to the underlying asset." },
     { type: "Liquidation Risk" /* LIQUIDATION_RISK */, value: 0.1, weight: 10, reason: "Liquidation risk is low due to the nature of the Re7 Pool on Vesu" },
@@ -68343,9 +68483,9 @@ ${indent}}` : "}";
       protocols: [endurProtocol, vesuProtocol],
       maxTVL: new Web3Number("1500000", 18),
       risk: {
-        riskFactor: _riskFactor3,
-        netRisk: _riskFactor3.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor3.reduce((acc, curr) => acc + curr.weight, 0),
-        notARisks: getNoRiskTags(_riskFactor3)
+        riskFactor: _riskFactor2,
+        netRisk: _riskFactor2.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor2.reduce((acc, curr) => acc + curr.weight, 0),
+        notARisks: getNoRiskTags(_riskFactor2)
       },
       additionalInfo: {
         mainToken: Global.getDefaultTokens().find((t) => t.symbol === "STRK"),
@@ -68369,7 +68509,9 @@ ${indent}}` : "}";
   ];
 
   // src/strategies/universal-adapters/adapter-utils.ts
-  var SIMPLE_SANITIZER = ContractAddr.from("0x3798dc4f83fdfad199e5236e3656cf2fb79bc50c00504d0dd41522e0f042072");
+  var SIMPLE_SANITIZER = ContractAddr.from("0x5a2e3ceb3da368b983a8717898427ab7b6daf04014b70f321e777f9aad940b4");
+  var PRICE_ROUTER = ContractAddr.from("0x05e83Fa38D791d2dba8E6f487758A9687FfEe191A6Cf8a6c5761ab0a110DB837");
+  var AVNU_MIDDLEWARE = ContractAddr.from("0x4a7972ed3f5d1e74a6d6c4a8f467666953d081c8f2270390cc169d50d17cb0d");
   function toBigInt3(value) {
     if (typeof value === "string") {
       return BigInt(value);
@@ -68512,6 +68654,66 @@ ${indent}}` : "}";
         };
       };
     }
+    getAvnuAdapter(fromToken, toToken, id) {
+      return () => ({
+        leaf: this.constructSimpleLeafData({
+          id,
+          target: AVNU_MIDDLEWARE,
+          method: "multi_route_swap",
+          packedArguments: [
+            fromToken.toBigInt(),
+            toToken.toBigInt(),
+            this.config.vaultAllocator.toBigInt()
+          ]
+        }),
+        callConstructor: this.getAvnuCall(fromToken, toToken).bind(this)
+      });
+    }
+    getAvnuCall(fromToken, toToken) {
+      return (params) => {
+        return {
+          sanitizer: SIMPLE_SANITIZER,
+          call: {
+            contractAddress: AVNU_MIDDLEWARE,
+            selector: hash_exports.getSelectorFromName("multi_route_swap"),
+            calldata: [
+              fromToken.toBigInt(),
+              // sell_token_address
+              toBigInt3(params.props.token_from_amount.low.toString()),
+              // sell_token_amount low
+              toBigInt3(params.props.token_from_amount.high.toString()),
+              // sell_token_amount high
+              toToken.toBigInt(),
+              // buy_token_address
+              toBigInt3(params.props.token_to_amount.low.toString()),
+              // buy_token_amount low
+              toBigInt3(params.props.token_to_amount.high.toString()),
+              // buy_token_amount high
+              toBigInt3(params.props.token_to_min_amount.low.toString()),
+              // buy_token_min_amount low
+              toBigInt3(params.props.token_to_min_amount.high.toString()),
+              // buy_token_min_amount high
+              this.config.vaultAllocator.toBigInt(),
+              // beneficiary
+              toBigInt3(0),
+              // integrator_fee_amount_bps
+              this.config.vaultAllocator.toBigInt(),
+              // integrator_fee_recipient
+              // unpack routes
+              BigInt(params.props.routes.length),
+              ...params.props.routes.map((r) => [
+                BigInt(num_exports.hexToDecimalString(r.token_from)),
+                BigInt(num_exports.hexToDecimalString(r.token_to)),
+                BigInt(num_exports.hexToDecimalString(r.exchange_address)),
+                BigInt(r.percent),
+                BigInt(r.additional_swap_params.length),
+                ...r.additional_swap_params.map((p) => BigInt(num_exports.hexToDecimalString(p)))
+              ]).flat()
+            ]
+          }
+        };
+      };
+    }
   };
 
   // src/data/vesu-singleton.abi.json
@@ -70845,6 +71047,40 @@ ${indent}}` : "}";
           }
         };
       };
+      this.getDefispringRewardsAdapter = (id) => {
+        return () => {
+          const packedArguments = [];
+          const output3 = {
+            id: BigInt(num_exports.getDecimalString(shortString_exports.encodeShortString(id))),
+            readableId: id,
+            data: [
+              SIMPLE_SANITIZER.toBigInt(),
+              // sanitizer address
+              VESU_REWARDS_CONTRACT.toBigInt(),
+              // contract
+              toBigInt3(hash_exports.getSelectorFromName("claim")),
+              // method name
+              BigInt(packedArguments.length),
+              ...packedArguments
+            ]
+          };
+          return { leaf: output3, callConstructor: this.getDefiSpringClaimCall().bind(this) };
+        };
+      };
+      this.getDefiSpringClaimCall = () => {
+        return (params) => ({
+          sanitizer: SIMPLE_SANITIZER,
+          call: {
+            contractAddress: VESU_REWARDS_CONTRACT,
+            selector: hash_exports.getSelectorFromName("claim"),
+            calldata: [
+              BigInt(params.amount.toWei()),
+              BigInt(params.proofs.length),
+              ...params.proofs.map((proof) => BigInt(num_exports.hexToDecimalString(proof)))
+            ]
+          }
+        });
+      };
       this.config = config2;
     }
     static getDefaultModifyPositionCallParams(params) {
@@ -73471,7 +73707,7 @@ ${indent}}` : "}";
       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;
+      const defispringAPY = (netAPY.splits.find((s) => s.id === "defispring")?.apy || 0) * 0.8;
       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);
@@ -73714,6 +73950,51 @@ ${indent}}` : "}";
       const manageCall = this.getManageCall(["approve_bring_liquidity" /* APPROVE_BRING_LIQUIDITY */, "bring_liquidity" /* BRING_LIQUIDITY */], [manageCall1, manageCall2]);
       return manageCall;
     }
+    async getHarvestCall() {
+      const vesuHarvest = new VesuHarvests(this.config);
+      const harvestInfo = await vesuHarvest.getUnHarvestedRewards(this.metadata.additionalInfo.vaultAllocator);
+      if (harvestInfo.length != 1) {
+        throw new Error(`Expected 1 harvest info, got ${harvestInfo.length}`);
+      }
+      const amount = harvestInfo[0].claim.amount;
+      const actualReward = harvestInfo[0].actualReward;
+      const proofs = harvestInfo[0].proof;
+      if (actualReward.isZero()) {
+        throw new Error(`Expected non-zero actual reward, got ${harvestInfo[0].actualReward}`);
+      }
+      const manage1Info = this.getProofs("defispring_rewards" /* DEFISPRING_REWARDS */);
+      const manageCall1 = manage1Info.callConstructor({
+        amount,
+        proofs
+      });
+      const proofIds = ["defispring_rewards" /* DEFISPRING_REWARDS */];
+      const manageCalls = [manageCall1];
+      const STRK2 = Global.getDefaultTokens().find((t) => t.symbol === "STRK");
+      if (this.asset().symbol != "STRK") {
+        const manage2Info = this.getProofs("approve_swap_token1" /* APPROVE_SWAP_TOKEN1 */);
+        const manageCall2 = manage2Info.callConstructor({
+          amount: actualReward
+        });
+        const avnuModule = new AvnuWrapper();
+        const quote = await avnuModule.getQuotes(
+          STRK2.address.address,
+          this.asset().address.address,
+          actualReward.toWei(),
+          this.address.address
+        );
+        const swapInfo = await avnuModule.getSwapInfo(quote, this.address.address, 0, this.address.address);
+        const manage3Info = this.getProofs("avnu_swap_rewards" /* AVNU_SWAP_REWARDS */);
+        const manageCall3 = manage3Info.callConstructor({
+          props: swapInfo
+        });
+        proofIds.push("approve_swap_token1" /* APPROVE_SWAP_TOKEN1 */);
+        proofIds.push("avnu_swap_rewards" /* AVNU_SWAP_REWARDS */);
+        manageCalls.push(manageCall2);
+        manageCalls.push(manageCall3);
+      }
+      const manageCall = this.getManageCall(proofIds, manageCalls);
+      return { call: manageCall, reward: actualReward, tokenInfo: STRK2 };
+    }
     async getRebalanceCall(params) {
       let callSet1 = this.getVesuModifyPositionCalls({
         isLeg1: true,
@@ -73750,6 +74031,9 @@ ${indent}}` : "}";
     UNIVERSAL_MANAGE_IDS2["APPROVE_TOKEN2"] = "approve_token2";
     UNIVERSAL_MANAGE_IDS2["APPROVE_BRING_LIQUIDITY"] = "approve_bring_liquidity";
     UNIVERSAL_MANAGE_IDS2["BRING_LIQUIDITY"] = "bring_liquidity";
+    UNIVERSAL_MANAGE_IDS2["DEFISPRING_REWARDS"] = "defispring_rewards";
+    UNIVERSAL_MANAGE_IDS2["APPROVE_SWAP_TOKEN1"] = "approve_swap_token1";
+    UNIVERSAL_MANAGE_IDS2["AVNU_SWAP_REWARDS"] = "avnu_swap_rewards";
     return UNIVERSAL_MANAGE_IDS2;
   })(UNIVERSAL_MANAGE_IDS || {});
   var UNIVERSAL_ADAPTERS = /* @__PURE__ */ ((UNIVERSAL_ADAPTERS2) => {
@@ -73799,9 +74083,13 @@ ${indent}}` : "}";
     vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(ETHToken.address, vesuAdapterETHUSDC.VESU_SINGLETON, "approve_token2" /* APPROVE_TOKEN2 */).bind(commonAdapter));
     vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(USDCToken.address, vaultSettings.vaultAddress, "approve_bring_liquidity" /* APPROVE_BRING_LIQUIDITY */).bind(commonAdapter));
     vaultSettings.leafAdapters.push(commonAdapter.getBringLiquidityAdapter("bring_liquidity" /* BRING_LIQUIDITY */).bind(commonAdapter));
+    vaultSettings.leafAdapters.push(vesuAdapterUSDCETH.getDefispringRewardsAdapter("defispring_rewards" /* DEFISPRING_REWARDS */).bind(vesuAdapterUSDCETH));
+    const STRKToken = Global.getDefaultTokens().find((token) => token.symbol === "STRK");
+    vaultSettings.leafAdapters.push(commonAdapter.getApproveAdapter(STRKToken.address, AVNU_MIDDLEWARE, "approve_swap_token1" /* APPROVE_SWAP_TOKEN1 */).bind(commonAdapter));
+    vaultSettings.leafAdapters.push(commonAdapter.getAvnuAdapter(STRKToken.address, USDCToken.address, "avnu_swap_rewards" /* AVNU_SWAP_REWARDS */).bind(commonAdapter));
     return vaultSettings;
   }
-  var _riskFactor4 = [
+  var _riskFactor3 = [
     { type: "Smart Contract Risk" /* SMART_CONTRACT_RISK */, value: 0.5, weight: 25, reason: "Audited by Zellic" },
     { type: "Liquidation Risk" /* LIQUIDATION_RISK */, value: 1.5, weight: 50, reason: "Liquidation risk is mitigated by stable price feed on Starknet" },
     { type: "Technical Risk" /* TECHNICAL_RISK */, value: 1, weight: 50, reason: "Technical failures like risk monitoring failures" }
@@ -74005,9 +74293,9 @@ ${indent}}` : "}";
       depositTokens: [Global.getDefaultTokens().find((token) => token.symbol === "USDC")],
       additionalInfo: getLooperSettings("USDC", "ETH", usdcVaultSettings, 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)
+        riskFactor: _riskFactor3,
+        netRisk: _riskFactor3.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor3.reduce((acc, curr) => acc + curr.weight, 0),
+        notARisks: getNoRiskTags(_riskFactor3)
       },
       protocols: [Protocols.VESU],
       maxTVL: Web3Number.fromWei(0, 6),
@@ -74024,9 +74312,9 @@ ${indent}}` : "}";
       depositTokens: [Global.getDefaultTokens().find((token) => token.symbol === "WBTC")],
       additionalInfo: getLooperSettings("WBTC", "ETH", wbtcVaultSettings, 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)
+        riskFactor: _riskFactor3,
+        netRisk: _riskFactor3.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor3.reduce((acc, curr) => acc + curr.weight, 0),
+        notARisks: getNoRiskTags(_riskFactor3)
       },
       protocols: [Protocols.VESU],
       maxTVL: Web3Number.fromWei(0, 8),
@@ -74043,9 +74331,9 @@ ${indent}}` : "}";
       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)
+        riskFactor: _riskFactor3,
+        netRisk: _riskFactor3.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor3.reduce((acc, curr) => acc + curr.weight, 0),
+        notARisks: getNoRiskTags(_riskFactor3)
       },
       protocols: [Protocols.VESU],
       maxTVL: Web3Number.fromWei(0, 18),
@@ -74062,9 +74350,9 @@ ${indent}}` : "}";
       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)
+        riskFactor: _riskFactor3,
+        netRisk: _riskFactor3.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor3.reduce((acc, curr) => acc + curr.weight, 0),
+        notARisks: getNoRiskTags(_riskFactor3)
       },
       protocols: [Protocols.VESU],
       maxTVL: Web3Number.fromWei(0, 18),
@@ -74081,9 +74369,9 @@ ${indent}}` : "}";
       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)
+        riskFactor: _riskFactor3,
+        netRisk: _riskFactor3.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor3.reduce((acc, curr) => acc + curr.weight, 0),
+        notARisks: getNoRiskTags(_riskFactor3)
       },
       protocols: [Protocols.VESU],
       maxTVL: Web3Number.fromWei(0, 6),