@strkfarm/sdk 1.0.62 → 1.0.63

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);
@@ -49667,8 +49667,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 +49956,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 +49975,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 +50044,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 +50080,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 +50099,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 +50162,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 +50569,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 +50669,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 +51157,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 +51234,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 +51335,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 +51712,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 +53786,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 +65441,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));
@@ -68369,7 +68370,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 +68515,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 +70908,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 +73568,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 +73811,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 +73892,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,6 +73944,10 @@ ${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 = [