@tokemak/queries 0.0.2 → 0.0.4

package/dist/index.cjs

@@ -645,7 +645,7 @@ var require_version = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.version = void 0;
-    exports.version = "6.14.4";
+    exports.version = "6.15.0";
   }
 });
 
@@ -5877,15 +5877,15 @@ var require_curve = __commonJS({
           const { windows, windowSize } = opts(W);
           const points = [];
           let p = elm;
-          let base3 = p;
+          let base2 = p;
           for (let window2 = 0; window2 < windows; window2++) {
-            base3 = p;
-            points.push(base3);
+            base2 = p;
+            points.push(base2);
             for (let i = 1; i < windowSize; i++) {
-              base3 = base3.add(p);
-              points.push(base3);
+              base2 = base2.add(p);
+              points.push(base2);
             }
-            p = base3.double();
+            p = base2.double();
           }
           return points;
         },
@@ -7412,13 +7412,29 @@ var require_signature = __commonJS({
        *  The ``s`` value for a signature.
        */
       get s() {
+        (0, index_js_2.assertArgument)(parseInt(__privateGet(this, _s).substring(0, 3)) < 8, "non-canonical s; use ._s", "s", __privateGet(this, _s));
         return __privateGet(this, _s);
       }
       set s(_value) {
         (0, index_js_2.assertArgument)((0, index_js_2.dataLength)(_value) === 32, "invalid s", "value", _value);
-        const value = (0, index_js_2.hexlify)(_value);
-        (0, index_js_2.assertArgument)(parseInt(value.substring(0, 3)) < 8, "non-canonical s", "value", value);
-        __privateSet(this, _s, value);
+        __privateSet(this, _s, (0, index_js_2.hexlify)(_value));
+      }
+      /**
+       *  Return the s value, unchecked for EIP-2 compliance.
+       *
+       *  This should generally not be used and is for situations where
+       *  a non-canonical S value might be relevant, such as Frontier blocks
+       *  that were mined prior to EIP-2 or invalid Authorization List
+       *  signatures.
+       */
+      get _s() {
+        return __privateGet(this, _s);
+      }
+      /**
+       *  Returns true if the Signature is valid for [[link-eip-2]] signatures.
+       */
+      isValid() {
+        return parseInt(__privateGet(this, _s).substring(0, 3)) < 8;
       }
       /**
        *  The ``v`` value for a signature.
@@ -7488,13 +7504,13 @@ var require_signature = __commonJS({
         return (0, index_js_2.concat)([this.r, this.s, this.yParity ? "0x1c" : "0x1b"]);
       }
       [Symbol.for("nodejs.util.inspect.custom")]() {
-        return `Signature { r: "${this.r}", s: "${this.s}", yParity: ${this.yParity}, networkV: ${this.networkV} }`;
+        return `Signature { r: "${this.r}", s: "${this._s}"${this.isValid() ? "" : ', valid: "false"'}, yParity: ${this.yParity}, networkV: ${this.networkV} }`;
       }
       /**
        *  Returns a new identical [[Signature]].
        */
       clone() {
-        const clone = new _Signature(_guard, this.r, this.s, this.v);
+        const clone = new _Signature(_guard, this.r, this._s, this.v);
         if (this.networkV) {
           __privateSet(clone, _networkV, this.networkV);
         }
@@ -7509,7 +7525,7 @@ var require_signature = __commonJS({
           _type: "signature",
           networkV: networkV != null ? networkV.toString() : null,
           r: this.r,
-          s: this.s,
+          s: this._s,
           v: this.v
         };
       }
@@ -7607,10 +7623,9 @@ var require_signature = __commonJS({
           }
           if (bytes.length === 65) {
             const r2 = (0, index_js_2.hexlify)(bytes.slice(0, 32));
-            const s2 = bytes.slice(32, 64);
-            assertError((s2[0] & 128) === 0, "non-canonical s");
+            const s2 = (0, index_js_2.hexlify)(bytes.slice(32, 64));
             const v2 = _Signature.getNormalizedV(bytes[64]);
-            return new _Signature(_guard, r2, (0, index_js_2.hexlify)(s2), v2);
+            return new _Signature(_guard, r2, s2, v2);
           }
           assertError(false, "invalid raw signature length");
         }
@@ -7632,7 +7647,6 @@ var require_signature = __commonJS({
           }
           assertError(false, "missing s");
         }(sig.s, sig.yParityAndS);
-        assertError(((0, index_js_2.getBytes)(s)[0] & 128) == 0, "non-canonical s");
         const { networkV, v } = function(_v2, yParityAndS, yParity) {
           if (_v2 != null) {
             const v2 = (0, index_js_2.getBigInt)(_v2);
@@ -7980,7 +7994,7 @@ var require_address = __commonJS({
       }
       return result;
     }
-    function getAddress5(address) {
+    function getAddress6(address) {
       (0, index_js_2.assertArgument)(typeof address === "string", "invalid address", "address", address);
       if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {
         if (!address.startsWith("0x")) {
@@ -8000,9 +8014,9 @@ var require_address = __commonJS({
       }
       (0, index_js_2.assertArgument)(false, "invalid address", "address", address);
     }
-    exports.getAddress = getAddress5;
+    exports.getAddress = getAddress6;
     function getIcapAddress(address) {
-      let base36 = BigInt(getAddress5(address)).toString(36).toUpperCase();
+      let base36 = BigInt(getAddress6(address)).toString(36).toUpperCase();
       while (base36.length < 30) {
         base36 = "0" + base36;
       }
@@ -12018,14 +12032,14 @@ var require_typed_data = __commonJS({
         const types = {};
         Object.keys(_types2).forEach((type) => {
           types[type] = _types2[type].map(({ name, type: type2 }) => {
-            let { base: base3, index } = splitArray(type2);
-            if (base3 === "int" && !_types2["int"]) {
-              base3 = "int256";
+            let { base: base2, index } = splitArray(type2);
+            if (base2 === "int" && !_types2["int"]) {
+              base2 = "int256";
             }
-            if (base3 === "uint" && !_types2["uint"]) {
-              base3 = "uint256";
+            if (base2 === "uint" && !_types2["uint"]) {
+              base2 = "uint256";
             }
-            return { name, type: base3 + (index || "") };
+            return { name, type: base2 + (index || "") };
           });
           links.set(type, /* @__PURE__ */ new Set());
           parents.set(type, []);
@@ -43747,6 +43761,45 @@ var require_get_proto = __commonJS({
   }
 });
 
+// ../../node_modules/async-function/index.js
+var require_async_function = __commonJS({
+  "../../node_modules/async-function/index.js"(exports, module2) {
+    "use strict";
+    var cached = (
+      /** @type {import('.').AsyncFunctionConstructor} */
+      async function() {
+      }.constructor
+    );
+    module2.exports = () => cached;
+  }
+});
+
+// ../../node_modules/generator-function/index.js
+var require_generator_function = __commonJS({
+  "../../node_modules/generator-function/index.js"(exports, module2) {
+    "use strict";
+    var cached = (
+      /** @type {GeneratorFunctionConstructor} */
+      function* () {
+      }.constructor
+    );
+    module2.exports = () => cached;
+  }
+});
+
+// ../../node_modules/async-generator-function/index.js
+var require_async_generator_function = __commonJS({
+  "../../node_modules/async-generator-function/index.js"(exports, module2) {
+    "use strict";
+    var cached = (
+      /** @type {import('.').AsyncGeneratorFunctionConstructor} */
+      async function* () {
+      }.constructor
+    );
+    module2.exports = () => cached;
+  }
+});
+
 // ../../node_modules/hasown/index.js
 var require_hasown = __commonJS({
   "../../node_modules/hasown/index.js"(exports, module2) {
@@ -43778,13 +43831,6 @@ var require_get_intrinsic = __commonJS({
     var pow = require_pow();
     var round = require_round();
     var sign = require_sign();
-    var $Function = Function;
-    var getEvalledConstructor = function(expressionSyntax) {
-      try {
-        return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
-      } catch (e) {
-      }
-    };
     var $gOPD = require_gopd();
     var $defineProperty = require_es_define_property();
     var throwTypeError = function() {
@@ -43840,7 +43886,7 @@ var require_get_intrinsic = __commonJS({
       "%Float32Array%": typeof Float32Array === "undefined" ? undefined2 : Float32Array,
       "%Float64Array%": typeof Float64Array === "undefined" ? undefined2 : Float64Array,
       "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined2 : FinalizationRegistry,
-      "%Function%": $Function,
+      "%Function%": Function,
       "%GeneratorFunction%": needsEval,
       "%Int8Array%": typeof Int8Array === "undefined" ? undefined2 : Int8Array,
       "%Int16Array%": typeof Int16Array === "undefined" ? undefined2 : Int16Array,
@@ -43903,14 +43949,17 @@ var require_get_intrinsic = __commonJS({
       }
     }
     var errorProto;
+    var getAsyncFunction = require_async_function();
+    var getGeneratorFunction = require_generator_function();
+    var getAsyncGeneratorFunction = require_async_generator_function();
     var doEval = function doEval2(name) {
       var value;
       if (name === "%AsyncFunction%") {
-        value = getEvalledConstructor("async function () {}");
+        value = getAsyncFunction() || void 0;
       } else if (name === "%GeneratorFunction%") {
-        value = getEvalledConstructor("function* () {}");
+        value = getGeneratorFunction() || void 0;
       } else if (name === "%AsyncGeneratorFunction%") {
-        value = getEvalledConstructor("async function* () {}");
+        value = getAsyncGeneratorFunction() || void 0;
       } else if (name === "%AsyncGenerator%") {
         var fn = doEval2("%AsyncGeneratorFunction%");
         if (fn) {
@@ -44963,8 +45012,8 @@ var require_follow_redirects = __commonJS({
       }
       return parsed;
     }
-    function resolveUrl(relative, base3) {
-      return useNativeURL ? new URL2(relative, base3) : parseUrl(url.resolve(base3, relative));
+    function resolveUrl(relative, base2) {
+      return useNativeURL ? new URL2(relative, base2) : parseUrl(url.resolve(base2, relative));
     }
     function validateUrl(input) {
       if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) {
@@ -52617,6 +52666,16 @@ var require_dist2 = __commonJS({
       systemName: "gen3",
       systemRegistry: "0x1a912EB51D3cF8364eBAEE5A982cA37f25aD8848"
     };
+    var arbGen3Config = {
+      chainId: 42161,
+      systemName: "gen3",
+      systemRegistry: "0xBFd8E6C9bF2CD5466f5651746f8E946A6C7b4220"
+    };
+    var plasmaGen3Config = {
+      chainId: 9745,
+      systemName: "gen3",
+      systemRegistry: "0x9065C0E33Bc8FB31A21874f399985e39bC187D48"
+    };
     function getConfigByRegistry(chainId, systemRegistry) {
       const cid = chainId.toString();
       const sysReg = systemRegistry.toLowerCase();
@@ -52626,6 +52685,10 @@ var require_dist2 = __commonJS({
         return baseGen3Config;
       } else if (cid === "146" && sysReg == sonicGen3Config.systemRegistry.toLowerCase()) {
         return sonicGen3Config;
+      } else if (cid === "42161" && sysReg == arbGen3Config.systemRegistry.toLowerCase()) {
+        return arbGen3Config;
+      } else if (cid === "9745" && sysReg == plasmaGen3Config.systemRegistry.toLowerCase()) {
+        return plasmaGen3Config;
       }
       throw new Error(`Chain ${chainId} and System Registry ${systemRegistry} not supported`);
     }
@@ -52691,7 +52754,7 @@ var require_bn = __commonJS({
         ctor.prototype = new TempCtor();
         ctor.prototype.constructor = ctor;
       }
-      function BN2(number, base3, endian) {
+      function BN2(number, base2, endian) {
         if (BN2.isBN(number)) {
           return number;
         }
@@ -52700,11 +52763,11 @@ var require_bn = __commonJS({
         this.length = 0;
         this.red = null;
         if (number !== null) {
-          if (base3 === "le" || base3 === "be") {
-            endian = base3;
-            base3 = 10;
+          if (base2 === "le" || base2 === "be") {
+            endian = base2;
+            base2 = 10;
           }
-          this._init(number || 0, base3 || 10, endian || "be");
+          this._init(number || 0, base2 || 10, endian || "be");
         }
       }
       if (typeof module3 === "object") {
@@ -52739,17 +52802,17 @@ var require_bn = __commonJS({
           return left;
         return right;
       };
-      BN2.prototype._init = function init(number, base3, endian) {
+      BN2.prototype._init = function init(number, base2, endian) {
         if (typeof number === "number") {
-          return this._initNumber(number, base3, endian);
+          return this._initNumber(number, base2, endian);
         }
         if (typeof number === "object") {
-          return this._initArray(number, base3, endian);
+          return this._initArray(number, base2, endian);
         }
-        if (base3 === "hex") {
-          base3 = 16;
+        if (base2 === "hex") {
+          base2 = 16;
         }
-        assert(base3 === (base3 | 0) && base3 >= 2 && base3 <= 36);
+        assert(base2 === (base2 | 0) && base2 >= 2 && base2 <= 36);
         number = number.toString().replace(/\s+/g, "");
         var start = 0;
         if (number[0] === "-") {
@@ -52757,17 +52820,17 @@ var require_bn = __commonJS({
           this.negative = 1;
         }
         if (start < number.length) {
-          if (base3 === 16) {
+          if (base2 === 16) {
             this._parseHex(number, start, endian);
           } else {
-            this._parseBase(number, base3, start);
+            this._parseBase(number, base2, start);
             if (endian === "le") {
-              this._initArray(this.toArray(), base3, endian);
+              this._initArray(this.toArray(), base2, endian);
             }
           }
         }
       };
-      BN2.prototype._initNumber = function _initNumber(number, base3, endian) {
+      BN2.prototype._initNumber = function _initNumber(number, base2, endian) {
         if (number < 0) {
           this.negative = 1;
           number = -number;
@@ -52792,9 +52855,9 @@ var require_bn = __commonJS({
         }
         if (endian !== "le")
           return;
-        this._initArray(this.toArray(), base3, endian);
+        this._initArray(this.toArray(), base2, endian);
       };
-      BN2.prototype._initArray = function _initArray(number, base3, endian) {
+      BN2.prototype._initArray = function _initArray(number, base2, endian) {
         assert(typeof number.length === "number");
         if (number.length <= 0) {
           this.words = [0];
@@ -52908,20 +52971,20 @@ var require_bn = __commonJS({
         }
         return r;
       }
-      BN2.prototype._parseBase = function _parseBase(number, base3, start) {
+      BN2.prototype._parseBase = function _parseBase(number, base2, start) {
         this.words = [0];
         this.length = 1;
-        for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base3) {
+        for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base2) {
           limbLen++;
         }
         limbLen--;
-        limbPow = limbPow / base3 | 0;
+        limbPow = limbPow / base2 | 0;
         var total = number.length - start;
         var mod = total % limbLen;
         var end = Math.min(total, total - mod) + start;
         var word = 0;
         for (var i = start; i < end; i += limbLen) {
-          word = parseBase(number, i, i + limbLen, base3);
+          word = parseBase(number, i, i + limbLen, base2);
           this.imuln(limbPow);
           if (this.words[0] + word < 67108864) {
             this.words[0] += word;
@@ -52931,9 +52994,9 @@ var require_bn = __commonJS({
         }
         if (mod !== 0) {
           var pow = 1;
-          word = parseBase(number, i, number.length, base3);
+          word = parseBase(number, i, number.length, base2);
           for (i = 0; i < mod; i++) {
-            pow *= base3;
+            pow *= base2;
           }
           this.imuln(pow);
           if (this.words[0] + word < 67108864) {
@@ -53103,11 +53166,11 @@ var require_bn = __commonJS({
         52521875,
         60466176
       ];
-      BN2.prototype.toString = function toString(base3, padding) {
-        base3 = base3 || 10;
+      BN2.prototype.toString = function toString(base2, padding) {
+        base2 = base2 || 10;
         padding = padding | 0 || 1;
         var out;
-        if (base3 === 16 || base3 === "hex") {
+        if (base2 === 16 || base2 === "hex") {
           out = "";
           var off = 0;
           var carry = 0;
@@ -53137,14 +53200,14 @@ var require_bn = __commonJS({
           }
           return out;
         }
-        if (base3 === (base3 | 0) && base3 >= 2 && base3 <= 36) {
-          var groupSize = groupSizes[base3];
-          var groupBase = groupBases[base3];
+        if (base2 === (base2 | 0) && base2 >= 2 && base2 <= 36) {
+          var groupSize = groupSizes[base2];
+          var groupBase = groupBases[base2];
           out = "";
           var c = this.clone();
           c.negative = 0;
           while (!c.isZero()) {
-            var r = c.modrn(groupBase).toString(base3);
+            var r = c.modrn(groupBase).toString(base2);
             c = c.idivn(groupBase);
             if (!c.isZero()) {
               out = zeros[groupSize - r.length] + r + out;
@@ -55615,7 +55678,7 @@ var require_bn = __commonJS({
 var require_src2 = __commonJS({
   "../../node_modules/@layerzerolabs/lz-v2-utilities/node_modules/base-x/src/index.js"(exports, module2) {
     "use strict";
-    function base3(ALPHABET) {
+    function base2(ALPHABET) {
       if (ALPHABET.length >= 255) {
         throw new TypeError("Alphabet too long");
       }
@@ -55743,7 +55806,7 @@ var require_src2 = __commonJS({
         decode
       };
     }
-    module2.exports = base3;
+    module2.exports = base2;
   }
 });
 
@@ -55763,6 +55826,7 @@ __export(queries_exports, {
   BASE_ASSETS: () => BASE_ASSETS,
   BATCH_SIZE: () => BATCH_SIZE,
   ETH_BASE_ASSETS: () => ETH_BASE_ASSETS,
+  EUR_BASE_ASSETS: () => EUR_BASE_ASSETS,
   MessageStatus: () => MessageStatus,
   PRICED_TOKENS: () => PRICED_TOKENS,
   USD_BASE_ASSETS: () => USD_BASE_ASSETS,
@@ -55817,6 +55881,7 @@ __export(queries_exports, {
   getPoolsAndDestinations: () => getPoolsAndDestinations,
   getProtocolStats: () => getProtocolStats,
   getRebalanceStats: () => getRebalanceStats,
+  getRebalanceValueUsd: () => getRebalanceValueUsd,
   getRewardsPayloadV1: () => getRewardsPayloadV1,
   getSToke: () => getSToke,
   getSTokeChainsForEnv: () => getSTokeChainsForEnv,
@@ -56201,18 +56266,20 @@ function getSTokeChainsForEnv({
 
 // utils/getAutopoolCategory.ts
 var ETH_BASE_ASSETS = ["ETH", "WETH"];
-var USD_BASE_ASSETS = ["USDC", "DOLA"];
+var USD_BASE_ASSETS = ["USDC", "DOLA", "USDT0"];
+var EUR_BASE_ASSETS = ["EURC"];
 var AutopoolCategory = /* @__PURE__ */ ((AutopoolCategory2) => {
   AutopoolCategory2["ETH"] = "eth";
-  AutopoolCategory2["USD"] = "usd";
   AutopoolCategory2["CRYPTO"] = "crypto";
+  AutopoolCategory2["STABLES"] = "stables";
+  AutopoolCategory2["USD"] = "usd";
   return AutopoolCategory2;
 })(AutopoolCategory || {});
 var getAutopoolCategory = (baseAsset) => {
-  if (ETH_BASE_ASSETS.includes(baseAsset.toUpperCase())) {
+  if (ETH_BASE_ASSETS.includes(baseAsset?.toUpperCase())) {
     return "eth" /* ETH */;
-  } else if (USD_BASE_ASSETS.includes(baseAsset.toUpperCase())) {
-    return "usd" /* USD */;
+  } else if (USD_BASE_ASSETS.includes(baseAsset?.toUpperCase()) || EUR_BASE_ASSETS.includes(baseAsset?.toUpperCase())) {
+    return "stables" /* STABLES */;
   }
   return "crypto" /* CRYPTO */;
 };
@@ -56319,8 +56386,43 @@ async function paginateQuery(queryFn, arrayKey, options = {}) {
   return results;
 }
 
+// functions/getPoolsAndDestinationsBackup.ts
+var import_utils2 = require("@tokemak/utils");
+
+// functions/getBlobData.ts
+var getBlobData = async (blobName) => {
+  try {
+    const blobUrl = `https://kg4e5p7eknl8rdgg.public.blob.vercel-storage.com/${blobName}`;
+    const response = await fetch(blobUrl, { cache: "no-store" });
+    if (!response.ok) {
+      console.warn(
+        `Failed to fetch blob data for ${blobName}: ${response.status} ${response.statusText}`
+      );
+      return null;
+    }
+    const data = await response.text();
+    return JSON.parse(data);
+  } catch (error) {
+    console.warn(`Failed to fetch blob data for ${blobName}:`, error);
+    return null;
+  }
+};
+
+// functions/getPoolsAndDestinationsBackup.ts
+var getPoolsAndDestinationsBackup = async (chainId) => {
+  try {
+    const networkName = (0, import_utils2.getNetwork)(chainId)?.name.toLowerCase();
+    const backupData = await getBlobData(
+      `${networkName}-getPoolsAndDestinations-latest-success.json`
+    );
+    return backupData?.data;
+  } catch (e) {
+    console.error(e);
+  }
+};
+
 // functions/getChainAutopools.ts
-var import_utils4 = require("@tokemak/utils");
+var import_utils6 = require("@tokemak/utils");
 var import_viem2 = require("viem");
 
 // constants/tokenOrders.ts
@@ -56418,10 +56520,31 @@ var getPoolsAndDestinations = async (wagmiConfig, { chainId }) => {
     );
     return autopoolsAndDestinations;
   } catch (error) {
-    console.error(`Error on ${chainId} in getPoolsAndDestionations:`, error);
+    console.error(`Error on ${chainId} in getPoolsAndDestinations:`, error);
   }
 };
 
+// functions/getBackupApr.ts
+var import_utils4 = require("@tokemak/utils");
+var getBackupApr = async (chainId, poolAddress) => {
+  try {
+    const networkName = (0, import_utils4.getNetwork)(chainId)?.name.toLowerCase();
+    const backupData = await getBlobData(
+      `${networkName}-getChainAutopools-latest-success.json`
+    );
+    if (backupData) {
+      const backupApr = backupData.data.find(
+        (item) => item.poolAddress.toLowerCase() === poolAddress.toLowerCase()
+      )?.apr.base;
+      return backupApr || 0;
+    }
+  } catch (e) {
+    console.error(e);
+    return 0;
+  }
+  return null;
+};
+
 // functions/getChainAutopools.ts
 var getChainAutopools = async (wagmiConfig, {
   chainId,
@@ -56435,14 +56558,16 @@ var getChainAutopools = async (wagmiConfig, {
     const genStratAprs = await getGenStratAprs({
       chainId
     });
-    const autopoolsAndDestinations = await getPoolsAndDestinations(
-      wagmiConfig,
-      {
-        chainId
-      }
-    );
+    let autopoolsAndDestinations = await getPoolsAndDestinations(wagmiConfig, {
+      chainId
+    });
     if (!autopoolsAndDestinations) {
-      throw new Error(`No autopools and destinations found for ${chainId}`);
+      const backupData = await getPoolsAndDestinationsBackup(chainId);
+      if (backupData) {
+        autopoolsAndDestinations = backupData;
+      } else {
+        throw new Error(`No autopools and destinations found for ${chainId}`);
+      }
     }
     const vaultAddedMapping = vaultAddeds.reduce((acc, vaultAdded) => {
       acc[vaultAdded.vault.toLowerCase()] = Number(vaultAdded.blockTimestamp);
@@ -56450,8 +56575,14 @@ var getChainAutopools = async (wagmiConfig, {
     }, {});
     const autopools = await Promise.all(
       autopoolsAndDestinations.map(async (autopool) => {
-        const baseAsset = (0, import_utils4.getToken)(autopool.baseAsset);
-        let baseAssetPrice = prices[baseAsset.symbol.toUpperCase()];
+        let baseAsset = (0, import_utils6.getToken)(autopool.baseAsset);
+        if (!baseAsset?.symbol) {
+          console.error(
+            "FIX THIS BEFORE PROD: base asset not found",
+            autopool.baseAsset
+          );
+        }
+        let baseAssetPrice = prices[(baseAsset?.symbol || "").toUpperCase()];
         if (!baseAssetPrice) {
           baseAssetPrice = await getTokenPrice({
             chainId: baseAsset.chainId,
@@ -56459,18 +56590,18 @@ var getChainAutopools = async (wagmiConfig, {
           }) || 0;
         }
         const timestamp = vaultAddedMapping[autopool.poolAddress.toLowerCase()];
-        const totalAssets = (0, import_utils4.formatUnitsNum)(
+        const totalAssets = (0, import_utils6.formatUnitsNum)(
           autopool.totalAssets,
           baseAsset.decimals
         );
         const tvl = totalAssets * baseAssetPrice;
-        const totalIdleAssets = (0, import_utils4.formatUnitsNum)(
+        const totalIdleAssets = (0, import_utils6.formatUnitsNum)(
           autopool.totalIdle,
           baseAsset.decimals
         );
         const exchangeValues = {};
         const destinations = autopool.destinations.map((destination) => {
-          const debtValueHeldByVaultEth = (0, import_utils4.formatUnitsNum)(
+          const debtValueHeldByVaultEth = (0, import_utils6.formatUnitsNum)(
             destination.debtValueHeldByVault,
             baseAsset.decimals
           );
@@ -56483,8 +56614,8 @@ var getChainAutopools = async (wagmiConfig, {
             destination.underlyingTokenValueHeld
           );
           let underlyingTokens = tokensWithValue.map((token) => {
-            const tokenDetails = (0, import_utils4.getToken)(token.tokenAddress);
-            let value = (0, import_utils4.formatUnitsNum)(
+            const tokenDetails = (0, import_utils6.getToken)(token.tokenAddress);
+            let value = (0, import_utils6.formatUnitsNum)(
               token.valueHeldInEth,
               baseAsset.decimals
             );
@@ -56500,7 +56631,7 @@ var getChainAutopools = async (wagmiConfig, {
             if (underlyingTokenAddress) {
               underlyingTokens = [
                 {
-                  ...(0, import_utils4.getToken)(underlyingTokenAddress, chainId),
+                  ...(0, import_utils6.getToken)(underlyingTokenAddress, chainId),
                   valueUsd: debtValueHeldByVaultEth * baseAssetPrice,
                   value: debtValueHeldByVaultEth
                 }
@@ -56512,16 +56643,16 @@ var getChainAutopools = async (wagmiConfig, {
             ...destination,
             debtValueHeldByVaultUsd: debtValueHeldByVaultEth * baseAssetPrice,
             debtValueHeldByVaultEth,
-            compositeReturn: isGenStrat ? genStratAprs?.[autopool.poolAddress]?.[destination.vaultAddress]?.apr || 0 : (0, import_utils4.formatUnitsNum)(destination.compositeReturn, 4),
+            compositeReturn: isGenStrat ? genStratAprs?.[autopool.poolAddress]?.[destination.vaultAddress]?.apr || 0 : (0, import_utils6.formatEtherNum)(destination.compositeReturn),
             debtValueHeldByVaultAllocation: debtValueHeldByVaultEth / totalAssets,
             underlyingTokens,
-            poolName: (0, import_utils4.formatPoolName)(destination.lpTokenName),
-            exchange: (0, import_utils4.getProtocol)(destination.exchangeName)
+            poolName: (0, import_utils6.formatPoolName)(destination.lpTokenName),
+            exchange: (0, import_utils6.getProtocol)(destination.exchangeName)
           };
         });
         const uniqueExchanges = Array.from(
           new Set(
-            destinations.map((d) => (0, import_utils4.getProtocol)(d.exchangeName)).filter(Boolean)
+            destinations.map((d) => (0, import_utils6.getProtocol)(d.exchangeName)).filter(Boolean)
           )
         );
         const uniqueExchangesWithValueHeld = uniqueExchanges.map((exchange) => {
@@ -56580,12 +56711,15 @@ var getChainAutopools = async (wagmiConfig, {
           }
         );
         let UIBaseAsset = baseAsset;
-        if (baseAsset.symbol.toLowerCase() === import_tokenlist3.WETH_TOKEN.symbol.toLowerCase()) {
+        if (baseAsset.symbol?.toLowerCase() === import_tokenlist3.WETH_TOKEN.symbol.toLowerCase()) {
           UIBaseAsset = import_tokenlist3.ETH_TOKEN;
         }
-        if (baseAsset.symbol.toLowerCase() === import_tokenlist3.WS_TOKEN.symbol.toLowerCase()) {
+        if (baseAsset.symbol?.toLowerCase() === import_tokenlist3.WS_TOKEN.symbol.toLowerCase()) {
           UIBaseAsset = import_tokenlist3.S_TOKEN;
         }
+        if (baseAsset.symbol?.toLowerCase() === import_tokenlist3.WXPL_TOKEN.symbol.toLowerCase()) {
+          UIBaseAsset = import_tokenlist3.XPL_TOKEN;
+        }
         const isNew = (Date.now() / 1e3 - timestamp) / 60 / 60 / 24 < 45;
         const aprs = autopoolsApr.find(
           (autopoolApr) => (0, import_viem2.getAddress)(autopoolApr.id) === (0, import_viem2.getAddress)(autopool.poolAddress)
@@ -56593,10 +56727,10 @@ var getChainAutopools = async (wagmiConfig, {
         let baseApr = aprs?.currentApy;
         let boostedApr = 0;
         let extraApr = 0;
-        const formattedRewarder7DayMAApy = (0, import_utils4.formatEtherNum)(
+        const formattedRewarder7DayMAApy = (0, import_utils6.formatEtherNum)(
           BigInt(Number(aprs?.rewarder?.day7MAApy) || 0)
         );
-        const formattedRewarder30DayMAApy = (0, import_utils4.formatEtherNum)(
+        const formattedRewarder30DayMAApy = (0, import_utils6.formatEtherNum)(
           BigInt(Number(aprs?.rewarder?.day30MAApy) || 0)
         );
         if (formattedRewarder7DayMAApy > 0) {
@@ -56618,16 +56752,34 @@ var getChainAutopools = async (wagmiConfig, {
         if (!baseApr) {
           baseApr = 0;
         }
+        if (baseApr === 0) {
+          try {
+            const backupApr = await getBackupApr(chainId, autopool.poolAddress);
+            if (backupApr) {
+              baseApr = backupApr;
+              console.log("using backup apr", backupApr);
+            }
+          } catch (e) {
+            console.error(e);
+            console.log("unable to retrieve backup apr");
+          }
+        }
+        if (baseApr === 0 && autopool.symbol.toLowerCase() === "baseusd") {
+          baseApr = 0.0914;
+        }
         let extraRewards = [];
         if (aprs?.rewarder?.extraRewarders?.length && aprs?.rewarder?.extraRewarders?.length > 0) {
           extraRewards = aprs?.rewarder?.extraRewarders.map((reward) => {
-            const token = (0, import_utils4.getToken)(reward?.rewardToken?.id, chainId);
+            const token = (0, import_utils6.getToken)(reward?.rewardToken?.id, chainId);
             return {
               ...token,
-              apr: (0, import_utils4.formatEtherNum)(BigInt(reward.currentApy || 0))
+              apr: (0, import_utils6.formatEtherNum)(BigInt(reward.currentApy || 0))
             };
           });
         }
+        if (autopool?.symbol?.toLowerCase() === "plasmausd") {
+          boostedApr = 0;
+        }
         extraApr = extraRewards.reduce((acc, reward) => acc + reward.apr, 0);
         const combinedApr = baseApr + boostedApr + extraApr;
         let denominatedToken = import_tokenlist3.ETH_TOKEN;
@@ -56636,13 +56788,13 @@ var getChainAutopools = async (wagmiConfig, {
         if (denominatedIn?.symbol?.toLowerCase() === "weth") {
           denominatedToken = import_tokenlist3.ETH_TOKEN;
         } else {
-          denominatedToken = (0, import_utils4.getToken)(denominatedIn?.id);
+          denominatedToken = (0, import_utils6.getToken)(denominatedIn?.id);
           if (denominatedToken) {
             useDenominatedValues = true;
           }
         }
         let denominatedTokenPrice = 0;
-        const tokenSymbol = denominatedToken.symbol.toUpperCase();
+        const tokenSymbol = denominatedToken.symbol?.toUpperCase();
         if (tokenSymbol in prices) {
           denominatedTokenPrice = prices[tokenSymbol];
         } else {
@@ -56651,12 +56803,12 @@ var getChainAutopools = async (wagmiConfig, {
             tokenAddress: denominatedToken.address
           }) || 0;
         }
-        const navPerShareBaseAsset = (0, import_utils4.formatUnitsNum)(
+        const navPerShareBaseAsset = (0, import_utils6.formatUnitsNum)(
           autopool.navPerShare,
           baseAsset.decimals
         );
         const assets = convertBaseAssetToTokenPricesAndDenom(
-          (0, import_utils4.formatUnitsNum)(autopool.totalAssets, baseAsset.decimals),
+          (0, import_utils6.formatUnitsNum)(autopool.totalAssets, baseAsset.decimals),
           baseAssetPrice,
           denominatedTokenPrice,
           prices
@@ -56763,7 +56915,7 @@ var getChainAutopools = async (wagmiConfig, {
         });
         const autopoolInfo = getAutopoolInfo(autopool.symbol);
         if (autopoolInfo && !autopoolInfo.description) {
-          autopoolInfo.description = `Autopool featuring ${UIBaseAsset.symbol} deployed across integrated DEXs and lending protocols on ${(0, import_utils4.getNetwork)(chainId)?.name}.`;
+          autopoolInfo.description = `Autopool featuring ${UIBaseAsset.symbol} deployed across integrated DEXs and lending protocols on ${(0, import_utils6.getNetwork)(chainId)?.name}.`;
         }
         return {
           ...autopool,
@@ -56788,7 +56940,7 @@ var getChainAutopools = async (wagmiConfig, {
           UITokens,
           UIExchanges: finalUIExchanges,
           tokens: uniqueTokens,
-          chain: (0, import_utils4.getNetwork)(chainId),
+          chain: (0, import_utils6.getNetwork)(chainId),
           apr: {
             base: baseApr,
             boosted: boostedApr,
@@ -56852,36 +57004,40 @@ var getAutopools = async (wagmiConfig, {
 };
 
 // functions/getAutopoolRebalances.ts
-var import_clients = require("@tokemak/graph-cli/dist/clients");
-var getAutopoolRebalances = async (id, chainId = 1) => {
-  const { GetAutopoolRebalances } = (0, import_clients.getSdkByChainId)(chainId);
-  const { autopoolRebalances } = await GetAutopoolRebalances({
-    address: id
+var import_graph_cli2 = require("@tokemak/graph-cli");
+var getAutopoolRebalances = async (id, chainId = 1, options) => {
+  const { GetAutopoolRebalances } = (0, import_graph_cli2.getSdkByChainId)(chainId);
+  const first = options?.first ?? 1e3;
+  const maxPages = options?.maxPages ?? 100;
+  const queryFn = ({ first: first2, skip }) => GetAutopoolRebalances({ address: id, first: first2, skip });
+  const all = await paginateQuery(queryFn, "autopoolRebalances", {
+    first,
+    maxPages,
+    onPage: options?.onPage
   });
-  const length = autopoolRebalances.length;
-  return autopoolRebalances.map((rebalance, index) => ({
+  const length = all.length;
+  return all.map((rebalance, index) => ({
     ...rebalance,
     ix: length - index
   }));
 };
 
 // functions/getAutopoolsRebalances.ts
-var import_graph_cli2 = require("@tokemak/graph-cli");
+var import_graph_cli3 = require("@tokemak/graph-cli");
 var getAutopoolsRebalances = async (chainId = 1) => {
-  const { GetAutopoolsRebalances } = (0, import_graph_cli2.getSdkByChainId)(chainId);
+  const { GetAutopoolsRebalances } = (0, import_graph_cli3.getSdkByChainId)(chainId);
   const { autopools } = await GetAutopoolsRebalances();
   const rebalances = autopools.map(({ rebalances: rebalances2 }) => rebalances2);
   return rebalances.flat().sort((a, b) => b.timestamp - a.timestamp);
 };
 
 // functions/getAutopoolsHistory.ts
-var import_chains3 = require("viem/chains");
 var import_viem4 = require("viem");
 
 // functions/getAutopoolsDayData.ts
-var import_graph_cli3 = require("@tokemak/graph-cli");
+var import_graph_cli4 = require("@tokemak/graph-cli");
 var getAutopoolsDayData = async (chainId, timestamp) => {
-  const { GetAutopoolsDayData } = (0, import_graph_cli3.getSdkByChainId)(chainId);
+  const { GetAutopoolsDayData } = (0, import_graph_cli4.getSdkByChainId)(chainId);
   const PAGE_SIZE = 1e3;
   let allResults = [];
   let hasMore = true;
@@ -56892,7 +57048,16 @@ var getAutopoolsDayData = async (chainId, timestamp) => {
       first: PAGE_SIZE,
       skip
     });
-    allResults = [...allResults, ...autopoolDayDatas];
+    const autopoolDayDatasWithVaultId = autopoolDayDatas.map(
+      (autopoolDayData) => {
+        const parsedVaultId = autopoolDayData.id.split("-")[0];
+        return {
+          ...autopoolDayData,
+          vault: { id: parsedVaultId }
+        };
+      }
+    );
+    allResults = [...allResults, ...autopoolDayDatasWithVaultId];
     if (autopoolDayDatas.length < PAGE_SIZE) {
       hasMore = false;
     } else {
@@ -56909,23 +57074,13 @@ var getAutopoolsHistory = async (autopools, days, includeTestnet = false) => {
       throw new Error("No autopools found");
     }
     const timestampXDaysAgo = Math.floor(Date.now() / 1e3) - 60 * 60 * 24 * days;
-    const ethAutopoolDayDatas = await getAutopoolsDayData(
-      import_chains3.mainnet.id,
-      timestampXDaysAgo
-    );
-    const baseAutopoolDayDatas = await getAutopoolsDayData(
-      import_chains3.base.id,
-      timestampXDaysAgo
-    );
-    const sonicAutopoolDayDatas = await getAutopoolsDayData(
-      import_chains3.sonic.id,
-      timestampXDaysAgo
+    const chains = getChainsForEnv({ includeTestnet });
+    const autopoolDayDatas = await Promise.all(
+      chains.map(
+        (chain) => getAutopoolsDayData(chain.chainId, timestampXDaysAgo)
+      )
     );
-    let groupedDayDatas = [
-      ...ethAutopoolDayDatas,
-      ...baseAutopoolDayDatas,
-      ...sonicAutopoolDayDatas
-    ];
+    let groupedDayDatas = [...autopoolDayDatas.flat()];
     const groupedByVault = groupedDayDatas.reduce((acc, data) => {
       const vaultId = data.vault.id.toLowerCase();
       if (!acc[vaultId]) {
@@ -56997,7 +57152,7 @@ var import_abis2 = require("@tokemak/abis");
 var import_config4 = require("@tokemak/config");
 var import_core2 = require("@wagmi/core");
 var import_viem5 = require("viem");
-var import_chains4 = require("viem/chains");
+var import_chains3 = require("viem/chains");
 var getSushiLP = async (wagmiConfig, { ethPrice }) => {
   const { sushiPool, lpRewardsV1Url } = (0, import_config4.getMainnetConfig)();
   const sushiPoolContract = {
@@ -57012,12 +57167,12 @@ var getSushiLP = async (wagmiConfig, { ethPrice }) => {
           {
             ...sushiPoolContract,
             functionName: "getReserves",
-            chainId: import_chains4.mainnet.id
+            chainId: import_chains3.mainnet.id
           },
           {
             ...sushiPoolContract,
             functionName: "totalSupply",
-            chainId: import_chains4.mainnet.id
+            chainId: import_chains3.mainnet.id
           }
         ]
       }
@@ -57047,9 +57202,9 @@ var getSushiLP = async (wagmiConfig, { ethPrice }) => {
 };
 
 // functions/getChainUserActivity.ts
-var import_graph_cli4 = require("@tokemak/graph-cli");
+var import_graph_cli5 = require("@tokemak/graph-cli");
 var getChainUserActivity = async (address, chainId = 1) => {
-  const { GetUserBalanceChangeHistory } = (0, import_graph_cli4.getSdkByChainId)(chainId);
+  const { GetUserBalanceChangeHistory } = (0, import_graph_cli5.getSdkByChainId)(chainId);
   try {
     const { userAutopoolBalanceChanges } = await GetUserBalanceChangeHistory({
       userAddress: address
@@ -57120,7 +57275,7 @@ var getRewardsPayloadV1 = async (cycleHash, account, rewardsV1Url) => {
 // functions/getUserAutoEthRewards.ts
 var import_abis3 = require("@tokemak/abis");
 var import_core3 = require("@wagmi/core");
-var import_utils7 = require("@tokemak/utils");
+var import_utils10 = require("@tokemak/utils");
 var getAutoEthRewards = async (wagmiConfig, {
   account,
   currentCycleIndex,
@@ -57158,7 +57313,7 @@ var getAutoEthRewards = async (wagmiConfig, {
     const currentAmount = Number(drippingHashPayload?.summary?.currentAmount);
     const previousAmount = Number(drippingHashPayload?.summary?.previousAmount);
     const cycleDuration = 604800;
-    const lastCycleStart = (0, import_utils7.convertChainCycleToUnix)(Number(currentCycleIndex));
+    const lastCycleStart = (0, import_utils10.convertChainCycleToUnix)(Number(currentCycleIndex));
     const timeSinceCycleStart = Date.now() / 1e3 - lastCycleStart;
     const currentUserRewards = currentAmount * Math.min(timeSinceCycleStart, cycleDuration) / cycleDuration + previousAmount;
     const lastWeekRewards = Number(lastWeekHashPayload?.summary?.currentAmount);
@@ -57179,7 +57334,7 @@ var getUserAutoEthRewards = async (wagmiConfig, rewardsV1Url, rewardsHash, addre
     rewardsHash,
     chainId
   });
-  const currentUserRewardsUsd = (0, import_utils7.formatCurrency)(
+  const currentUserRewardsUsd = (0, import_utils10.formatCurrency)(
     ethPrice * (autoETHRewards?.currentUserRewards || 0)
   );
   return { ...autoETHRewards, currentUserRewardsUsd };
@@ -57240,7 +57395,7 @@ var getUserRewardsV1 = async (wagmiConfig, {
 var import_abis5 = require("@tokemak/abis");
 var import_core5 = require("@wagmi/core");
 var import_config5 = require("@tokemak/config");
-var import_chains5 = require("viem/chains");
+var import_chains4 = require("viem/chains");
 var getUserV1 = async (wagmiConfig, {
   currentCycleIndex,
   address,
@@ -57255,14 +57410,14 @@ var getUserV1 = async (wagmiConfig, {
     autoEthGuardedRewards,
     rewardsV1,
     missedTokeRewards
-  } = (0, import_config5.getMainnetConfig)(import_chains5.mainnet.id);
+  } = (0, import_config5.getMainnetConfig)(import_chains4.mainnet.id);
   try {
     const userStakedTokeV1 = await (0, import_core5.readContract)(wagmiConfig, {
       address: stakingV1,
       abi: import_abis5.stakingV1Abi,
       functionName: "availableForWithdrawal",
       args: [address, 0n],
-      chainId: import_chains5.mainnet.id
+      chainId: import_chains4.mainnet.id
     });
     const tokeRewards = await getUserRewardsV1(wagmiConfig, {
       address,
@@ -57344,12 +57499,12 @@ var getUserV1 = async (wagmiConfig, {
 };
 
 // functions/getChainUserAutopoolsHistory.tsx
-var import_graph_cli5 = require("@tokemak/graph-cli");
+var import_graph_cli6 = require("@tokemak/graph-cli");
 var getChainUserAutopoolsHistory = async ({
   address,
   chainId = 1
 }) => {
-  const { GetUserVaultsDayData } = (0, import_graph_cli5.getSdkByChainId)(chainId);
+  const { GetUserVaultsDayData } = (0, import_graph_cli6.getSdkByChainId)(chainId);
   const oneYearAgoTimestamp = Math.floor(Date.now() / 1e3) - 365 * 24 * 60 * 60;
   try {
     if (address) {
@@ -57367,21 +57522,21 @@ var getChainUserAutopoolsHistory = async ({
 };
 
 // functions/getUserAutopoolsHistory.ts
-var import_utils11 = require("@tokemak/utils");
+var import_utils14 = require("@tokemak/utils");
 
 // functions/getTokenValueDayDatas.ts
-var import_chains6 = require("viem/chains");
-var import_utils8 = require("@tokemak/utils");
+var import_chains5 = require("viem/chains");
+var import_utils11 = require("@tokemak/utils");
 var import_viem6 = require("viem");
-var import_graph_cli6 = require("@tokemak/graph-cli");
-var getTokenValueDayDatas = async (tokenAddress, chainId = import_chains6.mainnet.id) => {
-  const { GetTokenValueDayDatas } = (0, import_graph_cli6.getSdkByChainId)(chainId);
+var import_graph_cli7 = require("@tokemak/graph-cli");
+var getTokenValueDayDatas = async (tokenAddress, chainId = import_chains5.mainnet.id) => {
+  const { GetTokenValueDayDatas } = (0, import_graph_cli7.getSdkByChainId)(chainId);
   try {
     const { tokenValueDayDatas } = await GetTokenValueDayDatas({
       tokenAddress: tokenAddress.toLowerCase()
     });
     const historicalPrice = tokenValueDayDatas.map((tokenValueDayData) => {
-      const date = (0, import_utils8.convertTimestampToDate)(
+      const date = (0, import_utils11.convertTimestampToDate)(
         tokenValueDayData.lastSnapshotTimestamp
       );
       const usdPrice = (0, import_viem6.formatUnits)(tokenValueDayData.priceInUsd, 8);
@@ -57400,28 +57555,55 @@ var getTokenValueDayDatas = async (tokenAddress, chainId = import_chains6.mainne
 // functions/getTokenPrices.ts
 var import_tokenlist4 = require("@tokemak/tokenlist");
 var import_constants6 = require("@tokemak/constants");
+
+// functions/getBackupTokenPrices.ts
+var getBackupTokenPrices = async () => {
+  try {
+    const backupData = await getBlobData(`getTokenPrices-latest-success.json`);
+    if (backupData) {
+      return backupData;
+    }
+  } catch (e) {
+    console.error(e);
+    return void 0;
+  }
+  return void 0;
+};
+
+// functions/getTokenPrices.ts
 var BASE_ASSETS = [
-  { ...import_tokenlist4.ETH_TOKEN, symbol: "ETH" },
-  { ...import_tokenlist4.PXETH_TOKEN, symbol: "PXETH" },
-  { ...import_tokenlist4.USDC_TOKEN, symbol: "USDC" },
-  { ...import_tokenlist4.DOLA_TOKEN, symbol: "DOLA" },
-  { ...import_tokenlist4.S_TOKEN, symbol: "S" }
+  { ...import_tokenlist4.ETH_TOKEN, symbol: "ETH", coinGeckoId: "ethereum" },
+  { ...import_tokenlist4.PXETH_TOKEN, symbol: "PXETH", coinGeckoId: "dinero-staked-eth" },
+  { ...import_tokenlist4.USDC_TOKEN, symbol: "USDC", coinGeckoId: "usd-coin" },
+  { ...import_tokenlist4.DOLA_TOKEN, symbol: "DOLA", coinGeckoId: "dola-usd" },
+  { ...import_tokenlist4.S_TOKEN, symbol: "S" },
+  { ...import_tokenlist4.EURC_TOKEN, symbol: "EURC", coinGeckoId: "euro-coin" },
+  { ...import_tokenlist4.USDT_TOKEN, symbol: "USDT", coinGeckoId: "tether" },
+  { ...import_tokenlist4.USDT0_TOKEN, symbol: "USDT0", coinGeckoId: "tether" }
 ];
 var PRICED_TOKENS = [
   ...BASE_ASSETS,
-  { ...import_tokenlist4.TOKE_TOKEN, symbol: "TOKE" }
+  { ...import_tokenlist4.TOKE_TOKEN, symbol: "TOKE" },
+  { ...import_tokenlist4.SILO_TOKEN, symbol: "SILO" },
+  { ...import_tokenlist4.XPL_TOKEN, address: import_tokenlist4.WXPL_TOKEN.address, symbol: "XPL" },
+  { ...import_tokenlist4.USDT0_TOKEN, symbol: "USDT0" }
 ];
 var WRAPPED_TOKENS = [
   { ...import_tokenlist4.WETH_TOKEN, symbol: "WETH" },
-  { ...import_tokenlist4.WS_TOKEN, symbol: "WS" }
+  { ...import_tokenlist4.WS_TOKEN, symbol: "WS" },
+  { ...import_tokenlist4.WXPL_TOKEN, symbol: "WXPL" }
 ];
-var getTokenPrices = async () => {
+var isStale = (timestamp) => {
+  return timestamp - Math.floor(Date.now() / 1e3) > 5 * 60;
+};
+var getTokenPrices = async (isCronJob = false) => {
   try {
     const body = {
-      tokens: PRICED_TOKENS.map((asset, index) => ({
+      tokens: PRICED_TOKENS.map((asset) => ({
         token: asset.address,
         chainId: asset.chainId,
-        systemName: "gen3"
+        systemName: "gen3",
+        timeoutMS: 5 * 1e3
       }))
     };
     const response = await fetch(`${import_constants6.TOKEMAK_PRICES_STAGING_URL}`, {
@@ -57436,43 +57618,73 @@ var getTokenPrices = async () => {
       const priceData = data.find(
         (item) => item.token.toLowerCase() === asset.address.toLowerCase() && item.chainId === asset.chainId
       );
-      acc[asset.symbol] = priceData?.price || 0;
+      acc[asset.symbol] = priceData?.price ?? 0;
       return acc;
     }, {});
-    return { ...prices, WETH: prices.ETH, WS: prices.S };
+    const timestamp = Math.floor(Date.now() / 1e3);
+    return {
+      timestamp,
+      isStale: false,
+      prices: {
+        ...prices,
+        WETH: prices.ETH,
+        WS: prices.S,
+        WXPL: prices.XPL
+      }
+    };
   } catch (e) {
-    console.log("pricing failed, falling back to getTokenPrice");
-    console.error(e);
-    const pricesResponse = await Promise.all(
-      PRICED_TOKENS.map(
-        (asset) => getTokenPrice({ tokenAddress: asset.address, chainId: asset.chainId })
-      )
-    );
-    const prices = pricesResponse.reduce((acc, price, index) => {
-      acc[PRICED_TOKENS[index].symbol] = price || 0;
-      return acc;
-    }, {});
-    return { ...prices, WETH: prices.ETH, WS: prices.S };
+    if (isCronJob) {
+      return {
+        prices: void 0,
+        timestamp: void 0,
+        isStale: false
+      };
+    } else {
+      const backupPrices = await getBackupTokenPrices();
+      if (backupPrices) {
+        return {
+          prices: backupPrices.prices,
+          timestamp: backupPrices.timestamp,
+          isStale: isStale(backupPrices.timestamp)
+        };
+      }
+      return {
+        prices: void 0,
+        timestamp: void 0,
+        isStale: false
+      };
+    }
   }
 };
 
 // functions/getHistoricalTokenPrices.ts
 var import_tokenlist5 = require("@tokemak/tokenlist");
+var hasCoinGeckoId = (asset) => typeof asset?.coinGeckoId === "string" && asset.coinGeckoId.length > 0;
+var getBlobHistoricalTokenPrices = async (tokenSymbol) => {
+  const blobName = `historical_v2/${tokenSymbol}-latest-success.json`;
+  const res = await getBlobData(blobName);
+  if (!res?.data || !Array.isArray(res.data))
+    return [];
+  return res.data.map(({ timestamp, date, price }) => ({
+    timestamp,
+    date,
+    price
+  }));
+};
 var getHistoricalTokenPrices = async () => {
   const ETH_ADDRESS_IN_SUBGRAPH = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
   const historicalBaseAssetPrices = await Promise.all(
     BASE_ASSETS.map(async (baseAsset) => {
-      let address = baseAsset.address;
-      if (baseAsset.address === import_tokenlist5.ETH_TOKEN.address) {
-        address = ETH_ADDRESS_IN_SUBGRAPH;
-      }
-      return {
-        ...baseAsset,
-        prices: await getTokenValueDayDatas(
+      if (!hasCoinGeckoId(baseAsset)) {
+        const address = baseAsset.address === import_tokenlist5.ETH_TOKEN.address ? ETH_ADDRESS_IN_SUBGRAPH : baseAsset.address;
+        const prices2 = await getTokenValueDayDatas(
           address,
           baseAsset.chainId
-        )
-      };
+        );
+        return { ...baseAsset, prices: prices2 ?? [] };
+      }
+      const prices = await getBlobHistoricalTokenPrices(baseAsset.symbol);
+      return { ...baseAsset, prices };
     })
   );
   const allTimestamps = /* @__PURE__ */ new Set();
@@ -57491,51 +57703,32 @@ var getHistoricalTokenPrices = async () => {
         ...BASE_ASSETS.map((asset) => asset.symbol),
         "USD"
       ];
+      const usdPrices = /* @__PURE__ */ new Map();
+      baseAssetsWithUsd.forEach((asset) => {
+        if (asset !== "USD") {
+          const assetData = historicalBaseAssetPrices.find(
+            (a) => a.symbol === asset
+          );
+          const priceData = findClosestTimestampEntry(
+            assetData?.prices || [],
+            timestamp
+          );
+          usdPrices.set(asset, priceData ? parseFloat(priceData.price) : 0);
+        }
+      });
       baseAssetsWithUsd.forEach((asset1) => {
         prices[asset1] = {};
         baseAssetsWithUsd.forEach((asset2) => {
           if (asset1 === asset2) {
             prices[asset1][asset2] = 1;
-          } else if (asset1 === "USD" && asset2 !== "USD") {
-            const asset2Data = historicalBaseAssetPrices.find(
-              (a) => a.symbol === asset2
-            );
-            const priceData = findClosestTimestampEntry(
-              asset2Data?.prices || [],
-              timestamp
-            );
-            prices[asset1][asset2] = priceData ? parseFloat(priceData.price) : 0;
-          } else if (asset2 === "USD" && asset1 !== "USD") {
-            const asset1Data = historicalBaseAssetPrices.find(
-              (a) => a.symbol === asset1
-            );
-            const priceData = findClosestTimestampEntry(
-              asset1Data?.prices || [],
-              timestamp
-            );
-            prices[asset1][asset2] = priceData ? parseFloat(priceData.price) : 0;
-          } else if (asset1 !== "USD" && asset2 !== "USD") {
-            const asset1Data = historicalBaseAssetPrices.find(
-              (a) => a.symbol === asset1
-            );
-            const asset2Data = historicalBaseAssetPrices.find(
-              (a) => a.symbol === asset2
-            );
-            const asset1PriceData = findClosestTimestampEntry(
-              asset1Data?.prices || [],
-              timestamp
-            );
-            const asset2PriceData = findClosestTimestampEntry(
-              asset2Data?.prices || [],
-              timestamp
-            );
-            if (asset1PriceData && asset2PriceData) {
-              const asset1UsdPrice = parseFloat(asset1PriceData.price);
-              const asset2UsdPrice = parseFloat(asset2PriceData.price);
-              prices[asset1][asset2] = asset2UsdPrice > 0 ? asset1UsdPrice / asset2UsdPrice : 0;
-            } else {
-              prices[asset1][asset2] = 0;
-            }
+          } else if (asset1 === "USD") {
+            prices[asset1][asset2] = usdPrices.get(asset2) || 0;
+          } else if (asset2 === "USD") {
+            prices[asset1][asset2] = usdPrices.get(asset1) || 0;
+          } else {
+            const asset1UsdPrice = usdPrices.get(asset1) || 0;
+            const asset2UsdPrice = usdPrices.get(asset2) || 0;
+            prices[asset1][asset2] = asset2UsdPrice > 0 ? asset1UsdPrice / asset2UsdPrice : 0;
           }
         });
       });
@@ -57552,7 +57745,7 @@ var getHistoricalTokenPrices = async () => {
 // functions/getUserAutopoolsHistory.ts
 var ONE_DAY_IN_MS = 24 * 60 * 60 * 1e3;
 function validateEnhancedUserHistoryEntry(entry) {
-  return entry && typeof entry === "object" && entry.date instanceof Date && typeof entry.timestamp === "string" && Array.isArray(entry.autopools) && entry.nav && typeof entry.nav.ETH === "number" && typeof entry.nav.USD === "number" && typeof entry.nav.PXETH === "number" && typeof entry.nav.USDC === "number" && Array.isArray(entry.events) && typeof entry.differential === "number";
+  return entry && typeof entry === "object" && entry.date instanceof Date && typeof entry.timestamp === "string" && Array.isArray(entry.autopools) && entry.nav && typeof entry.nav.ETH === "number" && typeof entry.nav.USD === "number" && typeof entry.nav.PXETH === "number" && typeof entry.nav.USDC === "number" && typeof entry.nav.EURC === "number" && typeof entry.nav.USDT === "number" && Array.isArray(entry.events) && typeof entry.differential === "number";
 }
 var getUserAutopoolsHistory = async (address, autopoolsHistory, events, includeTestnet = false) => {
   if (!autopoolsHistory) {
@@ -57611,7 +57804,7 @@ var getUserAutopoolsHistory = async (address, autopoolsHistory, events, includeT
               Math.floor(sharesRatio * Number(SCALE))
             );
             const navBigInt = sharesRatioBigInt * BigInt(dayData.nav) / SCALE;
-            const navNum = (0, import_utils11.formatUnitsNum)(
+            const navNum = (0, import_utils14.formatUnitsNum)(
               navBigInt,
               dayData.baseAsset.decimals
             );
@@ -57662,7 +57855,9 @@ var getUserAutopoolsHistory = async (address, autopoolsHistory, events, includeT
           ETH: 0,
           USD: 0,
           PXETH: 0,
-          USDC: 0
+          USDC: 0,
+          EURC: 0,
+          USDT: 0
         },
         date: dayData.date,
         autopools: {}
@@ -57673,17 +57868,21 @@ var getUserAutopoolsHistory = async (address, autopoolsHistory, events, includeT
     acc[timestampKey].nav.ETH += dayData.nav.ETH;
     acc[timestampKey].nav.PXETH += dayData.nav.PXETH;
     acc[timestampKey].nav.USDC += dayData.nav.USDC;
+    acc[timestampKey].nav.EURC += dayData.nav.EURC;
+    acc[timestampKey].nav.USDT += dayData.nav.USDT;
     return acc;
   }, {});
   let finalAggregatedHistoryArray = Object.keys(aggregatedHistoryArray).map(
     (dateKey) => ({
       date: aggregatedHistoryArray[dateKey].date,
-      formattedDate: (0, import_utils11.formatDateToReadable)(aggregatedHistoryArray[dateKey].date),
+      formattedDate: (0, import_utils14.formatDateToReadable)(aggregatedHistoryArray[dateKey].date),
       nav: {
         ETH: aggregatedHistoryArray[dateKey].nav.ETH,
         USD: aggregatedHistoryArray[dateKey].nav.USD,
         PXETH: aggregatedHistoryArray[dateKey].nav.PXETH,
-        USDC: aggregatedHistoryArray[dateKey].nav.USDC
+        USDC: aggregatedHistoryArray[dateKey].nav.USDC,
+        EURC: aggregatedHistoryArray[dateKey].nav.EURC,
+        USDT: aggregatedHistoryArray[dateKey].nav.USDT
       },
       timestamp: aggregatedHistoryArray[dateKey].timestamp,
       autopools: Object.values(aggregatedHistoryArray[dateKey].autopools)
@@ -57697,7 +57896,9 @@ var getUserAutopoolsHistory = async (address, autopoolsHistory, events, includeT
           ETH: dayData.nav.ETH,
           USD: dayData.nav.USD,
           PXETH: dayData.nav.PXETH,
-          USDC: dayData.nav.USDC
+          USDC: dayData.nav.USDC,
+          EURC: dayData.nav.EURC,
+          USDT: dayData.nav.USDT
         }
       };
     }
@@ -57709,7 +57910,7 @@ var getUserAutopoolsHistory = async (address, autopoolsHistory, events, includeT
         return eventDate.getTime() >= dayData.date.getTime() && eventDate.getTime() < dayData.date.getTime() + 24 * 60 * 60 * 1e3;
       });
       const differential = eventsForDay.reduce(
-        (sum, event) => sum + (0, import_utils11.formatEtherNum)(BigInt(event?.assetChange || 0n)),
+        (sum, event) => sum + (0, import_utils14.formatEtherNum)(BigInt(event?.assetChange || 0n)),
         0
       );
       return {
@@ -57877,9 +58078,9 @@ var getUserCurveLP = async (wagmiConfig, {
 };
 
 // functions/getMultipleAutopoolRebalances.ts
-var import_graph_cli7 = require("@tokemak/graph-cli");
+var import_graph_cli8 = require("@tokemak/graph-cli");
 var getMutlipleAutopoolRebalances = async (ids, chainId = 1) => {
-  const { GetMutlipleAutopoolRebalances } = (0, import_graph_cli7.getSdkByChainId)(chainId);
+  const { GetMutlipleAutopoolRebalances } = (0, import_graph_cli8.getSdkByChainId)(chainId);
   const { autopools } = await GetMutlipleAutopoolRebalances({
     addresses: ids
   });
@@ -57889,12 +58090,12 @@ var getMutlipleAutopoolRebalances = async (ids, chainId = 1) => {
 
 // functions/getAutopoolDayData.ts
 var import_viem7 = require("viem");
-var import_utils13 = require("@tokemak/utils");
+var import_utils16 = require("@tokemak/utils");
 var import_constants7 = require("@tokemak/constants");
-var import_graph_cli8 = require("@tokemak/graph-cli");
+var import_graph_cli9 = require("@tokemak/graph-cli");
 var getAutopoolDayData = async (address, chainId = 1, startTimestamp = import_constants7.TOKEMAK_LAUNCH_TIMESTAMP) => {
   try {
-    const { GetAutopoolDayData } = (0, import_graph_cli8.getSdkByChainId)(chainId);
+    const { GetAutopoolDayData } = (0, import_graph_cli9.getSdkByChainId)(chainId);
     const { autopoolDayDatas } = await GetAutopoolDayData({
       address,
       timestamp: startTimestamp
@@ -57903,10 +58104,10 @@ var getAutopoolDayData = async (address, chainId = 1, startTimestamp = import_co
       const navPerShare = autoPoolDayData.nav / autoPoolDayData.totalSupply;
       let baseApy = autoPoolDayData.autopoolApy;
       let rewarderApy = 0;
-      const formattedRewarder7DayMAApy = (0, import_utils13.formatEtherNum)(
+      const formattedRewarder7DayMAApy = (0, import_utils16.formatEtherNum)(
         BigInt(Number(autoPoolDayData.rewarderDay7MAApy) || 0)
       );
-      const formattedRewarder30DayMAApy = (0, import_utils13.formatEtherNum)(
+      const formattedRewarder30DayMAApy = (0, import_utils16.formatEtherNum)(
         BigInt(Number(autoPoolDayData.rewarderDay30MAApy) || 0)
       );
       if (formattedRewarder7DayMAApy) {
@@ -57985,12 +58186,12 @@ var getSystemConfig = async (wagmiConfig, { systemRegistry }) => {
 };
 
 // functions/getChainUserAutopools.tsx
-var import_graph_cli9 = require("@tokemak/graph-cli");
+var import_graph_cli10 = require("@tokemak/graph-cli");
 var getChainUserAutopools = async ({
   address,
   chainId = 1
 }) => {
-  const { GetUserVaultInfo } = (0, import_graph_cli9.getSdkByChainId)(chainId);
+  const { GetUserVaultInfo } = (0, import_graph_cli10.getSdkByChainId)(chainId);
   try {
     if (address) {
       const { userInfo } = await GetUserVaultInfo({
@@ -58006,13 +58207,13 @@ var getChainUserAutopools = async ({
 };
 
 // functions/getUserAutopools.ts
-var import_utils15 = require("@tokemak/utils");
+var import_utils18 = require("@tokemak/utils");
 var import_tokenlist6 = require("@tokemak/tokenlist");
 
 // functions/getUserAutopool.tsx
 var import_viem8 = require("viem");
 var import_core9 = require("@wagmi/core");
-var import_utils14 = require("@tokemak/utils");
+var import_utils17 = require("@tokemak/utils");
 var import_abis9 = require("@tokemak/abis");
 var getUserAutopool = async (wagmiConfig, {
   address,
@@ -58061,10 +58262,10 @@ var getUserAutopool = async (wagmiConfig, {
         args: [address],
         chainId: autopool?.chain?.chainId
       });
-      const stakedShares = (0, import_utils14.formatEtherNum)(stakedPoolShares);
+      const stakedShares = (0, import_utils17.formatEtherNum)(stakedPoolShares);
       const stakedNav = stakedShares * (autopool?.navPerShare.baseAsset || 0);
       const stakedNavUsd = stakedShares * (autopool?.navPerShare.USD || 0);
-      const unstakedShares = (0, import_utils14.formatEtherNum)(unstakedPoolShares || 0n);
+      const unstakedShares = (0, import_utils17.formatEtherNum)(unstakedPoolShares || 0n);
       const unstakedNav = unstakedShares * (autopool?.navPerShare.USD || 0);
       const unstakedNavUsd = unstakedShares * (autopool?.navPerShare.USD || 0);
       const totalShares = unstakedShares + stakedShares;
@@ -58085,7 +58286,7 @@ var getUserAutopool = async (wagmiConfig, {
         });
         pastRewarderBalances = pastRewards.map(({ result }, index) => {
           const balance = result;
-          const shares = (0, import_utils14.formatEtherNum)(result);
+          const shares = (0, import_utils17.formatEtherNum)(result);
           const nav = shares * (autopool?.navPerShare.baseAsset || 0);
           const navUsd = shares * (autopool?.navPerShare.USD || 0);
           return {
@@ -58194,7 +58395,8 @@ var getUserAutopools = async ({
       let categories = {
         usd: { ...initialAutopoolsValue },
         eth: { ...initialAutopoolsValue },
-        crypto: { ...initialAutopoolsValue }
+        crypto: { ...initialAutopoolsValue },
+        stables: { ...initialAutopoolsValue }
       };
       const userAutopoolsWithData = userAutopools.map((userAutopool) => {
         const autopoolData = autopools.find(
@@ -58202,14 +58404,14 @@ var getUserAutopools = async ({
         );
         if (autopoolData) {
           const isDOLA = autopoolData.symbol === "autoDOLA" && userAutoDOLA;
-          const userShares = isDOLA ? userAutoDOLA?.totalShares : (0, import_utils15.formatEtherNum)(userAutopool?.totalShares);
-          const totalVaultShares = (0, import_utils15.formatEtherNum)(autopoolData?.totalSupply);
+          const userShares = isDOLA ? userAutoDOLA?.totalShares : (0, import_utils18.formatEtherNum)(userAutopool?.totalShares);
+          const totalVaultShares = (0, import_utils18.formatEtherNum)(autopoolData?.totalSupply);
           const userShareOfVault = userShares / totalVaultShares;
-          const totalDeposits = (0, import_utils15.formatUnitsNum)(
+          const totalDeposits = (0, import_utils18.formatUnitsNum)(
             userActivity?.totals[userAutopool.vaultAddress]?.totalDeposits || 0n,
             autopoolData?.baseAsset.decimals
           );
-          const totalWithdrawals = (0, import_utils15.formatUnitsNum)(
+          const totalWithdrawals = (0, import_utils18.formatUnitsNum)(
             userActivity?.totals[userAutopool.vaultAddress]?.totalWithdrawals || 0n,
             autopoolData?.baseAsset.decimals
           );
@@ -58218,7 +58420,7 @@ var getUserAutopools = async ({
           );
           let lastDeposit;
           if (poolEvents && poolEvents?.length > 0) {
-            lastDeposit = (0, import_utils15.convertTimestampToDate)(
+            lastDeposit = (0, import_utils18.convertTimestampToDate)(
               poolEvents[poolEvents.length - 1].timestamp
             ).toLocaleDateString("en-US", {
               day: "2-digit",
@@ -58318,7 +58520,7 @@ var getUserAutopools = async ({
             totalWithdrawals: prev.totalWithdrawals + totalWithdrawals
           };
           const stakedBalance = isDOLA ? userAutoDOLA?.staked.balance : BigInt(userAutopool?.stakedShares);
-          const stakedShares = isDOLA ? userAutoDOLA?.staked.shares : (0, import_utils15.formatEtherNum)(stakedBalance);
+          const stakedShares = isDOLA ? userAutoDOLA?.staked.shares : (0, import_utils18.formatEtherNum)(stakedBalance);
           const stakedNav = stakedShares * (autopoolData?.navPerShare.baseAsset || 0);
           const staked = convertBaseAssetToTokenPrices(
             stakedNav,
@@ -58326,7 +58528,7 @@ var getUserAutopools = async ({
             prices
           );
           const unstakedBalance = isDOLA ? userAutoDOLA?.unstaked.balance : BigInt(userAutopool?.walletShares);
-          const unstakedShares = isDOLA ? userAutoDOLA?.unstaked.shares : (0, import_utils15.formatEtherNum)(unstakedBalance);
+          const unstakedShares = isDOLA ? userAutoDOLA?.unstaked.shares : (0, import_utils18.formatEtherNum)(unstakedBalance);
           const unstakedNav = unstakedShares * (autopoolData?.navPerShare.baseAsset || 0);
           const unstaked = convertBaseAssetToTokenPrices(
             unstakedNav,
@@ -58335,7 +58537,10 @@ var getUserAutopools = async ({
           );
           const stakedRatio = stakedShares / userShares;
           const unstakedRatio = 1 - stakedRatio;
-          const blendedApr = stakedRatio * autopoolData?.apr?.combined + unstakedRatio * autopoolData?.apr?.base;
+          const isSilo = autopoolData?.symbol === "siloETH" || autopoolData?.symbol === "siloUSD";
+          const baseApr = autopoolData?.apr?.base ?? 0;
+          const stakedAprForBlend = isSilo ? baseApr : autopoolData?.apr?.combined ?? 0;
+          const blendedApr = stakedRatio * stakedAprForBlend + unstakedRatio * baseApr;
           return {
             name: autopoolData?.name,
             symbol: autopoolData?.symbol,
@@ -58358,6 +58563,7 @@ var getUserAutopools = async ({
               nav: unstaked
             },
             useDenomination: autopoolData?.useDenomination,
+            baseApr,
             blendedApr,
             rewardsClaimed: userAutopool?.rewardsClaimed,
             lastDeposit,
@@ -58522,14 +58728,14 @@ var getUserAutopools = async ({
 
 // functions/getUserTokenBalances.ts
 var import_viem9 = require("viem");
-var import_chains7 = require("viem/chains");
+var import_chains6 = require("viem/chains");
 var networkToAlchemyUrl = (chainId, apiKey) => {
   switch (chainId) {
-    case import_chains7.mainnet.id:
+    case import_chains6.mainnet.id:
       return `https://eth-mainnet.g.alchemy.com/v2/${apiKey}`;
-    case import_chains7.base.id:
+    case import_chains6.base.id:
       return `https://base-mainnet.g.alchemy.com/v2/${apiKey}`;
-    case import_chains7.sonic.id:
+    case import_chains6.sonic.id:
       return `https://sonic-mainnet.g.alchemy.com/v2/${apiKey}`;
     default:
       throw new Error("Unsupported network");
@@ -58591,10 +58797,10 @@ var getTokenList = async () => {
 };
 
 // functions/getTopAutopoolHolders.ts
-var import_graph_cli10 = require("@tokemak/graph-cli");
+var import_graph_cli11 = require("@tokemak/graph-cli");
 var getTopAutopoolHolders = async (autopoolAddress, chainId = 1) => {
   try {
-    const { GetTopAutopoolHolders } = (0, import_graph_cli10.getSdkByChainId)(chainId);
+    const { GetTopAutopoolHolders } = (0, import_graph_cli11.getSdkByChainId)(chainId);
     const { holders } = await GetTopAutopoolHolders({
       address: autopoolAddress
     });
@@ -58656,6 +58862,9 @@ var getUserActivity = async ({
   return mergedActivity;
 };
 
+// functions/getUserAutopoolsRewards.ts
+var import_viem11 = require("viem");
+
 // functions/getChainUserAutopoolsRewards.ts
 var import_config8 = require("@tokemak/config");
 var import_core11 = require("@wagmi/core");
@@ -58684,7 +58893,11 @@ var getChainUserAutopoolsRewards = async (wagmiConfig, {
         if (!userRewards[autopool]) {
           userRewards[autopool] = {};
         }
-        userRewards[autopool][token.tokenAddress] = token.amount;
+        if (userRewards[autopool][token.tokenAddress]) {
+          userRewards[autopool][`${token.tokenAddress}-main`] = token.amount;
+        } else {
+          userRewards[autopool][`${token.tokenAddress}`] = token.amount;
+        }
       });
     });
     return userRewards;
@@ -58694,29 +58907,66 @@ var getChainUserAutopoolsRewards = async (wagmiConfig, {
 };
 
 // functions/getUserAutopoolsRewards.ts
-var import_utils19 = require("@tokemak/utils");
+var import_utils22 = require("@tokemak/utils");
+var import_tokenlist8 = require("@tokemak/tokenlist");
+var import_chains7 = require("viem/chains");
 var getUserAutopoolsRewards = async (wagmiConfig, {
   address,
   tokenPrices,
+  autopools,
   includeTestnet = false
 }) => {
   const chains = getChainsForEnv({ includeTestnet });
   try {
+    if (!autopools)
+      throw new Error("No autopools found");
     const userRewards = await Promise.all(
       chains.map(
         (chain) => getChainUserAutopoolsRewards(wagmiConfig, {
           chainId: chain.chainId,
-          address,
-          tokenPrices
+          address
         })
       )
     );
     const rewardsData = chains.map(({ chainId }, index) => {
       const chainUserRewards = userRewards[index] || {};
+      const extraRewardsArray = Object.entries(chainUserRewards).flatMap(
+        ([autopoolAddress, rewards]) => {
+          const autopool = autopools.find(
+            (autopool2) => (0, import_viem11.getAddress)(autopool2.poolAddress) === (0, import_viem11.getAddress)(autopoolAddress)
+          );
+          if (!autopool || !autopool.extraRewarders) {
+            return [];
+          }
+          return autopool.extraRewarders.map((extraRewards2) => {
+            const rewarderToken = (0, import_utils22.getToken)(
+              extraRewards2.rewardToken?.id,
+              autopool.chain?.chainId
+            );
+            const claimableAmount = rewards ? rewards[(0, import_viem11.getAddress)(extraRewards2.rewardToken?.id)] : 0n;
+            let price = tokenPrices[rewarderToken.symbol] || 0;
+            if (rewarderToken.symbol === "XSILO") {
+              price = tokenPrices[import_tokenlist8.SILO_TOKEN.symbol] || 0;
+            }
+            const formattedAmount = (0, import_utils22.formatUnitsNum)(
+              claimableAmount,
+              rewarderToken.decimals || 18
+            );
+            return {
+              address: (0, import_viem11.getAddress)(extraRewards2?.id),
+              chainId,
+              token: rewarderToken,
+              amount: claimableAmount,
+              formattedAmount,
+              USD: formattedAmount * price
+            };
+          });
+        }
+      );
       const tokenRewards = {};
       Object.values(chainUserRewards).forEach((autopoolRewards) => {
         Object.entries(autopoolRewards).forEach(([tokenAddress, amount]) => {
-          const token = (0, import_utils19.getToken)(tokenAddress, chainId);
+          const token = (0, import_utils22.getToken)(tokenAddress, chainId);
           const tokenSymbol = token.symbol;
           if (!tokenRewards[tokenSymbol]) {
             tokenRewards[tokenSymbol] = {
@@ -58732,8 +58982,11 @@ var getUserAutopoolsRewards = async (wagmiConfig, {
       });
       Object.entries(tokenRewards).forEach(
         ([tokenSymbol, { amount, decimals }]) => {
-          const price = tokenPrices[tokenSymbol] || 0;
-          const formattedAmount = (0, import_utils19.formatUnitsNum)(amount, decimals || 18);
+          let price = tokenPrices[tokenSymbol] || 0;
+          if (tokenSymbol === "XSILO") {
+            price = tokenPrices[import_tokenlist8.SILO_TOKEN.symbol] || 0;
+          }
+          const formattedAmount = (0, import_utils22.formatUnitsNum)(amount, decimals || 18);
           tokenRewards[tokenSymbol] = {
             amount,
             formattedAmount,
@@ -58742,10 +58995,21 @@ var getUserAutopoolsRewards = async (wagmiConfig, {
           };
         }
       );
+      if (Object.keys(tokenRewards).includes("undefined") && chainId === import_chains7.plasma.id) {
+        const undefinedToken = tokenRewards["undefined"];
+        let price = tokenPrices.TOKE || 0;
+        tokenRewards["TOKE"] = {
+          ...undefinedToken,
+          USD: undefinedToken.formattedAmount * price,
+          logoURI: import_tokenlist8.TOKE_TOKEN.logoURI
+        };
+        delete tokenRewards["undefined"];
+      }
       return {
         chainId,
         autopools: chainUserRewards,
-        rewards: tokenRewards
+        rewards: tokenRewards,
+        extraRewards: extraRewardsArray
       };
     });
     const rewardsByToken = {};
@@ -58770,14 +59034,21 @@ var getUserAutopoolsRewards = async (wagmiConfig, {
       (acc, { USD }) => acc + USD,
       0
     );
+    const extraRewards = rewardsData.flatMap(
+      ({ extraRewards: extraRewards2 }) => extraRewards2
+    );
+    const hasRewards = totalRewardsUSD > 0 || extraRewards.some((extraReward) => extraReward.USD > 0);
     return {
       chains: {
         ...Object.fromEntries(
           rewardsData.map(({ chainId, ...data }) => [chainId, data])
         )
       },
+      tokeRewards: rewardsByToken.TOKE,
+      extraRewards,
       rewardsByToken,
-      totalRewardsUSD
+      totalRewardsUSD,
+      hasRewards
     };
   } catch (e) {
     console.error(e);
@@ -58785,8 +59056,8 @@ var getUserAutopoolsRewards = async (wagmiConfig, {
 };
 
 // functions/getAmountWithdrawn.ts
-var import_viem12 = require("viem");
-var import_utils21 = require("@tokemak/utils");
+var import_viem13 = require("viem");
+var import_utils24 = require("@tokemak/utils");
 
 // functions/getSwapQuote.ts
 var import_constants8 = require("@tokemak/constants");
@@ -58816,17 +59087,20 @@ var getAutopilotRouter = async (wagmiConfig, { chainId }) => await getAddressFro
 
 // functions/getSwapQuote.ts
 var import_config10 = require("@tokemak/config");
-var import_tokenlist8 = require("@tokemak/tokenlist");
+var import_tokenlist9 = require("@tokemak/tokenlist");
 var import_chains8 = require("viem/chains");
 var getSwapQuote = async (config, { chainId, ...params }) => {
   try {
     if (!params.sellToken || !params.buyToken) {
       throw new Error("Sell token and buy token are required");
     }
-    if (params.sellToken === import_tokenlist8.ETH_TOKEN.address) {
+    if (params.sellToken === import_tokenlist9.ETH_TOKEN.address) {
       params.sellToken = (0, import_config10.getCoreConfig)(chainId).weth;
       if (chainId === import_chains8.sonic.id) {
-        params.sellToken = import_tokenlist8.WS_TOKEN.address;
+        params.sellToken = import_tokenlist9.WS_TOKEN.address;
+      }
+      if (chainId === import_chains8.plasma.id) {
+        params.sellToken = import_tokenlist9.WXPL_TOKEN.address;
       }
     }
     const sellAmount = params.sellAmount.toString();
@@ -58861,7 +59135,7 @@ var import_core13 = require("@wagmi/core");
 var import_abis12 = require("@tokemak/abis");
 var import_config11 = require("@tokemak/config");
 var import_autopilot_swap_route_calc = __toESM(require_dist2(), 1);
-var import_viem11 = require("viem");
+var import_viem12 = require("viem");
 var import_constants9 = require("@tokemak/constants");
 var placeholderAddress = "0x8b4334d4812c530574bd4f2763fcd22de94a969b";
 var getDynamicSwap = async ({
@@ -58936,7 +59210,7 @@ var getDynamicSwap = async ({
             account: user || placeholderAddress
           });
         } catch (e) {
-          if (e instanceof import_viem11.ContractFunctionExecutionError && e.cause instanceof import_viem11.ContractFunctionRevertedError && e.cause.data?.errorName === "PreviewRedeemWithRoutesResult") {
+          if (e instanceof import_viem12.ContractFunctionExecutionError && e.cause instanceof import_viem12.ContractFunctionRevertedError && e.cause.data?.errorName === "PreviewRedeemWithRoutesResult") {
             previewRedeem = e.cause.data?.args?.[0];
           }
         }
@@ -58965,7 +59239,7 @@ var getDynamicSwap = async ({
 };
 
 // functions/getAmountWithdrawn.ts
-var import_tokenlist9 = require("@tokemak/tokenlist");
+var import_tokenlist10 = require("@tokemak/tokenlist");
 var import_config12 = require("@tokemak/config");
 var import_core14 = require("@wagmi/core");
 var import_abis13 = require("@tokemak/abis");
@@ -58997,13 +59271,13 @@ var getAmountWithdrawn = async ({
     let quote;
     let convertedAssets;
     if (!!dynamicSwap?.previewRedeem) {
-      const minAmountWithSlippage = (0, import_utils21.calculateMinAmountWithSlippage)(
+      const minAmountWithSlippage = (0, import_utils24.calculateMinAmountWithSlippage)(
         dynamicSwap?.previewRedeem,
         slippage
       );
-      let minAmount = (0, import_viem12.formatUnits)(minAmountWithSlippage, decimals);
+      let minAmount = (0, import_viem13.formatUnits)(minAmountWithSlippage, decimals);
       if (isSwap) {
-        if (buyToken === import_tokenlist9.ETH_TOKEN.address) {
+        if (buyToken === import_tokenlist10.ETH_TOKEN.address) {
           const weth = (0, import_config12.getCoreConfig)(chainId).weth;
           buyToken = weth;
         }
@@ -59021,13 +59295,13 @@ var getAmountWithdrawn = async ({
           buyToken,
           sellToken,
           sellAmount: dynamicSwap?.previewRedeem,
-          slippageBps: (0, import_utils21.convertNumToBps)(slippage),
+          slippageBps: (0, import_utils24.convertNumToBps)(slippage),
           chainId,
           includeSources: "0xV2",
           sellAll: true
         });
         if (quote) {
-          minAmount = (0, import_viem12.formatUnits)(BigInt(quote?.minBuyAmount), decimals);
+          minAmount = (0, import_viem13.formatUnits)(BigInt(quote?.minBuyAmount), decimals);
         } else {
           throw new Error("No quote found");
         }
@@ -59049,7 +59323,7 @@ var getAmountWithdrawn = async ({
 // functions/getAmountDeposited.ts
 var import_core15 = require("@wagmi/core");
 var import_abis14 = require("@tokemak/abis");
-var import_utils22 = require("@tokemak/utils");
+var import_utils25 = require("@tokemak/utils");
 var getAmountDeposited = async ({
   address,
   chainId,
@@ -59070,13 +59344,13 @@ var getAmountDeposited = async ({
       chainId
     });
     if (!isSwap) {
-      let minAmountWithSlippage = (0, import_utils22.calculateMinAmountWithSlippage)(
+      let minAmountWithSlippage = (0, import_utils25.calculateMinAmountWithSlippage)(
         previewDeposit,
         slippage
       );
-      return (0, import_utils22.formatEtherNum)(minAmountWithSlippage);
+      return (0, import_utils25.formatEtherNum)(minAmountWithSlippage);
     } else {
-      return (0, import_utils22.formatEtherNum)(previewDeposit);
+      return (0, import_utils25.formatEtherNum)(previewDeposit);
     }
   } catch (e) {
     console.error(e);
@@ -59088,7 +59362,7 @@ var getAmountDeposited = async ({
 // functions/getBridgeFee.ts
 var import_core16 = require("@wagmi/core");
 var import_abis15 = require("@tokemak/abis");
-var import_viem13 = require("viem");
+var import_viem14 = require("viem");
 
 // ../../node_modules/@ethersproject/logger/lib.esm/_version.js
 var version = "logger/5.8.0";
@@ -59860,7 +60134,7 @@ var getBridgeFee = async (wagmiConfig, {
     const minAmountLD = amount / factor * factor;
     const sendParams = {
       dstEid: eid,
-      to: (0, import_viem13.toHex)(addressToBytes32(from)),
+      to: (0, import_viem14.toHex)(addressToBytes32(from)),
       amountLD: amount,
       minAmountLD,
       extraOptions: "0x",
@@ -59938,9 +60212,9 @@ var waitForMessageReceived = async ({
 // functions/getChainUserSToke.ts
 var import_abis17 = require("@tokemak/abis");
 var import_config13 = require("@tokemak/config");
-var import_utils23 = require("@tokemak/utils");
+var import_utils26 = require("@tokemak/utils");
 var import_core18 = require("@wagmi/core");
-var import_viem14 = require("viem");
+var import_viem15 = require("viem");
 var import_chains9 = require("viem/chains");
 
 // functions/getCurrentCycleId.ts
@@ -59959,7 +60233,7 @@ var getCurrentCycleId = async (wagmiConfig, {
 };
 
 // functions/getChainUserSToke.ts
-var import_graph_cli11 = require("@tokemak/graph-cli");
+var import_graph_cli12 = require("@tokemak/graph-cli");
 var getChainUserSToke = async (wagmiConfig, {
   address,
   tokePrice,
@@ -59969,7 +60243,7 @@ var getChainUserSToke = async (wagmiConfig, {
     const { stoke } = (0, import_config13.getCoreConfig)(chainId);
     const cycleIndex = await getCurrentCycleId(wagmiConfig, { chainId, stoke });
     if (address && cycleIndex && stoke && tokePrice) {
-      const { GetUserSTokeBalance } = (0, import_graph_cli11.getSdkByChainId)(
+      const { GetUserSTokeBalance } = (0, import_graph_cli12.getSdkByChainId)(
         chainId
       );
       const { accountBalanceV1S } = await GetUserSTokeBalance({
@@ -60014,8 +60288,8 @@ var getChainUserSToke = async (wagmiConfig, {
         if (withdrawalAmount > 0n && cycleIndex >= withdrawalMinCycle) {
           balanceExcludingWithdrawal = balanceExcludingWithdrawal - withdrawalAmount;
         }
-        const withdrawalAmountUsd = (0, import_utils23.formatCurrency)(
-          (0, import_utils23.formatEtherNum)(withdrawalAmount) * tokePrice
+        const withdrawalAmountUsd = (0, import_utils26.formatCurrency)(
+          (0, import_utils26.formatEtherNum)(withdrawalAmount) * tokePrice
         );
         const lockDuration = Number(depositLockDuration);
         const lockCycle = Number(depositLockCycle);
@@ -60036,16 +60310,16 @@ var getChainUserSToke = async (wagmiConfig, {
         const withdrawAvailable = lockRenew - 1;
         const hasAddedLockedToke = depositAmount > 0n && depositAmount > rolloverDepositAmount;
         const addedLockedToke = depositAmount - rolloverDepositAmount;
-        const balanceUSD = (0, import_utils23.formatCurrency)(
-          Number((0, import_viem14.formatEther)(balanceExcludingWithdrawal)) * tokePrice
+        const balanceUSD = (0, import_utils26.formatCurrency)(
+          Number((0, import_viem15.formatEther)(balanceExcludingWithdrawal)) * tokePrice
         );
-        const balanceExcludingWithdrawalUsd = (0, import_utils23.formatCurrency)(
-          (0, import_utils23.formatEtherNum)(balanceExcludingWithdrawal) * tokePrice
+        const balanceExcludingWithdrawalUsd = (0, import_utils26.formatCurrency)(
+          (0, import_utils26.formatEtherNum)(balanceExcludingWithdrawal) * tokePrice
         );
         const isUnlockRequestAvailable = currentCycle === withdrawAvailable;
         const hasRequestedUnlock = withdrawalAmount > 0n;
-        const unlockRequestPeriodStartUnix = (0, import_utils23.convertChainCycleToUnix)(withdrawAvailable, chainId) - Date.now() / 1e3;
-        const unlockRequestPeriodEndUnix = (0, import_utils23.convertChainCycleToUnix)(lockRenew, chainId) - Date.now() / 1e3;
+        const unlockRequestPeriodStartUnix = (0, import_utils26.convertChainCycleToUnix)(withdrawAvailable, chainId) - Date.now() / 1e3;
+        const unlockRequestPeriodEndUnix = (0, import_utils26.convertChainCycleToUnix)(lockRenew, chainId) - Date.now() / 1e3;
         const hasBalance = balance > 0n;
         const hasBalanceExcludingWithdrawal = balanceExcludingWithdrawal > 0n;
         const hasUnlockableBalance = withdrawalMinCycle <= currentCycle && withdrawalAmount > 0n;
@@ -60055,8 +60329,8 @@ var getChainUserSToke = async (wagmiConfig, {
           lockDurationInMonths = lockDuration - 1;
         }
         const unlockPeriodDateRangeArray = [
-          new Date((0, import_utils23.convertChainCycleToUnix)(withdrawAvailable, chainId) * 1e3),
-          new Date((0, import_utils23.convertChainCycleToUnix)(lockRenew, chainId) * 1e3)
+          new Date((0, import_utils26.convertChainCycleToUnix)(withdrawAvailable, chainId) * 1e3),
+          new Date((0, import_utils26.convertChainCycleToUnix)(lockRenew, chainId) * 1e3)
         ];
         const {
           unlockPeriodDateRange,
@@ -60068,18 +60342,18 @@ var getChainUserSToke = async (wagmiConfig, {
           unlockPeriodDateRangeArray,
           chainId === import_chains9.sepolia.id ? "time" : "date"
         );
-        const totalActiveUserCredits = (0, import_utils23.formatEtherNum)(balanceExcludingWithdrawal) * lockDurationInMonths;
-        const totalUserCredits = (0, import_utils23.formatEtherNum)(balance) * lockDurationInMonths;
+        const totalActiveUserCredits = (0, import_utils26.formatEtherNum)(balanceExcludingWithdrawal) * lockDurationInMonths;
+        const totalUserCredits = (0, import_utils26.formatEtherNum)(balance) * lockDurationInMonths;
         return {
           balance,
           balanceUSD,
-          balanceExcludingWithdrawal: hasBalance ? (0, import_viem14.formatEther)(balanceExcludingWithdrawal) : "0.00",
+          balanceExcludingWithdrawal: hasBalance ? (0, import_viem15.formatEther)(balanceExcludingWithdrawal) : "0.00",
           balanceExcludingWithdrawalUsd,
           hasBalanceExcludingWithdrawal,
-          timeLeftBeforeUnlockRequestAvailable: (0, import_utils23.convertSecondsToRemainingTime)(
+          timeLeftBeforeUnlockRequestAvailable: (0, import_utils26.convertSecondsToRemainingTime)(
             unlockRequestPeriodStartUnix
           ),
-          timeLeftBeforeUnlockRequestUnavailable: (0, import_utils23.convertSecondsToRemainingTime)(
+          timeLeftBeforeUnlockRequestUnavailable: (0, import_utils26.convertSecondsToRemainingTime)(
             unlockRequestPeriodEndUnix
           ),
           withdrawalAmount,
@@ -60096,7 +60370,7 @@ var getChainUserSToke = async (wagmiConfig, {
           unlockRenewalDate,
           lockDurationInMonths,
           boost: lockDuration,
-          points: (0, import_utils23.formatEtherNum)(balanceExcludingWithdrawal) * lockDuration,
+          points: (0, import_utils26.formatEtherNum)(balanceExcludingWithdrawal) * lockDuration,
           totalActiveCredits: totalActiveUserCredits,
           totalCredits: totalUserCredits
         };
@@ -60108,7 +60382,7 @@ var getChainUserSToke = async (wagmiConfig, {
 };
 
 // functions/getUserSToke.ts
-var import_utils25 = require("@tokemak/utils");
+var import_utils28 = require("@tokemak/utils");
 var getUserSToke = async (wagmiConfig, {
   address,
   tokePrice,
@@ -60135,8 +60409,8 @@ var getUserSToke = async (wagmiConfig, {
       }
       return acc;
     }, 0n);
-    const totalBalance = (0, import_utils25.formatEtherNum)(totalBalanceRaw || 0n);
-    const totalBalanceUsd = (0, import_utils25.formatCurrency)(totalBalance * tokePrice);
+    const totalBalance = (0, import_utils28.formatEtherNum)(totalBalanceRaw || 0n);
+    const totalBalanceUsd = (0, import_utils28.formatCurrency)(totalBalance * tokePrice);
     const hasBalance = totalBalance > 0;
     return {
       chains: { ...userSToke },
@@ -60150,12 +60424,12 @@ var getUserSToke = async (wagmiConfig, {
 };
 
 // functions/getChainSToke.ts
-var import_viem15 = require("viem");
+var import_viem16 = require("viem");
 var import_core19 = require("@wagmi/core");
 var import_abis18 = require("@tokemak/abis");
-var import_utils27 = require("@tokemak/utils");
+var import_utils30 = require("@tokemak/utils");
 var import_config14 = require("@tokemak/config");
-var import_utils28 = require("@tokemak/utils");
+var import_utils31 = require("@tokemak/utils");
 var getChainSToke = async (wagmiConfig, {
   tokePrice,
   chainId
@@ -60180,16 +60454,16 @@ var getChainSToke = async (wagmiConfig, {
           }
         ]
       });
-      const tvl = Number((0, import_viem15.formatEther)(totalSupply || 0n)) * tokePrice;
-      const secondsLeftBeforeNextCycle = (0, import_utils27.convertChainCycleToUnix)(Number(currentCycle) + 1, chainId) - Date.now() / 1e3;
+      const tvl = Number((0, import_viem16.formatEther)(totalSupply || 0n)) * tokePrice;
+      const secondsLeftBeforeNextCycle = (0, import_utils30.convertChainCycleToUnix)(Number(currentCycle) + 1, chainId) - Date.now() / 1e3;
       return {
         rawTotalSupply: totalSupply,
-        totalSupply: (0, import_utils27.formatLargeNumber)((0, import_viem15.formatEther)(totalSupply || 0n)),
-        tvl: (0, import_utils27.formatTVL)(tvl),
+        totalSupply: (0, import_utils30.formatLargeNumber)((0, import_viem16.formatEther)(totalSupply || 0n)),
+        tvl: (0, import_utils30.formatTVL)(tvl),
         rawTVL: tvl,
         currentCycle,
-        chain: (0, import_utils28.getNetwork)(chainId),
-        timeBeforeNextCycle: (0, import_utils27.convertSecondsToRemainingTime)(
+        chain: (0, import_utils31.getNetwork)(chainId),
+        timeBeforeNextCycle: (0, import_utils30.convertSecondsToRemainingTime)(
           secondsLeftBeforeNextCycle
         )
       };
@@ -60200,8 +60474,8 @@ var getChainSToke = async (wagmiConfig, {
 };
 
 // functions/getSToke.ts
-var import_utils29 = require("@tokemak/utils");
-var import_viem16 = require("viem");
+var import_utils32 = require("@tokemak/utils");
+var import_viem17 = require("viem");
 var getSToke = async (wagmiConfig, {
   tokePrice,
   includeTestnet = false
@@ -60220,14 +60494,14 @@ var getSToke = async (wagmiConfig, {
       }
       return acc;
     }, 0n);
-    const totalSupply = (0, import_utils29.formatLargeNumber)((0, import_viem16.formatEther)(totalSupplyBigInt || 0n));
+    const totalSupply = (0, import_utils32.formatLargeNumber)((0, import_viem17.formatEther)(totalSupplyBigInt || 0n));
     let tvlNum = Object.values(sToke).reduce((acc, item) => {
       if (item && item.rawTVL) {
         return acc + item.rawTVL;
       }
       return acc;
     }, 0);
-    const tvl = (0, import_utils29.formatTVL)(tvlNum);
+    const tvl = (0, import_utils32.formatTVL)(tvlNum);
     return { totalSupply, tvl, rawTVL: tvlNum, chains: { ...sToke } };
   } catch (e) {
     console.error(e);
@@ -60279,8 +60553,8 @@ var getChainCycleRolloverBlockNumber = async (wagmiConfig, {
 };
 
 // functions/getChainUserSTokeVotes.ts
-var import_utils32 = require("@tokemak/utils");
-var import_graph_cli12 = require("@tokemak/graph-cli");
+var import_utils35 = require("@tokemak/utils");
+var import_graph_cli13 = require("@tokemak/graph-cli");
 var getChainUserSTokeVotes = async ({
   address,
   chainId = 1,
@@ -60289,7 +60563,7 @@ var getChainUserSTokeVotes = async ({
 }) => {
   try {
     if (address && stokeVotes) {
-      const { GetUserSTokeVotes, GetUserSTokeBalance } = (0, import_graph_cli12.getSdkByChainId)(chainId);
+      const { GetUserSTokeVotes, GetUserSTokeBalance } = (0, import_graph_cli13.getSdkByChainId)(chainId);
       const { userVotes } = await GetUserSTokeVotes({
         address: address.toLowerCase()
       });
@@ -60302,10 +60576,10 @@ var getChainUserSTokeVotes = async ({
         subgraphUserVotesData?.pools || [],
         subgraphUserVotesData?.weights || []
       );
-      const stakedToke = (0, import_utils32.formatEtherNum)(
+      const stakedToke = (0, import_utils35.formatEtherNum)(
         BigInt(subgraphAccountVotesBalance?.amount || 0n)
       );
-      const totalUserVotes = (0, import_utils32.formatEtherNum)(
+      const totalUserVotes = (0, import_utils35.formatEtherNum)(
         BigInt(subgraphAccountVotesBalance?.points || 0n)
       );
       const autopools = {};
@@ -60393,21 +60667,21 @@ var getUserSTokeVotes = async ({
 
 // functions/getChainSTokeVotes.ts
 var import_config15 = require("@tokemak/config");
-var import_utils35 = require("@tokemak/utils");
-var import_viem17 = require("viem");
-var import_graph_cli13 = require("@tokemak/graph-cli");
+var import_utils38 = require("@tokemak/utils");
+var import_viem18 = require("viem");
+var import_graph_cli14 = require("@tokemak/graph-cli");
 var getChainSTokeVotes = async ({
   chainId,
   includeTestnet = false
 }) => {
-  const { GetSTokeVotes } = (0, import_graph_cli13.getSdkByChainId)(chainId);
+  const { GetSTokeVotes } = (0, import_graph_cli14.getSdkByChainId)(chainId);
   const { accTokeVoteWeights, voteStatuses } = await GetSTokeVotes();
   const autopoolRawVotes = voteStatuses[0];
   const globalVotes = accTokeVoteWeights[0];
   const globalVoted = BigInt(globalVotes.voted);
   const globalNotVoted = BigInt(globalVotes.notVoted);
   const whitelistedPools = includeTestnet ? autopoolRawVotes?.pools || [] : (autopoolRawVotes?.pools || []).filter(
-    (pool) => import_config15.AUTOPOOLS_WHITELIST_PROD.includes((0, import_viem17.getAddress)(pool))
+    (pool) => import_config15.AUTOPOOLS_WHITELIST_PROD.includes((0, import_viem18.getAddress)(pool))
   );
   const poolCount = whitelistedPools.length;
   const perPoolNotVoted = !!poolCount ? globalNotVoted / BigInt(poolCount) : 0n;
@@ -60424,13 +60698,13 @@ var getChainSTokeVotes = async ({
     updatedPoints
   );
   const globalSystemVotes = globalVoted + globalNotVoted;
-  const totalSystemVotesNum = (0, import_utils35.formatEtherNum)(globalSystemVotes);
+  const totalSystemVotesNum = (0, import_utils38.formatEtherNum)(globalSystemVotes);
   const formattedAutopoolVotes = Object.fromEntries(
     Object.entries(autopoolVotes).filter(
       ([poolAddress]) => includeTestnet ? true : whitelistedPools.includes(poolAddress)
     ).map(([poolAddress, rawVote]) => {
-      const formattedVote = (0, import_utils35.formatLargeNumber)(
-        (0, import_utils35.formatEtherNum)(BigInt(rawVote))
+      const formattedVote = (0, import_utils38.formatLargeNumber)(
+        (0, import_utils38.formatEtherNum)(BigInt(rawVote))
       );
       return [
         poolAddress,
@@ -60445,7 +60719,7 @@ var getChainSTokeVotes = async ({
       globalSystemVotes
     },
     totalSystemVotesNum,
-    totalSystemVotes: (0, import_utils35.formatLargeNumber)(totalSystemVotesNum),
+    totalSystemVotes: (0, import_utils38.formatLargeNumber)(totalSystemVotesNum),
     autopoolVotes: formattedAutopoolVotes
   };
 };
@@ -60470,14 +60744,14 @@ var getSTokeVotes = async ({
 
 // functions/getChainSTokeRewards.ts
 var import_config16 = require("@tokemak/config");
-var import_viem18 = require("viem");
-var import_utils37 = require("@tokemak/utils");
-var import_graph_cli14 = require("@tokemak/graph-cli");
+var import_viem19 = require("viem");
+var import_utils40 = require("@tokemak/utils");
+var import_graph_cli15 = require("@tokemak/graph-cli");
 var getChainSTokeRewards = async ({
   chainId
 }) => {
   try {
-    const { GetSTokeRewards } = (0, import_graph_cli14.getSdkByChainId)(chainId);
+    const { GetSTokeRewards } = (0, import_graph_cli15.getSdkByChainId)(chainId);
     const { poolRewardsBalances } = await GetSTokeRewards();
     const allPoolRewardsBalanceDayDatas = await paginateQuery(
       GetSTokeRewards,
@@ -60495,9 +60769,9 @@ var getChainSTokeRewards = async ({
       if (!whitelistedPools.includes(pool.id.toLowerCase())) {
         continue;
       }
-      const convertedBalance = (0, import_utils37.formatEtherNum)(pool.balance);
-      const convertedBalanceUSD = Number((0, import_viem18.formatUnits)(pool.balanceUSD, 8));
-      const convertedApr = (0, import_utils37.formatEtherNum)(pool.currentAprPerCredit);
+      const convertedBalance = (0, import_utils40.formatEtherNum)(pool.balance);
+      const convertedBalanceUSD = Number((0, import_viem19.formatUnits)(pool.balanceUSD, 8));
+      const convertedApr = (0, import_utils40.formatEtherNum)(pool.currentAprPerCredit);
       if (minApr === null || convertedApr < minApr) {
         minApr = convertedApr;
       }
@@ -60570,7 +60844,7 @@ var getSTokeRewards = async ({
 
 // functions/getChainUserSTokeRewards.ts
 var import_config17 = require("@tokemak/config");
-var import_utils40 = require("@tokemak/utils");
+var import_utils43 = require("@tokemak/utils");
 var getChainUserSTokeRewards = async (wagmiConfig, {
   address,
   chainId,
@@ -60621,14 +60895,14 @@ var getChainUserSTokeRewards = async (wagmiConfig, {
       throw fallbackError;
     }
   }
-  const claimableNum = (0, import_utils40.formatEtherNum)(tokeRewards?.claimable || 0n);
+  const claimableNum = (0, import_utils43.formatEtherNum)(tokeRewards?.claimable || 0n);
   const claimableUsd = tokePrice * claimableNum;
   const hasClaimable = claimableNum > 0n;
-  const pendingRewards = (0, import_utils40.formatEtherNum)(
+  const pendingRewards = (0, import_utils43.formatEtherNum)(
     tokeRewards?.rewardsPayload.breakdown?.totalRewardAmount || 0n
   );
   const pendingRewardsUsd = tokePrice * pendingRewards;
-  const totalRewardsReceived = (0, import_utils40.formatEtherNum)(
+  const totalRewardsReceived = (0, import_utils43.formatEtherNum)(
     tokeRewards.rewardsPayload.payload.amount || 0n
   );
   const totalRewardsReceivedUsd = tokePrice * totalRewardsReceived;
@@ -60645,11 +60919,11 @@ var getChainUserSTokeRewards = async (wagmiConfig, {
 };
 
 // functions/getChainSubgraphStatus.ts
-var import_graph_cli15 = require("@tokemak/graph-cli");
+var import_graph_cli16 = require("@tokemak/graph-cli");
 var getChainSubgraphStatus = async (chain) => {
   const currentTimestamp = Math.floor(Date.now() / 1e3);
   try {
-    const { GetLatestSubgraphTimestamp } = (0, import_graph_cli15.getSdkByChainId)(
+    const { GetLatestSubgraphTimestamp } = (0, import_graph_cli16.getSdkByChainId)(
       chain.chainId
     );
     const { _meta } = await GetLatestSubgraphTimestamp();
@@ -60703,13 +60977,13 @@ var getSubgraphStatus = async (includeTestnet = false) => {
 // functions/getCycleV1.ts
 var import_core21 = require("@wagmi/core");
 var import_abis20 = require("@tokemak/abis");
-var import_viem19 = require("viem");
-var import_utils42 = require("@tokemak/utils");
+var import_viem20 = require("viem");
+var import_utils45 = require("@tokemak/utils");
 var import_config18 = require("@tokemak/config");
 var import_chains10 = require("viem/chains");
-var publicClient = (0, import_viem19.createPublicClient)({
+var publicClient = (0, import_viem20.createPublicClient)({
   chain: import_chains10.mainnet,
-  transport: (0, import_viem19.http)("https://mainnet.infura.io/v3/2BtQ5D1QEPHvwgZwKwnZC7WQVhr")
+  transport: (0, import_viem20.http)("https://mainnet.infura.io/v3/2BtQ5D1QEPHvwgZwKwnZC7WQVhr")
 });
 var getCycleV1 = async (wagmiConfig, {
   currentBlockNumber,
@@ -60738,11 +61012,11 @@ var getCycleV1 = async (wagmiConfig, {
       });
       const rolloverEvents = await publicClient.getFilterLogs({ filter });
       const cycleRolloverBlockNumber = chainId === 1 ? rolloverEvents[rolloverEvents.length - 1]?.blockNumber : rolloverEvents[rolloverEvents.length - 1]?.blockNumber || currentBlockNumber;
-      const secondsLeftBeforeNextCycle = (0, import_utils42.convertChainCycleToUnix)(Number(currentCycleIndex) + 1) - Date.now() / 1e3;
+      const secondsLeftBeforeNextCycle = (0, import_utils45.convertChainCycleToUnix)(Number(currentCycleIndex) + 1) - Date.now() / 1e3;
       return {
         currentCycleIndex,
         cycleRolloverBlockNumber,
-        timeBeforeNextCycle: (0, import_utils42.convertSecondsToRemainingTime)(
+        timeBeforeNextCycle: (0, import_utils45.convertSecondsToRemainingTime)(
           secondsLeftBeforeNextCycle
         )
       };
@@ -60753,7 +61027,7 @@ var getCycleV1 = async (wagmiConfig, {
 };
 
 // functions/getProtocolStats.ts
-var import_utils43 = require("@tokemak/utils");
+var import_utils46 = require("@tokemak/utils");
 var getProtocolStats = async (autopools, stoke, sushiLP) => {
   try {
     if (!autopools || !stoke || !sushiLP) {
@@ -60783,12 +61057,12 @@ var getProtocolStats = async (autopools, stoke, sushiLP) => {
       Object.entries(categories).map(([key, value]) => [
         key,
         {
-          tvl: (0, import_utils43.formatTVL)(value.tvl),
-          supply: (0, import_utils43.formatLargeNumber)(value.supply || 0)
+          tvl: (0, import_utils46.formatTVL)(value.tvl),
+          supply: (0, import_utils46.formatLargeNumber)(value.supply || 0)
         }
       ])
     );
-    const tvl = (0, import_utils43.formatTVL)(autopoolTVL + stoke.rawTVL + (sushiLP?.tvl || 0));
+    const tvl = (0, import_utils46.formatTVL)(autopoolTVL + stoke.rawTVL + (sushiLP?.tvl || 0));
     const vaultAddresses = autopools?.flatMap(
       (pool) => pool.destinations.map((destination) => destination.vaultAddress)
     );
@@ -60796,16 +61070,16 @@ var getProtocolStats = async (autopools, stoke, sushiLP) => {
     const totalDestinations = uniqueVaultAddresses.length;
     return {
       autopools: {
-        tvl: (0, import_utils43.formatTVL)(autopoolTVL),
+        tvl: (0, import_utils46.formatTVL)(autopoolTVL),
         tvlNum: autopoolTVL,
         categories: formattedCategories
       },
       stoke: {
-        tvl: (0, import_utils43.formatTVL)(stoke.rawTVL),
+        tvl: (0, import_utils46.formatTVL)(stoke.rawTVL),
         totalSupply: `${stoke.totalSupply} TOKE`
       },
       sushiLP: {
-        tvl: (0, import_utils43.formatTVL)(sushiLP?.tvl || 0),
+        tvl: (0, import_utils46.formatTVL)(sushiLP?.tvl || 0),
         totalSupply: sushiLP?.totalSupply || 0
       },
       tvl,
@@ -60818,18 +61092,18 @@ var getProtocolStats = async (autopools, stoke, sushiLP) => {
 };
 
 // functions/getRebalanceStats.ts
-var import_graph_cli16 = require("@tokemak/graph-cli");
+var import_graph_cli17 = require("@tokemak/graph-cli");
 
 // functions/getEthPriceAtBlock.ts
 var import_getCoreConfig = require("@tokemak/config/helpers/getCoreConfig");
 var import_core22 = require("@wagmi/core");
 var import_abis21 = require("@tokemak/abis");
-var import_tokenlist10 = require("@tokemak/tokenlist");
+var import_tokenlist11 = require("@tokemak/tokenlist");
 var getEthPriceAtBlock = async (wagmiConfig, blockNumber, chainId) => {
   const config = (0, import_getCoreConfig.getCoreConfig)(chainId);
   const rootPriceOracle = config.rootPriceOracle;
   const weth = config.weth;
-  const usdc = import_tokenlist10.USDC_TOKEN.extensions?.bridgeInfo?.[chainId]?.tokenAddress || import_tokenlist10.USDC_TOKEN.address;
+  const usdc = import_tokenlist11.USDC_TOKEN.extensions?.bridgeInfo?.[chainId]?.tokenAddress || import_tokenlist11.USDC_TOKEN.address;
   const priceAtBlock = await (0, import_core22.readContract)(wagmiConfig, {
     address: rootPriceOracle,
     abi: import_abis21.rootPriceOracleAbi,
@@ -60842,59 +61116,76 @@ var getEthPriceAtBlock = async (wagmiConfig, blockNumber, chainId) => {
 };
 
 // functions/getRebalanceStats.ts
-var import_utils45 = require("@tokemak/utils");
-var import_tokenlist11 = require("@tokemak/tokenlist");
+var import_utils48 = require("@tokemak/utils");
+var import_tokenlist12 = require("@tokemak/tokenlist");
 var import_chains11 = require("viem/chains");
 var BATCH_SIZE = 500;
 var fetchChainRebalances = async (chainId) => {
-  const { GetAllAutopoolRebalances } = (0, import_graph_cli16.getSdkByChainId)(chainId);
+  const { GetAllAutopoolRebalances } = (0, import_graph_cli17.getSdkByChainId)(chainId);
   const allRebalances = await paginateQuery(
     GetAllAutopoolRebalances,
     "autopoolRebalances"
   );
   if (allRebalances.length === 0) {
-    throw new Error("Could not fetch rebalance values");
+    return [];
   }
   return allRebalances;
 };
-var processRebalance = async (rebalance, chainId, wagmiConfig) => {
+function inferBaseAssetDecimals(rebalance, chainId) {
+  if (BigInt(rebalance.tokenOutValueBaseAsset) === BigInt(rebalance.tokenOutValueInEth)) {
+    return 18;
+  }
+  if (chainId === import_chains11.sonic.id) {
+    return rebalance.tokenOut.decimals;
+  }
+  return import_tokenlist12.USDC_TOKEN.decimals;
+}
+var getRebalanceValueUsd = async (rebalance, chainId, wagmiConfig) => {
+  const ethWei = BigInt(rebalance.tokenOutValueInEth || "0");
+  if (ethWei === 0n)
+    return null;
   try {
-    let valueInUsd = 0;
-    if (chainId === import_chains11.sonic.id) {
-      console.log(rebalance.tokenOutValueBaseAsset);
-      const tokenOutValueInBaseAsset = (0, import_utils45.formatUnitsNum)(
-        BigInt(rebalance.tokenOutValueBaseAsset),
-        import_tokenlist11.USDC_TOKEN.decimals
-      );
-      valueInUsd = tokenOutValueInBaseAsset;
-    } else {
-      const blockNumber = BigInt(rebalance.blockNumber);
-      const price = await getEthPriceAtBlock(
-        wagmiConfig,
-        blockNumber,
-        chainId
-      );
-      const tokenOutValueInEth = (0, import_utils45.formatEtherNum)(
-        BigInt(rebalance.tokenOutValueInEth)
-      );
-      let formattedPrice = (0, import_utils45.formatUnitsNum)(price, import_tokenlist11.USDC_TOKEN.decimals);
-      valueInUsd = tokenOutValueInEth * formattedPrice;
-    }
-    return {
-      timestamp: rebalance.timestamp,
-      blockNumber: rebalance.blockNumber,
-      chainId,
-      valueInUsd
-    };
+    const price = await getEthPriceAtBlock(
+      wagmiConfig,
+      BigInt(rebalance.blockNumber),
+      chainId
+    );
+    const ethUsd = Number((0, import_utils48.formatUnitsNum)(price, import_tokenlist12.USDC_TOKEN.decimals));
+    const ethAmt = Number((0, import_utils48.formatEtherNum)(ethWei));
+    const usd = ethAmt * ethUsd;
+    return usd;
   } catch (e) {
-    console.log(e);
+    console.warn(`WETH/USDC oracle unavailable for chainId: ${chainId}`);
+    return null;
+  }
+};
+var processRebalance = async (rebalance, chainId, wagmiConfig) => {
+  const ethPathUsd = await getRebalanceValueUsd(
+    rebalance,
+    chainId,
+    wagmiConfig
+  );
+  if (ethPathUsd != null) {
     return {
       timestamp: rebalance.timestamp,
       blockNumber: rebalance.blockNumber,
       chainId,
-      valueInUsd: 0
+      valueInUsd: ethPathUsd
     };
   }
+  const baseDecimals = inferBaseAssetDecimals(rebalance, chainId);
+  const baseUsd = Number(
+    (0, import_utils48.formatUnitsNum)(
+      BigInt(rebalance.tokenOutValueBaseAsset || "0"),
+      baseDecimals
+    )
+  );
+  return {
+    timestamp: rebalance.timestamp,
+    blockNumber: rebalance.blockNumber,
+    chainId,
+    valueInUsd: baseUsd
+  };
 };
 var processRebalancesInBatches = async (rebalances, chainId, wagmiConfig) => {
   const processedRebalances = [];
@@ -60978,6 +61269,7 @@ var updateRebalanceStats = async (wagmiConfig, {
   BASE_ASSETS,
   BATCH_SIZE,
   ETH_BASE_ASSETS,
+  EUR_BASE_ASSETS,
   MessageStatus,
   PRICED_TOKENS,
   USD_BASE_ASSETS,
@@ -61032,6 +61324,7 @@ var updateRebalanceStats = async (wagmiConfig, {
   getPoolsAndDestinations,
   getProtocolStats,
   getRebalanceStats,
+  getRebalanceValueUsd,
   getRewardsPayloadV1,
   getSToke,
   getSTokeChainsForEnv,