@strkfarm/sdk 1.1.60 → 1.1.62

package/dist/index.browser.global.js

@@ -23,11 +23,11 @@ var strkfarm_risk_engine = (() => {
     for (var name in all3)
       __defProp(target, name, { get: all3[name], enumerable: true });
   };
-  var __copyProps = (to, from, except, desc) => {
-    if (from && typeof from === "object" || typeof from === "function") {
-      for (let key of __getOwnPropNames(from))
+  var __copyProps = (to, from2, except, desc) => {
+    if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+      for (let key of __getOwnPropNames(from2))
         if (!__hasOwnProp.call(to, key) && key !== except)
-          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+          __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
     }
     return to;
   };
@@ -1776,10 +1776,10 @@ var strkfarm_risk_engine = (() => {
         } else if (indexOf(seen, obj) >= 0) {
           return "[Circular]";
         }
-        function inspect2(value, from, noIndent) {
-          if (from) {
+        function inspect2(value, from2, noIndent) {
+          if (from2) {
             seen = $arrSlice.call(seen);
-            seen.push(from);
+            seen.push(from2);
           }
           if (noIndent) {
             var newOpts = {
@@ -5073,13 +5073,13 @@ var strkfarm_risk_engine = (() => {
         if (typeof separator !== "string")
           throw new Error("join separator should be string");
         return {
-          encode: (from) => {
-            if (!Array.isArray(from) || from.length && typeof from[0] !== "string")
+          encode: (from2) => {
+            if (!Array.isArray(from2) || from2.length && typeof from2[0] !== "string")
               throw new Error("join.encode input should be array of strings");
-            for (let i of from)
+            for (let i of from2)
               if (typeof i !== "string")
                 throw new Error(`join.encode: non-string input=${i}`);
-            return from.join(separator);
+            return from2.join(separator);
           },
           decode: (to) => {
             if (typeof to !== "string")
@@ -5125,12 +5125,12 @@ var strkfarm_risk_engine = (() => {
       function normalize3(fn) {
         if (typeof fn !== "function")
           throw new Error("normalize fn should be function");
-        return { encode: (from) => from, decode: (to) => fn(to) };
+        return { encode: (from2) => from2, decode: (to) => fn(to) };
       }
       // @__NO_SIDE_EFFECTS__
-      function convertRadix(data, from, to) {
-        if (from < 2)
-          throw new Error(`convertRadix: wrong from=${from}, base cannot be less than 2`);
+      function convertRadix(data, from2, to) {
+        if (from2 < 2)
+          throw new Error(`convertRadix: wrong from=${from2}, base cannot be less than 2`);
         if (to < 2)
           throw new Error(`convertRadix: wrong to=${to}, base cannot be less than 2`);
         if (!Array.isArray(data))
@@ -5142,7 +5142,7 @@ var strkfarm_risk_engine = (() => {
         const digits = Array.from(data);
         digits.forEach((d) => {
           /* @__PURE__ */ assertNumber(d);
-          if (d < 0 || d >= from)
+          if (d < 0 || d >= from2)
             throw new Error(`Wrong integer: ${d}`);
         });
         while (true) {
@@ -5150,8 +5150,8 @@ var strkfarm_risk_engine = (() => {
           let done = true;
           for (let i = pos; i < digits.length; i++) {
             const digit = digits[i];
-            const digitBase = from * carry + digit;
-            if (!Number.isSafeInteger(digitBase) || from * carry / from !== carry || digitBase - digit !== from * carry) {
+            const digitBase = from2 * carry + digit;
+            if (!Number.isSafeInteger(digitBase) || from2 * carry / from2 !== carry || digitBase - digit !== from2 * carry) {
               throw new Error("convertRadix: carry overflow");
             }
             carry = digitBase % to;
@@ -5175,17 +5175,17 @@ var strkfarm_risk_engine = (() => {
         return res.reverse();
       }
       var gcd2 = /* @__NO_SIDE_EFFECTS__ */ (a, b) => !b ? a : /* @__PURE__ */ gcd2(b, a % b);
-      var radix2carry2 = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - /* @__PURE__ */ gcd2(from, to));
+      var radix2carry2 = /* @__NO_SIDE_EFFECTS__ */ (from2, to) => from2 + (to - /* @__PURE__ */ gcd2(from2, to));
       // @__NO_SIDE_EFFECTS__
-      function convertRadix22(data, from, to, padding3) {
+      function convertRadix22(data, from2, to, padding3) {
         if (!Array.isArray(data))
           throw new Error("convertRadix2: data should be array");
-        if (from <= 0 || from > 32)
-          throw new Error(`convertRadix2: wrong from=${from}`);
+        if (from2 <= 0 || from2 > 32)
+          throw new Error(`convertRadix2: wrong from=${from2}`);
         if (to <= 0 || to > 32)
           throw new Error(`convertRadix2: wrong to=${to}`);
-        if (/* @__PURE__ */ radix2carry2(from, to) > 32) {
-          throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${/* @__PURE__ */ radix2carry2(from, to)}`);
+        if (/* @__PURE__ */ radix2carry2(from2, to) > 32) {
+          throw new Error(`convertRadix2: carry overflow from=${from2} to=${to} carryBits=${/* @__PURE__ */ radix2carry2(from2, to)}`);
         }
         let carry = 0;
         let pos = 0;
@@ -5193,18 +5193,18 @@ var strkfarm_risk_engine = (() => {
         const res = [];
         for (const n of data) {
           /* @__PURE__ */ assertNumber(n);
-          if (n >= 2 ** from)
-            throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
-          carry = carry << from | n;
-          if (pos + from > 32)
-            throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
-          pos += from;
+          if (n >= 2 ** from2)
+            throw new Error(`convertRadix2: invalid data word=${n} from=${from2}`);
+          carry = carry << from2 | n;
+          if (pos + from2 > 32)
+            throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from2}`);
+          pos += from2;
           for (; pos >= to; pos -= to)
             res.push((carry >> pos - to & mask2) >>> 0);
           carry &= 2 ** pos - 1;
         }
         carry = carry << to - pos & mask2;
-        if (!padding3 && pos >= from)
+        if (!padding3 && pos >= from2)
           throw new Error("Excess padding");
         if (!padding3 && carry)
           throw new Error(`Non-zero padding: ${carry}`);
@@ -8424,7 +8424,7 @@ var strkfarm_risk_engine = (() => {
         function normalizeS(s) {
           return isBiggerThanHalfOrder(s) ? modN(-s) : s;
         }
-        const slcNum = (b, from, to) => ut.bytesToNumberBE(b.slice(from, to));
+        const slcNum = (b, from2, to) => ut.bytesToNumberBE(b.slice(from2, to));
         class Signature3 {
           constructor(r, s, recovery) {
             this.r = r;
@@ -10302,7 +10302,7 @@ var strkfarm_risk_engine = (() => {
         function normalizeS(s) {
           return isBiggerThanHalfOrder(s) ? modN(-s) : s;
         }
-        const slcNum = (b, from, to) => ut.bytesToNumberBE(b.slice(from, to));
+        const slcNum = (b, from2, to) => ut.bytesToNumberBE(b.slice(from2, to));
         class Signature3 {
           constructor(r, s, recovery) {
             this.r = r;
@@ -13249,7 +13249,7 @@ ${r2}}` : "}", l2;
         let op;
         let len;
         let dist;
-        let from;
+        let from2;
         let from_source;
         let input, output;
         const state = strm.state;
@@ -13342,72 +13342,72 @@ ${r2}}` : "}", l2;
                               break top;
                             }
                           }
-                          from = 0;
+                          from2 = 0;
                           from_source = s_window;
                           if (wnext === 0) {
-                            from += wsize - op;
+                            from2 += wsize - op;
                             if (op < len) {
                               len -= op;
                               do {
-                                output[_out++] = s_window[from++];
+                                output[_out++] = s_window[from2++];
                               } while (--op);
-                              from = _out - dist;
+                              from2 = _out - dist;
                               from_source = output;
                             }
                           } else if (wnext < op) {
-                            from += wsize + wnext - op;
+                            from2 += wsize + wnext - op;
                             op -= wnext;
                             if (op < len) {
                               len -= op;
                               do {
-                                output[_out++] = s_window[from++];
+                                output[_out++] = s_window[from2++];
                               } while (--op);
-                              from = 0;
+                              from2 = 0;
                               if (wnext < len) {
                                 op = wnext;
                                 len -= op;
                                 do {
-                                  output[_out++] = s_window[from++];
+                                  output[_out++] = s_window[from2++];
                                 } while (--op);
-                                from = _out - dist;
+                                from2 = _out - dist;
                                 from_source = output;
                               }
                             }
                           } else {
-                            from += wnext - op;
+                            from2 += wnext - op;
                             if (op < len) {
                               len -= op;
                               do {
-                                output[_out++] = s_window[from++];
+                                output[_out++] = s_window[from2++];
                               } while (--op);
-                              from = _out - dist;
+                              from2 = _out - dist;
                               from_source = output;
                             }
                           }
                           while (len > 2) {
-                            output[_out++] = from_source[from++];
-                            output[_out++] = from_source[from++];
-                            output[_out++] = from_source[from++];
+                            output[_out++] = from_source[from2++];
+                            output[_out++] = from_source[from2++];
+                            output[_out++] = from_source[from2++];
                             len -= 3;
                           }
                           if (len) {
-                            output[_out++] = from_source[from++];
+                            output[_out++] = from_source[from2++];
                             if (len > 1) {
-                              output[_out++] = from_source[from++];
+                              output[_out++] = from_source[from2++];
                             }
                           }
                         } else {
-                          from = _out - dist;
+                          from2 = _out - dist;
                           do {
-                            output[_out++] = output[from++];
-                            output[_out++] = output[from++];
-                            output[_out++] = output[from++];
+                            output[_out++] = output[from2++];
+                            output[_out++] = output[from2++];
+                            output[_out++] = output[from2++];
                             len -= 3;
                           } while (len > 2);
                           if (len) {
-                            output[_out++] = output[from++];
+                            output[_out++] = output[from2++];
                             if (len > 1) {
-                              output[_out++] = output[from++];
+                              output[_out++] = output[from2++];
                             }
                           }
                         }
@@ -14029,7 +14029,7 @@ ${r2}}` : "}", l2;
         let bits;
         let _in, _out;
         let copy;
-        let from;
+        let from2;
         let from_source;
         let here = 0;
         let here_bits, here_op, here_val;
@@ -14828,9 +14828,9 @@ ${r2}}` : "}", l2;
                   }
                   if (copy > state.wnext) {
                     copy -= state.wnext;
-                    from = state.wsize - copy;
+                    from2 = state.wsize - copy;
                   } else {
-                    from = state.wnext - copy;
+                    from2 = state.wnext - copy;
                   }
                   if (copy > state.length) {
                     copy = state.length;
@@ -14838,7 +14838,7 @@ ${r2}}` : "}", l2;
                   from_source = state.window;
                 } else {
                   from_source = output;
-                  from = put - state.offset;
+                  from2 = put - state.offset;
                   copy = state.length;
                 }
                 if (copy > left) {
@@ -14847,7 +14847,7 @@ ${r2}}` : "}", l2;
                 left -= copy;
                 state.length -= copy;
                 do {
-                  output[put++] = from_source[from++];
+                  output[put++] = from_source[from2++];
                 } while (--copy);
                 if (state.length === 0) {
                   state.mode = LEN2;
@@ -18870,11 +18870,11 @@ ${r2}}` : "}", l2;
         for (var name in all3)
           __defProp3(target, name, { get: all3[name], enumerable: true });
       };
-      var __copyProps3 = (to, from, except, desc) => {
-        if (from && typeof from === "object" || typeof from === "function") {
-          for (let key of __getOwnPropNames3(from))
+      var __copyProps3 = (to, from2, except, desc) => {
+        if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+          for (let key of __getOwnPropNames3(from2))
             if (!__hasOwnProp3.call(to, key) && key !== except)
-              __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
+              __defProp3(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc3(from2, key)) || desc.enumerable });
         }
         return to;
       };
@@ -19676,11 +19676,11 @@ ${r2}}` : "}", l2;
         for (var name in all3)
           __defProp3(target, name, { get: all3[name], enumerable: true });
       };
-      var __copyProps3 = (to, from, except, desc) => {
-        if (from && typeof from === "object" || typeof from === "function") {
-          for (let key of __getOwnPropNames3(from))
+      var __copyProps3 = (to, from2, except, desc) => {
+        if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+          for (let key of __getOwnPropNames3(from2))
             if (!__hasOwnProp3.call(to, key) && key !== except)
-              __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
+              __defProp3(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc3(from2, key)) || desc.enumerable });
         }
         return to;
       };
@@ -31849,9 +31849,9 @@ ${r2}}` : "}", l2;
   function join(separator = "") {
     astr("join", separator);
     return {
-      encode: (from) => {
-        astrArr("join.decode", from);
-        return from.join(separator);
+      encode: (from2) => {
+        astrArr("join.decode", from2);
+        return from2.join(separator);
       },
       decode: (to) => {
         astr("join.decode", to);
@@ -31886,35 +31886,35 @@ ${r2}}` : "}", l2;
     };
   }
   var gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
-  var radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));
+  var radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from2, to) => from2 + (to - gcd(from2, to));
   var powers = /* @__PURE__ */ (() => {
     let res = [];
     for (let i = 0; i < 40; i++)
       res.push(2 ** i);
     return res;
   })();
-  function convertRadix2(data, from, to, padding2) {
+  function convertRadix2(data, from2, to, padding2) {
     aArr(data);
-    if (from <= 0 || from > 32)
-      throw new Error(`convertRadix2: wrong from=${from}`);
+    if (from2 <= 0 || from2 > 32)
+      throw new Error(`convertRadix2: wrong from=${from2}`);
     if (to <= 0 || to > 32)
       throw new Error(`convertRadix2: wrong to=${to}`);
-    if (/* @__PURE__ */ radix2carry(from, to) > 32) {
-      throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from, to)}`);
+    if (/* @__PURE__ */ radix2carry(from2, to) > 32) {
+      throw new Error(`convertRadix2: carry overflow from=${from2} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from2, to)}`);
     }
     let carry = 0;
     let pos = 0;
-    const max = powers[from];
+    const max = powers[from2];
     const mask2 = powers[to] - 1;
     const res = [];
     for (const n of data) {
       anumber(n);
       if (n >= max)
-        throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
-      carry = carry << from | n;
-      if (pos + from > 32)
-        throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
-      pos += from;
+        throw new Error(`convertRadix2: invalid data word=${n} from=${from2}`);
+      carry = carry << from2 | n;
+      if (pos + from2 > 32)
+        throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from2}`);
+      pos += from2;
       for (; pos >= to; pos -= to)
         res.push((carry >> pos - to & mask2) >>> 0);
       const pow3 = powers[pos];
@@ -31923,7 +31923,7 @@ ${r2}}` : "}", l2;
       carry &= pow3 - 1;
     }
     carry = carry << to - pos & mask2;
-    if (!padding2 && pos >= from)
+    if (!padding2 && pos >= from2)
       throw new Error("Excess padding");
     if (!padding2 && carry > 0)
       throw new Error(`Non-zero padding: ${carry}`);
@@ -34625,7 +34625,7 @@ ${indent2}}` : "}";
     function normalizeS(s) {
       return isBiggerThanHalfOrder(s) ? modN(-s) : s;
     }
-    const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
+    const slcNum = (b, from2, to) => bytesToNumberBE(b.slice(from2, to));
     class Signature3 {
       constructor(r, s, recovery) {
         this.r = r;
@@ -37571,7 +37571,7 @@ ${indent2}}` : "}";
     let op;
     let len;
     let dist;
-    let from;
+    let from2;
     let from_source;
     let input, output;
     const state = strm.state;
@@ -37664,72 +37664,72 @@ ${indent2}}` : "}";
                           break top;
                         }
                       }
-                      from = 0;
+                      from2 = 0;
                       from_source = s_window;
                       if (wnext === 0) {
-                        from += wsize - op;
+                        from2 += wsize - op;
                         if (op < len) {
                           len -= op;
                           do {
-                            output[_out++] = s_window[from++];
+                            output[_out++] = s_window[from2++];
                           } while (--op);
-                          from = _out - dist;
+                          from2 = _out - dist;
                           from_source = output;
                         }
                       } else if (wnext < op) {
-                        from += wsize + wnext - op;
+                        from2 += wsize + wnext - op;
                         op -= wnext;
                         if (op < len) {
                           len -= op;
                           do {
-                            output[_out++] = s_window[from++];
+                            output[_out++] = s_window[from2++];
                           } while (--op);
-                          from = 0;
+                          from2 = 0;
                           if (wnext < len) {
                             op = wnext;
                             len -= op;
                             do {
-                              output[_out++] = s_window[from++];
+                              output[_out++] = s_window[from2++];
                             } while (--op);
-                            from = _out - dist;
+                            from2 = _out - dist;
                             from_source = output;
                           }
                         }
                       } else {
-                        from += wnext - op;
+                        from2 += wnext - op;
                         if (op < len) {
                           len -= op;
                           do {
-                            output[_out++] = s_window[from++];
+                            output[_out++] = s_window[from2++];
                           } while (--op);
-                          from = _out - dist;
+                          from2 = _out - dist;
                           from_source = output;
                         }
                       }
                       while (len > 2) {
-                        output[_out++] = from_source[from++];
-                        output[_out++] = from_source[from++];
-                        output[_out++] = from_source[from++];
+                        output[_out++] = from_source[from2++];
+                        output[_out++] = from_source[from2++];
+                        output[_out++] = from_source[from2++];
                         len -= 3;
                       }
                       if (len) {
-                        output[_out++] = from_source[from++];
+                        output[_out++] = from_source[from2++];
                         if (len > 1) {
-                          output[_out++] = from_source[from++];
+                          output[_out++] = from_source[from2++];
                         }
                       }
                     } else {
-                      from = _out - dist;
+                      from2 = _out - dist;
                       do {
-                        output[_out++] = output[from++];
-                        output[_out++] = output[from++];
-                        output[_out++] = output[from++];
+                        output[_out++] = output[from2++];
+                        output[_out++] = output[from2++];
+                        output[_out++] = output[from2++];
                         len -= 3;
                       } while (len > 2);
                       if (len) {
-                        output[_out++] = output[from++];
+                        output[_out++] = output[from2++];
                         if (len > 1) {
-                          output[_out++] = output[from++];
+                          output[_out++] = output[from2++];
                         }
                       }
                     }
@@ -38333,7 +38333,7 @@ ${indent2}}` : "}";
     let bits;
     let _in, _out;
     let copy;
-    let from;
+    let from2;
     let from_source;
     let here = 0;
     let here_bits, here_op, here_val;
@@ -39132,9 +39132,9 @@ ${indent2}}` : "}";
               }
               if (copy > state.wnext) {
                 copy -= state.wnext;
-                from = state.wsize - copy;
+                from2 = state.wsize - copy;
               } else {
-                from = state.wnext - copy;
+                from2 = state.wnext - copy;
               }
               if (copy > state.length) {
                 copy = state.length;
@@ -39142,7 +39142,7 @@ ${indent2}}` : "}";
               from_source = state.window;
             } else {
               from_source = output;
-              from = put - state.offset;
+              from2 = put - state.offset;
               copy = state.length;
             }
             if (copy > left) {
@@ -39151,7 +39151,7 @@ ${indent2}}` : "}";
             left -= copy;
             state.length -= copy;
             do {
-              output[put++] = from_source[from++];
+              output[put++] = from_source[from2++];
             } while (--copy);
             if (state.length === 0) {
               state.mode = LEN;
@@ -39600,11 +39600,11 @@ ${indent2}}` : "}";
     for (var name in all3)
       __defProp2(target, name, { get: all3[name], enumerable: true });
   };
-  var __copyProps2 = (to, from, except, desc) => {
-    if (from && typeof from === "object" || typeof from === "function") {
-      for (let key of __getOwnPropNames2(from))
+  var __copyProps2 = (to, from2, except, desc) => {
+    if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+      for (let key of __getOwnPropNames2(from2))
         if (!__hasOwnProp2.call(to, key) && key !== except)
-          __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+          __defProp2(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
     }
     return to;
   };
@@ -67167,14 +67167,14 @@ ${JSON.stringify(data, null, 2)}`;
       return { value: op[0] ? op[1] : void 0, done: true };
     }
   }
-  function __spreadArray(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-      if (ar || !(i in from)) {
-        if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-        ar[i] = from[i];
+  function __spreadArray(to, from2, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from2.length, ar; i < l; i++) {
+      if (ar || !(i in from2)) {
+        if (!ar) ar = Array.prototype.slice.call(from2, 0, i);
+        ar[i] = from2[i];
       }
     }
-    return to.concat(ar || Array.prototype.slice.call(from));
+    return to.concat(ar || Array.prototype.slice.call(from2));
   }
 
   // node_modules/.pnpm/ts-invariant@0.10.3/node_modules/ts-invariant/lib/invariant.js
@@ -72722,7 +72722,7 @@ spurious results.`);
     _proto3[SymbolObservable] = function() {
       return this;
     };
-    Observable2.from = function from(x) {
+    Observable2.from = function from2(x) {
       var C = typeof this === "function" ? this : Observable2;
       if (x == null) throw new TypeError(x + " is not an object");
       var method = getMethod(x, SymbolObservable);
@@ -74288,7 +74288,7 @@ spurious results.`);
       };
       ApolloCache2.prototype.watchFragment = function(options) {
         var _this = this;
-        var fragment = options.fragment, fragmentName = options.fragmentName, from = options.from, _a21 = options.optimistic, optimistic = _a21 === void 0 ? true : _a21, otherOptions = __rest(options, ["fragment", "fragmentName", "from", "optimistic"]);
+        var fragment = options.fragment, fragmentName = options.fragmentName, from2 = options.from, _a21 = options.optimistic, optimistic = _a21 === void 0 ? true : _a21, otherOptions = __rest(options, ["fragment", "fragmentName", "from", "optimistic"]);
         var query = this.getFragmentDoc(fragment, fragmentName);
         var diffOptions = __assign(__assign({}, otherOptions), { returnPartialData: true, id: (
           // While our TypeScript types do not allow for `undefined` as a valid
@@ -74297,7 +74297,7 @@ spurious results.`);
           // adding this fix here however to ensure those using plain JavaScript
           // and using `cache.identify` themselves will avoid seeing the obscure
           // warning.
-          typeof from === "undefined" || typeof from === "string" ? from : this.identify(from)
+          typeof from2 === "undefined" || typeof from2 === "string" ? from2 : this.identify(from2)
         ), query, optimistic });
         var latestDiff;
         return new Observable(function(observer) {
@@ -74608,10 +74608,10 @@ spurious results.`);
             isReference,
             toReference: this.toReference,
             canRead: this.canRead,
-            readField: function(fieldNameOrOptions, from) {
+            readField: function(fieldNameOrOptions, from2) {
               return _this.policies.readField(typeof fieldNameOrOptions === "string" ? {
                 fieldName: fieldNameOrOptions,
-                from: from || makeReference(dataId)
+                from: from2 || makeReference(dataId)
               } : fieldNameOrOptions, { store: _this });
             }
           };
@@ -75437,8 +75437,8 @@ spurious results.`);
   function keyFieldsFnFromSpecifier(specifier) {
     var info = lookupSpecifierInfo(specifier);
     return info.keyFieldsFn || (info.keyFieldsFn = function(object, context) {
-      var extract = function(from, key) {
-        return context.readField(key, from);
+      var extract = function(from2, key) {
+        return context.readField(key, from2);
       };
       var keyObject = context.keyObject = collectSpecifierPaths(specifier, function(schemaKeyPath) {
         var extracted = extractKeyPath(
@@ -75944,7 +75944,7 @@ spurious results.`);
     };
   }
   function normalizeReadFieldOptions(readFieldArgs, objectOrReference, variables) {
-    var fieldNameOrOptions = readFieldArgs[0], from = readFieldArgs[1], argc = readFieldArgs.length;
+    var fieldNameOrOptions = readFieldArgs[0], from2 = readFieldArgs[1], argc = readFieldArgs.length;
     var options;
     if (typeof fieldNameOrOptions === "string") {
       options = {
@@ -75952,7 +75952,7 @@ spurious results.`);
         // Default to objectOrReference only when no second argument was
         // passed for the from parameter, not when undefined is explicitly
         // passed as the second argument.
-        from: argc > 1 ? from : objectOrReference
+        from: argc > 1 ? from2 : objectOrReference
       };
     } else {
       options = __assign({}, fieldNameOrOptions);
@@ -76287,8 +76287,8 @@ spurious results.`);
             getStorageArgs = [isReference(e_1) ? e_1.__ref : e_1];
           }
           var changedFields_1;
-          var getValue_1 = function(from, name) {
-            return isArray2(from) ? typeof name === "number" ? from[name] : void 0 : context.store.getFieldValue(from, String(name));
+          var getValue_1 = function(from2, name) {
+            return isArray2(from2) ? typeof name === "number" ? from2[name] : void 0 : context.store.getFieldValue(from2, String(name));
           };
           mergeTree.map.forEach(function(childTree, storeFieldName) {
             var eVal = getValue_1(e_1, storeFieldName);
@@ -80178,6 +80178,12 @@ spurious results.`);
           amount1: availableAmount1.minus(y),
           ratio: 0
         };
+      } else if (ratio.eq(Infinity)) {
+        return {
+          amount0: availableAmount0,
+          amount1: Web3Number.fromWei("0", availableAmount1.decimals),
+          ratio: Infinity
+        };
       }
       return {
         amount0: availableAmount0.plus(x),
@@ -80285,6 +80291,7 @@ spurious results.`);
     // Helper to determine which token to sell, which to buy, and the amounts to use
     getSwapParams(expectedAmounts, poolKey, token0Bal, token1Bal) {
       const tokenToSell = expectedAmounts.amount0.lessThan(token0Bal) ? poolKey.token0 : poolKey.token1;
+      logger2.verbose(`getSwapParams => tokenToSell: ${tokenToSell.address}, expectedAmounts: ${expectedAmounts.amount0.toString()}, bal0: ${token0Bal.toString()}`);
       const tokenToBuy = tokenToSell == poolKey.token0 ? poolKey.token1 : poolKey.token0;
       const amountToSell = tokenToSell == poolKey.token0 ? token0Bal.minus(expectedAmounts.amount0) : token1Bal.minus(expectedAmounts.amount1);
       if (amountToSell.eq(0)) {
@@ -80424,14 +80431,22 @@ spurious results.`);
      * @param retry - Current retry attempt number (default 0)
      * @param adjustmentFactor - Percentage to adjust swap amount by (default 1)
      * @param isToken0Deficit - Whether token0 balance needs increasing (default true)
+     * @param MAX_RETRIES - Maximum number of retries (default 40)
+     * @param sameErrorCount - For certain errors, we just retry with same amount again. This is the count of such retries (default { count: 0, error: null })
+     * @param MAX_SAME_ERROR_COUNT - For certain errors, we just retry with same amount again. This limits such retries (default 10)
      * @returns Array of contract calls needed for rebalancing
-     * @throws Error if max retries reached without successful rebalance
+     * @throws Error if max retries reached without successful rebalance or max same errors reached
      */
-    async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40) {
+    async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40, sameErrorCount = { count: 0, error: null }, MAX_SAME_ERROR_COUNT = 10) {
       logger2.verbose(
-        `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}`
+        `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}, MAX_RETRIES=${MAX_RETRIES}, sameErrorCount=${sameErrorCount.error} (${sameErrorCount.count})`
       );
+      if (sameErrorCount.count >= MAX_SAME_ERROR_COUNT) {
+        logger2.error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+        throw new Error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+      }
       const fromAmount = uint256_exports.uint256ToBN(swapInfo.token_from_amount);
+      const fromTokenInfo = await Global.getTokenInfoFromAddr(ContractAddr.from(swapInfo.token_from_address));
       logger2.verbose(
         `Selling ${fromAmount.toString()} of token ${swapInfo.token_from_address}`
       );
@@ -80448,8 +80463,8 @@ spurious results.`);
           `Rebalance attempt ${retry + 1} failed, adjusting swap amount...`
         );
         const newSwapInfo = { ...swapInfo };
-        const currentAmount = Web3Number.fromWei(fromAmount.toString(), 18);
-        logger2.verbose(`Current amount: ${currentAmount.toString()}`);
+        const currentAmount = Web3Number.fromWei(fromAmount.toString(), fromTokenInfo.decimals);
+        logger2.verbose(`Current amount: ${currentAmount.toString()}, lowerLimit: ${lowerLimit.toString()}, upperLimit: ${upperLimit.toString()}`);
         if (err2.message.includes("invalid token0 balance") || err2.message.includes("invalid token0 amount")) {
           if (!isSellTokenToken0) {
             logger2.verbose("Reducing swap amount - excess token0");
@@ -80496,6 +80511,30 @@ spurious results.`);
             }
             newSwapInfo.token_from_amount = uint256_exports.bnToUint256(nextAmount);
           }
+        } else if (err2.message.includes("Residual tokens")) {
+          logger2.error("Residual tokens");
+          if (sameErrorCount.error == "Residual tokens") {
+            sameErrorCount.count++;
+          } else {
+            sameErrorCount.error = "Residual tokens";
+            sameErrorCount.count = 1;
+          }
+        } else if (err2.message.includes("Insufficient tokens received")) {
+          logger2.error("Insufficient tokens received");
+          if (sameErrorCount.error == "Insufficient tokens received") {
+            sameErrorCount.count++;
+          } else {
+            sameErrorCount.error = "Insufficient tokens received";
+            sameErrorCount.count = 1;
+          }
+        } else if (err2.message.includes("Could not reach the end of the program")) {
+          logger2.error("Could not reach the end of the program, may be the block is full (could be a temp/permanent gas issue)");
+          if (sameErrorCount.error == "Could not reach the end of the program") {
+            sameErrorCount.count++;
+          } else {
+            sameErrorCount.error = "Could not reach the end of the program";
+            sameErrorCount.count = 1;
+          }
         } else {
           logger2.error("Unexpected error:", err2);
           throw err2;
@@ -80508,7 +80547,10 @@ spurious results.`);
           isSellTokenToken0,
           retry + 1,
           lowerLimit,
-          upperLimit
+          upperLimit,
+          MAX_RETRIES,
+          sameErrorCount,
+          MAX_SAME_ERROR_COUNT
         );
       }
     }

package/dist/index.browser.mjs

@@ -16255,6 +16255,12 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         amount1: availableAmount1.minus(y),
         ratio: 0
       };
+    } else if (ratio.eq(Infinity)) {
+      return {
+        amount0: availableAmount0,
+        amount1: Web3Number.fromWei("0", availableAmount1.decimals),
+        ratio: Infinity
+      };
     }
     return {
       amount0: availableAmount0.plus(x),
@@ -16362,6 +16368,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
   // Helper to determine which token to sell, which to buy, and the amounts to use
   getSwapParams(expectedAmounts, poolKey, token0Bal, token1Bal) {
     const tokenToSell = expectedAmounts.amount0.lessThan(token0Bal) ? poolKey.token0 : poolKey.token1;
+    logger.verbose(`getSwapParams => tokenToSell: ${tokenToSell.address}, expectedAmounts: ${expectedAmounts.amount0.toString()}, bal0: ${token0Bal.toString()}`);
     const tokenToBuy = tokenToSell == poolKey.token0 ? poolKey.token1 : poolKey.token0;
     const amountToSell = tokenToSell == poolKey.token0 ? token0Bal.minus(expectedAmounts.amount0) : token1Bal.minus(expectedAmounts.amount1);
     if (amountToSell.eq(0)) {
@@ -16501,14 +16508,22 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
    * @param retry - Current retry attempt number (default 0)
    * @param adjustmentFactor - Percentage to adjust swap amount by (default 1)
    * @param isToken0Deficit - Whether token0 balance needs increasing (default true)
+   * @param MAX_RETRIES - Maximum number of retries (default 40)
+   * @param sameErrorCount - For certain errors, we just retry with same amount again. This is the count of such retries (default { count: 0, error: null })
+   * @param MAX_SAME_ERROR_COUNT - For certain errors, we just retry with same amount again. This limits such retries (default 10)
    * @returns Array of contract calls needed for rebalancing
-   * @throws Error if max retries reached without successful rebalance
+   * @throws Error if max retries reached without successful rebalance or max same errors reached
    */
-  async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40) {
+  async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40, sameErrorCount = { count: 0, error: null }, MAX_SAME_ERROR_COUNT = 10) {
     logger.verbose(
-      `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}`
+      `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}, MAX_RETRIES=${MAX_RETRIES}, sameErrorCount=${sameErrorCount.error} (${sameErrorCount.count})`
     );
+    if (sameErrorCount.count >= MAX_SAME_ERROR_COUNT) {
+      logger.error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+      throw new Error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+    }
     const fromAmount = uint2564.uint256ToBN(swapInfo.token_from_amount);
+    const fromTokenInfo = await Global.getTokenInfoFromAddr(ContractAddr.from(swapInfo.token_from_address));
     logger.verbose(
       `Selling ${fromAmount.toString()} of token ${swapInfo.token_from_address}`
     );
@@ -16525,8 +16540,8 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         `Rebalance attempt ${retry + 1} failed, adjusting swap amount...`
       );
       const newSwapInfo = { ...swapInfo };
-      const currentAmount = Web3Number.fromWei(fromAmount.toString(), 18);
-      logger.verbose(`Current amount: ${currentAmount.toString()}`);
+      const currentAmount = Web3Number.fromWei(fromAmount.toString(), fromTokenInfo.decimals);
+      logger.verbose(`Current amount: ${currentAmount.toString()}, lowerLimit: ${lowerLimit.toString()}, upperLimit: ${upperLimit.toString()}`);
       if (err.message.includes("invalid token0 balance") || err.message.includes("invalid token0 amount")) {
         if (!isSellTokenToken0) {
           logger.verbose("Reducing swap amount - excess token0");
@@ -16573,6 +16588,30 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
           }
           newSwapInfo.token_from_amount = uint2564.bnToUint256(nextAmount);
         }
+      } else if (err.message.includes("Residual tokens")) {
+        logger.error("Residual tokens");
+        if (sameErrorCount.error == "Residual tokens") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Residual tokens";
+          sameErrorCount.count = 1;
+        }
+      } else if (err.message.includes("Insufficient tokens received")) {
+        logger.error("Insufficient tokens received");
+        if (sameErrorCount.error == "Insufficient tokens received") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Insufficient tokens received";
+          sameErrorCount.count = 1;
+        }
+      } else if (err.message.includes("Could not reach the end of the program")) {
+        logger.error("Could not reach the end of the program, may be the block is full (could be a temp/permanent gas issue)");
+        if (sameErrorCount.error == "Could not reach the end of the program") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Could not reach the end of the program";
+          sameErrorCount.count = 1;
+        }
       } else {
         logger.error("Unexpected error:", err);
         throw err;
@@ -16585,7 +16624,10 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         isSellTokenToken0,
         retry + 1,
         lowerLimit,
-        upperLimit
+        upperLimit,
+        MAX_RETRIES,
+        sameErrorCount,
+        MAX_SAME_ERROR_COUNT
       );
     }
   }

package/dist/index.d.ts

@@ -813,10 +813,16 @@ declare class EkuboCLVault extends BaseStrategy<DualTokenInfo, DualActionAmount>
      * @param retry - Current retry attempt number (default 0)
      * @param adjustmentFactor - Percentage to adjust swap amount by (default 1)
      * @param isToken0Deficit - Whether token0 balance needs increasing (default true)
+     * @param MAX_RETRIES - Maximum number of retries (default 40)
+     * @param sameErrorCount - For certain errors, we just retry with same amount again. This is the count of such retries (default { count: 0, error: null })
+     * @param MAX_SAME_ERROR_COUNT - For certain errors, we just retry with same amount again. This limits such retries (default 10)
      * @returns Array of contract calls needed for rebalancing
-     * @throws Error if max retries reached without successful rebalance
+     * @throws Error if max retries reached without successful rebalance or max same errors reached
      */
-    rebalanceIter(swapInfo: SwapInfo, acc: Account, estimateCall: (swapInfo: SwapInfo) => Promise<Call[]>, isSellTokenToken0?: boolean, retry?: number, lowerLimit?: bigint, upperLimit?: bigint, MAX_RETRIES?: number): Promise<Call[]>;
+    rebalanceIter(swapInfo: SwapInfo, acc: Account, estimateCall: (swapInfo: SwapInfo) => Promise<Call[]>, isSellTokenToken0?: boolean, retry?: number, lowerLimit?: bigint, upperLimit?: bigint, MAX_RETRIES?: number, sameErrorCount?: {
+        count: number;
+        error: null | string;
+    }, MAX_SAME_ERROR_COUNT?: number): Promise<Call[]>;
     static tickToi129(tick: number): {
         mag: number;
         sign: number;

package/dist/index.js

@@ -9,11 +9,11 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
   }
   return to;
 };
@@ -16255,6 +16255,12 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         amount1: availableAmount1.minus(y),
         ratio: 0
       };
+    } else if (ratio.eq(Infinity)) {
+      return {
+        amount0: availableAmount0,
+        amount1: Web3Number.fromWei("0", availableAmount1.decimals),
+        ratio: Infinity
+      };
     }
     return {
       amount0: availableAmount0.plus(x),
@@ -16362,6 +16368,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
   // Helper to determine which token to sell, which to buy, and the amounts to use
   getSwapParams(expectedAmounts, poolKey, token0Bal, token1Bal) {
     const tokenToSell = expectedAmounts.amount0.lessThan(token0Bal) ? poolKey.token0 : poolKey.token1;
+    logger.verbose(`getSwapParams => tokenToSell: ${tokenToSell.address}, expectedAmounts: ${expectedAmounts.amount0.toString()}, bal0: ${token0Bal.toString()}`);
     const tokenToBuy = tokenToSell == poolKey.token0 ? poolKey.token1 : poolKey.token0;
     const amountToSell = tokenToSell == poolKey.token0 ? token0Bal.minus(expectedAmounts.amount0) : token1Bal.minus(expectedAmounts.amount1);
     if (amountToSell.eq(0)) {
@@ -16501,14 +16508,22 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
    * @param retry - Current retry attempt number (default 0)
    * @param adjustmentFactor - Percentage to adjust swap amount by (default 1)
    * @param isToken0Deficit - Whether token0 balance needs increasing (default true)
+   * @param MAX_RETRIES - Maximum number of retries (default 40)
+   * @param sameErrorCount - For certain errors, we just retry with same amount again. This is the count of such retries (default { count: 0, error: null })
+   * @param MAX_SAME_ERROR_COUNT - For certain errors, we just retry with same amount again. This limits such retries (default 10)
    * @returns Array of contract calls needed for rebalancing
-   * @throws Error if max retries reached without successful rebalance
+   * @throws Error if max retries reached without successful rebalance or max same errors reached
    */
-  async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40) {
+  async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40, sameErrorCount = { count: 0, error: null }, MAX_SAME_ERROR_COUNT = 10) {
     logger.verbose(
-      `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}`
+      `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}, MAX_RETRIES=${MAX_RETRIES}, sameErrorCount=${sameErrorCount.error} (${sameErrorCount.count})`
     );
+    if (sameErrorCount.count >= MAX_SAME_ERROR_COUNT) {
+      logger.error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+      throw new Error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+    }
     const fromAmount = import_starknet11.uint256.uint256ToBN(swapInfo.token_from_amount);
+    const fromTokenInfo = await Global.getTokenInfoFromAddr(ContractAddr.from(swapInfo.token_from_address));
     logger.verbose(
       `Selling ${fromAmount.toString()} of token ${swapInfo.token_from_address}`
     );
@@ -16525,8 +16540,8 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         `Rebalance attempt ${retry + 1} failed, adjusting swap amount...`
       );
       const newSwapInfo = { ...swapInfo };
-      const currentAmount = Web3Number.fromWei(fromAmount.toString(), 18);
-      logger.verbose(`Current amount: ${currentAmount.toString()}`);
+      const currentAmount = Web3Number.fromWei(fromAmount.toString(), fromTokenInfo.decimals);
+      logger.verbose(`Current amount: ${currentAmount.toString()}, lowerLimit: ${lowerLimit.toString()}, upperLimit: ${upperLimit.toString()}`);
       if (err.message.includes("invalid token0 balance") || err.message.includes("invalid token0 amount")) {
         if (!isSellTokenToken0) {
           logger.verbose("Reducing swap amount - excess token0");
@@ -16573,6 +16588,30 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
           }
           newSwapInfo.token_from_amount = import_starknet11.uint256.bnToUint256(nextAmount);
         }
+      } else if (err.message.includes("Residual tokens")) {
+        logger.error("Residual tokens");
+        if (sameErrorCount.error == "Residual tokens") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Residual tokens";
+          sameErrorCount.count = 1;
+        }
+      } else if (err.message.includes("Insufficient tokens received")) {
+        logger.error("Insufficient tokens received");
+        if (sameErrorCount.error == "Insufficient tokens received") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Insufficient tokens received";
+          sameErrorCount.count = 1;
+        }
+      } else if (err.message.includes("Could not reach the end of the program")) {
+        logger.error("Could not reach the end of the program, may be the block is full (could be a temp/permanent gas issue)");
+        if (sameErrorCount.error == "Could not reach the end of the program") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Could not reach the end of the program";
+          sameErrorCount.count = 1;
+        }
       } else {
         logger.error("Unexpected error:", err);
         throw err;
@@ -16585,7 +16624,10 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         isSellTokenToken0,
         retry + 1,
         lowerLimit,
-        upperLimit
+        upperLimit,
+        MAX_RETRIES,
+        sameErrorCount,
+        MAX_SAME_ERROR_COUNT
       );
     }
   }

package/dist/index.mjs

@@ -16153,6 +16153,12 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         amount1: availableAmount1.minus(y),
         ratio: 0
       };
+    } else if (ratio.eq(Infinity)) {
+      return {
+        amount0: availableAmount0,
+        amount1: Web3Number.fromWei("0", availableAmount1.decimals),
+        ratio: Infinity
+      };
     }
     return {
       amount0: availableAmount0.plus(x),
@@ -16260,6 +16266,7 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
   // Helper to determine which token to sell, which to buy, and the amounts to use
   getSwapParams(expectedAmounts, poolKey, token0Bal, token1Bal) {
     const tokenToSell = expectedAmounts.amount0.lessThan(token0Bal) ? poolKey.token0 : poolKey.token1;
+    logger.verbose(`getSwapParams => tokenToSell: ${tokenToSell.address}, expectedAmounts: ${expectedAmounts.amount0.toString()}, bal0: ${token0Bal.toString()}`);
     const tokenToBuy = tokenToSell == poolKey.token0 ? poolKey.token1 : poolKey.token0;
     const amountToSell = tokenToSell == poolKey.token0 ? token0Bal.minus(expectedAmounts.amount0) : token1Bal.minus(expectedAmounts.amount1);
     if (amountToSell.eq(0)) {
@@ -16399,14 +16406,22 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
    * @param retry - Current retry attempt number (default 0)
    * @param adjustmentFactor - Percentage to adjust swap amount by (default 1)
    * @param isToken0Deficit - Whether token0 balance needs increasing (default true)
+   * @param MAX_RETRIES - Maximum number of retries (default 40)
+   * @param sameErrorCount - For certain errors, we just retry with same amount again. This is the count of such retries (default { count: 0, error: null })
+   * @param MAX_SAME_ERROR_COUNT - For certain errors, we just retry with same amount again. This limits such retries (default 10)
    * @returns Array of contract calls needed for rebalancing
-   * @throws Error if max retries reached without successful rebalance
+   * @throws Error if max retries reached without successful rebalance or max same errors reached
    */
-  async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40) {
+  async rebalanceIter(swapInfo, acc, estimateCall, isSellTokenToken0 = true, retry = 0, lowerLimit = 0n, upperLimit = 0n, MAX_RETRIES = 40, sameErrorCount = { count: 0, error: null }, MAX_SAME_ERROR_COUNT = 10) {
     logger.verbose(
-      `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}`
+      `Rebalancing ${this.metadata.name}: retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}, MAX_RETRIES=${MAX_RETRIES}, sameErrorCount=${sameErrorCount.error} (${sameErrorCount.count})`
     );
+    if (sameErrorCount.count >= MAX_SAME_ERROR_COUNT) {
+      logger.error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+      throw new Error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+    }
     const fromAmount = uint2564.uint256ToBN(swapInfo.token_from_amount);
+    const fromTokenInfo = await Global.getTokenInfoFromAddr(ContractAddr.from(swapInfo.token_from_address));
     logger.verbose(
       `Selling ${fromAmount.toString()} of token ${swapInfo.token_from_address}`
     );
@@ -16423,8 +16438,8 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         `Rebalance attempt ${retry + 1} failed, adjusting swap amount...`
       );
       const newSwapInfo = { ...swapInfo };
-      const currentAmount = Web3Number.fromWei(fromAmount.toString(), 18);
-      logger.verbose(`Current amount: ${currentAmount.toString()}`);
+      const currentAmount = Web3Number.fromWei(fromAmount.toString(), fromTokenInfo.decimals);
+      logger.verbose(`Current amount: ${currentAmount.toString()}, lowerLimit: ${lowerLimit.toString()}, upperLimit: ${upperLimit.toString()}`);
       if (err.message.includes("invalid token0 balance") || err.message.includes("invalid token0 amount")) {
         if (!isSellTokenToken0) {
           logger.verbose("Reducing swap amount - excess token0");
@@ -16471,6 +16486,30 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
           }
           newSwapInfo.token_from_amount = uint2564.bnToUint256(nextAmount);
         }
+      } else if (err.message.includes("Residual tokens")) {
+        logger.error("Residual tokens");
+        if (sameErrorCount.error == "Residual tokens") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Residual tokens";
+          sameErrorCount.count = 1;
+        }
+      } else if (err.message.includes("Insufficient tokens received")) {
+        logger.error("Insufficient tokens received");
+        if (sameErrorCount.error == "Insufficient tokens received") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Insufficient tokens received";
+          sameErrorCount.count = 1;
+        }
+      } else if (err.message.includes("Could not reach the end of the program")) {
+        logger.error("Could not reach the end of the program, may be the block is full (could be a temp/permanent gas issue)");
+        if (sameErrorCount.error == "Could not reach the end of the program") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Could not reach the end of the program";
+          sameErrorCount.count = 1;
+        }
       } else {
         logger.error("Unexpected error:", err);
         throw err;
@@ -16483,7 +16522,10 @@ var EkuboCLVault = class _EkuboCLVault extends BaseStrategy {
         isSellTokenToken0,
         retry + 1,
         lowerLimit,
-        upperLimit
+        upperLimit,
+        MAX_RETRIES,
+        sameErrorCount,
+        MAX_SAME_ERROR_COUNT
       );
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "1.1.60",
+  "version": "1.1.62",
   "description": "STRKFarm TS SDK (Meant for our internal use, but feel free to use it)",
   "typings": "dist/index.d.ts",
   "types": "dist/index.d.ts",

package/src/strategies/ekubo-cl-vault.tsx

@@ -37,7 +37,7 @@ import { EkuboHarvests, HarvestInfo } from "@/modules/harvests";
 import { logger } from "@/utils/logger";
 import { COMMON_CONTRACTS } from "./constants";
 import { DepegRiskLevel, ImpermanentLossLevel, MarketRiskLevel, SmartContractRiskLevel } from "@/interfaces/risks";
-import { gql } from "@apollo/client";
+import { from, gql } from "@apollo/client";
 import apolloClient from "@/modules/apollo-client";
 import { binarySearch } from "@/utils/math-utils";
 import { Quote } from "@avnu/avnu-sdk";
@@ -1032,6 +1032,12 @@ export class EkuboCLVault extends BaseStrategy<
         amount1: availableAmount1.minus(y),
         ratio: 0,
       };
+    } else if (ratio.eq(Infinity)) {
+      return {
+        amount0: availableAmount0,
+        amount1: Web3Number.fromWei("0", availableAmount1.decimals),
+        ratio: Infinity,
+      };
     }
     return {
       amount0: availableAmount0.plus(x),
@@ -1198,6 +1204,7 @@ export class EkuboCLVault extends BaseStrategy<
     const tokenToSell = expectedAmounts.amount0.lessThan(token0Bal)
       ? poolKey.token0
       : poolKey.token1;
+    logger.verbose(`getSwapParams => tokenToSell: ${tokenToSell.address}, expectedAmounts: ${expectedAmounts.amount0.toString()}, bal0: ${token0Bal.toString()}`);
     // The other token is the one to buy
     const tokenToBuy =
       tokenToSell == poolKey.token0 ? poolKey.token1 : poolKey.token0;
@@ -1402,8 +1409,11 @@ export class EkuboCLVault extends BaseStrategy<
    * @param retry - Current retry attempt number (default 0)
    * @param adjustmentFactor - Percentage to adjust swap amount by (default 1)
    * @param isToken0Deficit - Whether token0 balance needs increasing (default true)
+   * @param MAX_RETRIES - Maximum number of retries (default 40)
+   * @param sameErrorCount - For certain errors, we just retry with same amount again. This is the count of such retries (default { count: 0, error: null })
+   * @param MAX_SAME_ERROR_COUNT - For certain errors, we just retry with same amount again. This limits such retries (default 10)
    * @returns Array of contract calls needed for rebalancing
-   * @throws Error if max retries reached without successful rebalance
+   * @throws Error if max retries reached without successful rebalance or max same errors reached
    */
   async rebalanceIter(
     swapInfo: SwapInfo,
@@ -1413,15 +1423,23 @@ export class EkuboCLVault extends BaseStrategy<
     retry = 0,
     lowerLimit = 0n,
     upperLimit = 0n,
-    MAX_RETRIES = 40
+    MAX_RETRIES = 40,
+    sameErrorCount: { count: number, error: null | string } = { count: 0, error: null },
+    MAX_SAME_ERROR_COUNT = 10
   ): Promise<Call[]> {
 
     logger.verbose(
       `Rebalancing ${this.metadata.name}: ` +
-        `retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}`
+        `retry=${retry}, lowerLimit=${lowerLimit}, upperLimit=${upperLimit}, isSellTokenToken0=${isSellTokenToken0}, MAX_RETRIES=${MAX_RETRIES}, sameErrorCount=${sameErrorCount.error} (${sameErrorCount.count})`
     );
 
+    if (sameErrorCount.count >= MAX_SAME_ERROR_COUNT) {
+      logger.error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+      throw new Error(`Rebalance failed after ${MAX_SAME_ERROR_COUNT} same errors`);
+    }
+
     const fromAmount = uint256.uint256ToBN(swapInfo.token_from_amount);
+    const fromTokenInfo = await Global.getTokenInfoFromAddr(ContractAddr.from(swapInfo.token_from_address));
     logger.verbose(
       `Selling ${fromAmount.toString()} of token ${swapInfo.token_from_address}`
     );
@@ -1441,8 +1459,8 @@ export class EkuboCLVault extends BaseStrategy<
       );
 
       const newSwapInfo = { ...swapInfo };
-      const currentAmount = Web3Number.fromWei(fromAmount.toString(), 18); // 18 is ok, as its toWei eventually anyways
-      logger.verbose(`Current amount: ${currentAmount.toString()}`);
+      const currentAmount = Web3Number.fromWei(fromAmount.toString(), fromTokenInfo.decimals);
+      logger.verbose(`Current amount: ${currentAmount.toString()}, lowerLimit: ${lowerLimit.toString()}, upperLimit: ${upperLimit.toString()}`);
       if (
         err.message.includes("invalid token0 balance") ||
         err.message.includes("invalid token0 amount")
@@ -1495,11 +1513,43 @@ export class EkuboCLVault extends BaseStrategy<
           }
           newSwapInfo.token_from_amount = uint256.bnToUint256(nextAmount);
         }
+      } else if (err.message.includes("Residual tokens")) {
+        logger.error("Residual tokens");
+        if (sameErrorCount.error == "Residual tokens") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Residual tokens";
+          sameErrorCount.count = 1;
+        }
+        // dont do anything, just try again. 
+      } else if (err.message.includes("Insufficient tokens received")) {
+        logger.error("Insufficient tokens received");
+        if (sameErrorCount.error == "Insufficient tokens received") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Insufficient tokens received";
+          sameErrorCount.count = 1;
+        }
+        // dont do anything, just try again. 
+      } else if (err.message.includes("Could not reach the end of the program")) {
+        logger.error("Could not reach the end of the program, may be the block is full (could be a temp/permanent gas issue)");
+        if (sameErrorCount.error == "Could not reach the end of the program") {
+          sameErrorCount.count++;
+        } else {
+          sameErrorCount.error = "Could not reach the end of the program";
+          sameErrorCount.count = 1;
+        }
+        // just try again. 
       } else {
         logger.error("Unexpected error:", err);
         throw err;
       }
       newSwapInfo.token_to_min_amount = uint256.bnToUint256("0");
+
+      // if (uint256.uint256ToBN(newSwapInfo.token_from_amount) == fromAmount && sameErrorCount.error == 'loop-stuck') {
+      //   logger.error("Swap amount did not change, cannot proceed");
+      //   sameErrorCount = { count: MAX_SAME_ERROR_COUNT, error: null };
+      // }
       return this.rebalanceIter(
         newSwapInfo,
         acc,
@@ -1507,7 +1557,10 @@ export class EkuboCLVault extends BaseStrategy<
         isSellTokenToken0,
         retry + 1,
         lowerLimit,
-        upperLimit
+        upperLimit,
+        MAX_RETRIES,
+        sameErrorCount,
+        MAX_SAME_ERROR_COUNT
       );
     }
   }