@scallop-io/sui-scallop-sdk 0.46.53 → 0.46.54

package/dist/index.js

@@ -335,1831 +335,1906 @@ var DEFAULT_CACHE_OPTIONS = {
   }
 };
 
-// src/models/scallopCache.ts
-var ScallopCache = class {
-  constructor(cacheOptions, suiKit) {
-    this.queryClient = new import_query_core.QueryClient(cacheOptions ?? DEFAULT_CACHE_OPTIONS);
-    this._suiKit = suiKit;
+// src/utils/builder.ts
+var requireSender = (txBlock) => {
+  const sender = txBlock.blockData.sender;
+  if (!sender) {
+    throw new Error("Sender is required");
   }
-  get suiKit() {
-    if (!this._suiKit) {
-      throw new Error("SuiKit instance is not initialized");
-    }
-    return this._suiKit;
+  return sender;
+};
+var checkVesca = (prevUnlockAtInMillisTimestamp) => {
+  if (prevUnlockAtInMillisTimestamp === void 0) {
+    throw new Error("veSca not found");
   }
-  /**
-   * @description Invalidate cache based on the refetchType parameter
-   * @param refetchType Determines the type of queries to be refetched. Defaults to `active`.
-   *
-   * - `active`: Only queries that match the refetch predicate and are actively being rendered via useQuery and related functions will be refetched in the background.
-   * - `inactive`: Only queries that match the refetch predicate and are NOT actively being rendered via useQuery and related functions will be refetched in the background.
-   * - `all`: All queries that match the refetch predicate will be refetched in the background.
-   * - `none`: No queries will be refetched. Queries that match the refetch predicate will only be marked as invalid.
-   */
-  invalidateAndRefetchAllCache(refetchType) {
-    return this.queryClient.invalidateQueries({
-      refetchType
-    });
+};
+var checkVescaExpired = (prevUnlockAtInMillisTimestamp) => {
+  if (prevUnlockAtInMillisTimestamp <= (/* @__PURE__ */ new Date()).getTime()) {
+    throw new Error("veSca is expired, use renewExpiredVeScaQuick instead");
   }
-  /**
-   * @description Cache protocol config call for 60 seconds.
-   * @returns Promise<ProtocolConfig>
-   */
-  async getProtocolConfig() {
-    return await this.queryClient.fetchQuery({
-      queryKey: ["getProtocolConfig"],
-      queryFn: async () => {
-        return await this.suiKit.client().getProtocolConfig();
-      },
-      staleTime: 3e4
-    });
+};
+var checkExtendLockPeriod = (lockPeriodInDays, newUnlockAtInSecondTimestamp, prevUnlockAtInMillisTimestamp) => {
+  checkVesca(prevUnlockAtInMillisTimestamp);
+  checkVescaExpired(prevUnlockAtInMillisTimestamp);
+  const prevUnlockAtInSecondTimestamp = Math.floor(
+    prevUnlockAtInMillisTimestamp / 1e3
+  );
+  if (lockPeriodInDays < 1) {
+    throw new Error("Minimum lock period is 1 day");
   }
-  /**
-   * @description Provides cache for inspectTxn of the SuiKit.
-   * @param QueryInspectTxnParams
-   * @param txBlock
-   * @returns Promise<DevInspectResults>
-   */
-  async queryInspectTxn({
-    queryTarget,
-    args,
-    typeArgs
-  }) {
-    const txBlock = new import_sui_kit.SuiTxBlock();
-    const resolvedArgs = await Promise.all(
-      args.map(async (arg) => {
-        if (typeof arg === "string") {
-          return (await this.queryGetObject(arg, { showContent: true })).data;
-        }
-        return arg;
-      })
+  const availableLockPeriodInDays = Math.floor(
+    (newUnlockAtInSecondTimestamp - prevUnlockAtInSecondTimestamp) / UNLOCK_ROUND_DURATION
+  );
+  if (lockPeriodInDays > availableLockPeriodInDays) {
+    throw new Error(
+      `Cannot extend lock period by ${lockPeriodInDays} days, maximum lock period is ~4 years (${MAX_LOCK_ROUNDS} days), remaining lock period is ${MAX_LOCK_ROUNDS - availableLockPeriodInDays}`
     );
-    txBlock.moveCall(queryTarget, resolvedArgs, typeArgs);
-    const txBytes = await txBlock.txBlock.build({
-      client: this.suiKit.client(),
-      onlyTransactionKind: true,
-      protocolConfig: await this.getProtocolConfig()
-    });
-    const query = await this.queryClient.fetchQuery({
-      queryKey: typeArgs ? ["inspectTxn", queryTarget, JSON.stringify(args)] : [
-        "inspectTxn",
-        queryTarget,
-        JSON.stringify(args),
-        JSON.stringify(typeArgs)
-      ],
-      queryFn: async () => {
-        return await this.suiKit.inspectTxn(txBytes);
-      }
-    });
-    return query;
   }
-  /**
-   * @description Provides cache for getObject of the SuiKit.
-   * @param objectId
-   * @param QueryObjectParams
-   * @returns Promise<SuiObjectResponse>
-   */
-  async queryGetObject(objectId, options) {
-    const queryKey = ["getObject", objectId, this.suiKit.currentAddress()];
-    if (options) {
-      queryKey.push(JSON.stringify(options));
-    }
-    return this.queryClient.fetchQuery({
-      queryKey,
-      queryFn: async () => {
-        return await this.suiKit.client().getObject({
-          id: objectId,
-          options
-        });
+};
+var checkLockSca = (scaAmountOrCoin, lockPeriodInDays, newUnlockAtInSecondTimestamp, prevUnlockAtInMillisTimestamp) => {
+  const prevUnlockAtInSecondTimestamp = prevUnlockAtInMillisTimestamp ? Math.floor(prevUnlockAtInMillisTimestamp / 1e3) : void 0;
+  const isInitialLock = !prevUnlockAtInSecondTimestamp;
+  const isLockExpired = !isInitialLock && prevUnlockAtInSecondTimestamp * 1e3 <= (/* @__PURE__ */ new Date()).getTime();
+  if (isInitialLock || isLockExpired) {
+    if (scaAmountOrCoin !== void 0 && lockPeriodInDays !== void 0) {
+      if (lockPeriodInDays <= 0) {
+        throw new Error("Lock period must be greater than 0");
       }
-    });
-  }
-  /**
-   * @description Provides cache for getObjects of the SuiKit.
-   * @param objectIds
-   * @returns Promise<SuiObjectData[]>
-   */
-  async queryGetObjects(objectIds, options) {
-    if (objectIds.length === 0)
-      return [];
-    const queryKey = [
-      "getObjects",
-      JSON.stringify(objectIds),
-      this.suiKit.currentAddress()
-    ];
-    if (options) {
-      queryKey.push(JSON.stringify(options));
-    }
-    return this.queryClient.fetchQuery({
-      queryKey,
-      queryFn: async () => {
-        return await this.suiKit.getObjects(objectIds, options);
+      if (typeof scaAmountOrCoin === "number" && scaAmountOrCoin < MIN_INITIAL_LOCK_AMOUNT) {
+        throw new Error(
+          `Minimum lock amount for ${isLockExpired ? "renewing expired veSca" : "initial lock"} is 10 SCA`
+        );
       }
-    });
-  }
-  /**
-   * @description Provides cache for getOwnedObjects of the SuiKit.
-   * @param input
-   * @returns Promise<PaginatedObjectsResponse>
-   */
-  async queryGetOwnedObjects(input) {
-    const queryKey = ["getOwnedObjects", input.owner];
-    if (input.cursor) {
-      queryKey.push(JSON.stringify(input.cursor));
-    }
-    if (input.options) {
-      queryKey.push(JSON.stringify(input.options));
+      const extendLockPeriodInSecond = lockPeriodInDays * UNLOCK_ROUND_DURATION;
+      if (extendLockPeriodInSecond > MAX_LOCK_DURATION) {
+        throw new Error(
+          `Maximum lock period is ~4 years (${MAX_LOCK_ROUNDS} days)`
+        );
+      }
+    } else {
+      throw new Error(
+        `SCA amount and lock period is required for ${isLockExpired ? "renewing expired veSca" : "initial lock"}`
+      );
     }
-    if (input.filter) {
-      queryKey.push(JSON.stringify(input.filter));
+  } else {
+    checkVesca(prevUnlockAtInMillisTimestamp);
+    checkVescaExpired(prevUnlockAtInMillisTimestamp);
+    if (typeof scaAmountOrCoin === "number" && scaAmountOrCoin < MIN_TOP_UP_AMOUNT) {
+      throw new Error("Minimum top up amount is 1 SCA");
     }
-    if (input.limit) {
-      queryKey.push(JSON.stringify(input.limit));
+    if (newUnlockAtInSecondTimestamp && lockPeriodInDays) {
+      checkExtendLockPeriod(
+        lockPeriodInDays,
+        newUnlockAtInSecondTimestamp,
+        prevUnlockAtInMillisTimestamp
+      );
     }
-    return this.queryClient.fetchQuery({
-      queryKey,
-      queryFn: async () => {
-        return await this.suiKit.client().getOwnedObjects(input);
-      }
-    });
   }
-  async queryGetDynamicFields(input) {
-    const queryKey = ["getDynamicFields", input.parentId];
-    if (input.cursor) {
-      queryKey.push(JSON.stringify(input.cursor));
-    }
-    if (input.limit) {
-      queryKey.push(JSON.stringify(input.limit));
-    }
-    return this.queryClient.fetchQuery({
-      queryKey,
-      queryFn: async () => {
-        return await this.suiKit.client().getDynamicFields(input);
-      }
-    });
+};
+var checkExtendLockAmount = (scaAmount, prevUnlockAtInMillisTimestamp) => {
+  checkVesca(prevUnlockAtInMillisTimestamp);
+  checkVescaExpired(prevUnlockAtInMillisTimestamp);
+  if (scaAmount < MIN_TOP_UP_AMOUNT) {
+    throw new Error("Minimum top up amount is 1 SCA");
   }
-  async queryGetDynamicFieldObject(input) {
-    const queryKey = [
-      "getDynamicFieldObject",
-      input.parentId,
-      input.name.type,
-      input.name.value
-    ];
-    return this.queryClient.fetchQuery({
-      queryKey,
-      queryFn: async () => {
-        return await this.suiKit.client().getDynamicFieldObject(input);
-      }
-    });
+  const isInitialLock = !prevUnlockAtInMillisTimestamp;
+  const isLockExpired = !isInitialLock && prevUnlockAtInMillisTimestamp <= (/* @__PURE__ */ new Date()).getTime();
+  if (isLockExpired) {
+    throw new Error("veSca is expired, use renewExpiredVeScaQuick instead");
   }
-  async queryGetAllCoinBalances(owner) {
-    const queryKey = ["getAllCoinBalances", owner];
-    return this.queryClient.fetchQuery({
-      queryKey,
-      queryFn: async () => {
-        const allBalances = await this.suiKit.client().getAllBalances({ owner });
-        const balances = allBalances.reduce(
-          (acc, coinBalance) => {
-            if (coinBalance.totalBalance !== "0") {
-              acc[(0, import_sui_kit.normalizeStructTag)(coinBalance.coinType)] = coinBalance.totalBalance;
-            }
-            return acc;
-          },
-          {}
-        );
-        for (const coinType in balances) {
-          const coinBalanceQueryKey = [
-            "getCoinBalance",
-            (0, import_sui_kit.normalizeSuiAddress)(owner),
-            (0, import_sui_kit.normalizeStructTag)(coinType)
-          ];
-          this.queryClient.setQueryData(
-            coinBalanceQueryKey,
-            balances[coinType]
-          );
-        }
-        return balances;
-      }
-    });
+};
+var checkRenewExpiredVeSca = (scaAmount, lockPeriodInDays, prevUnlockAtInMillisTimestamp) => {
+  if (!prevUnlockAtInMillisTimestamp || prevUnlockAtInMillisTimestamp > (/* @__PURE__ */ new Date()).getTime()) {
+    throw new Error("Renew method can only be used for expired veSca");
   }
-  async queryGetCoinBalance(input) {
-    if (!input.coinType)
-      return "0";
-    const queryKey = [
-      "getCoinBalance",
-      (0, import_sui_kit.normalizeSuiAddress)(input.owner),
-      (0, import_sui_kit.normalizeStructTag)(input.coinType)
-    ];
-    return this.queryClient.fetchQuery({
-      queryKey,
-      queryFn: async () => {
-        if (!input.coinType)
-          return "0";
-        return (await this.queryGetAllCoinBalances(input.owner))[(0, import_sui_kit.normalizeStructTag)(input.coinType)] ?? "0";
-      }
-    });
+  if (scaAmount < MIN_INITIAL_LOCK_AMOUNT) {
+    throw new Error("Minimum lock amount for renewing expired vesca 10 SCA");
+  }
+  const extendLockPeriodInSecond = lockPeriodInDays * UNLOCK_ROUND_DURATION;
+  if (extendLockPeriodInSecond >= MAX_LOCK_DURATION - UNLOCK_ROUND_DURATION) {
+    throw new Error(
+      `Maximum lock period is ~4 years (${MAX_LOCK_ROUNDS - 1} days)`
+    );
   }
 };
 
-// src/models/scallopAddress.ts
-var import_axios = __toESM(require("axios"));
-
-// src/constants/testAddress.ts
-var TEST_ADDRESSES = {
-  core: {
-    // version:
-    //   '0x07871c4b3c847a0f674510d4978d5cf6f960452795e8ff6f189fd2088a3f6ac7',
-    version: "0x6156d5cd1538bec8a167a40fe1209a4ec9cf8137921fe0a697f191ac561f0b09",
-    versionCap: "0x590a4011cb649b3878f3ea14b3a78674642a9548d79b7e091ef679574b158a07",
-    // object:
-    //   '0xefe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf',
-    object: "0x87ddec2984645dbbe2403a509cc6edf393a43acdba9b77d45da2bcbefcf733c1",
-    // market:
-    //   '0xa757975255146dc9686aa823b7838b507f315d704f428cbadad2f4ea061939d9',
-    market: "0x8606ed145cc887985b8ed793f7753ff5dc762a42c379dac035f568e1bac58490",
-    adminCap: "0x09689d018e71c337d9db6d67cbca06b74ed92196103624028ccc3ecea411777c",
-    coinDecimalsRegistry: "0x200abe9bf19751cc566ae35aa58e2b7e4ff688fc1130f8d8909ea09bc137d668",
-    // obligationAccessStore:
-    //   '0x733e30b7c94d619d78cb8f5bc4bfbb759ced9a531239028caabb2474e5be59c9',
-    obligationAccessStore: "0x48b472d68ca910c45f7f3b6c26836b6aa6d2569810d94b1b939023da05ae0a23",
-    coins: {
-      cetus: {
-        id: "0x06864a6f921804860930db6ddbe2e16acdf8504495ea7481637a1c8b9a8fe54b",
-        metaData: "0x4c0dce55eff2db5419bbd2d239d1aa22b4a400c01bbb648b058a9883989025da",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "e5b274b2611143df055d6e7cd8d93fe1961716bcd4dca1cad87a83bc1e78c1ef",
-            feedObject: "0x24c0247fb22457a719efac7f670cdc79be321b521460bd6bd2ccfa9f80713b14"
-          }
-        }
-      },
-      apt: {
-        id: "0x3a5143bb1196e3bcdfab6203d1683ae29edd26294fc8bfeafe4aaa9d2704df37",
-        metaData: "0xc969c5251f372c0f34c32759f1d315cf1ea0ee5e4454b52aea08778eacfdd0a8",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "03ae4db29ed4ae33d323568895aa00337e658e348b37509f5372ae51f0af00d5",
-            feedObject: "0x7c5b7837c44a69b469325463ac0673ac1aa8435ff44ddb4191c9ae380463647f"
-          }
-        }
-      },
-      sol: {
-        id: "0xb7844e289a8410e50fb3ca48d69eb9cf29e27d223ef90353fe1bd8e27ff8f3f8",
-        metaData: "0x4d2c39082b4477e3e79dc4562d939147ab90c42fc5f3e4acf03b94383cd69b6e",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "ef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d",
-            feedObject: "0x9d0d275efbd37d8a8855f6f2c761fa5983293dd8ce202ee5196626de8fcd4469"
-          }
-        }
-      },
-      btc: {
-        id: "0x027792d9fed7f9844eb4839566001bb6f6cb4804f66aa2da6fe1ee242d896881",
-        metaData: "0x5d3c6e60eeff8a05b693b481539e7847dfe33013e7070cdcb387f5c0cac05dfd",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "e62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43",
-            feedObject: "0x9a62b4863bdeaabdc9500fce769cf7e72d5585eeb28a6d26e4cafadc13f76ab2"
-          }
-        }
-      },
-      eth: {
-        id: "0xaf8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5",
-        metaData: "0x8900e4ceede3363bef086d6b50ca89d816d0e90bf6bc46efefe1f8455e08f50f",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "ff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace",
-            feedObject: "0x9193fd47f9a0ab99b6e365a464c8a9ae30e6150fc37ed2a89c1586631f6fc4ab"
-          }
-        }
-      },
-      usdc: {
-        id: "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf",
-        metaData: "0x4fbf84f3029bd0c0b77164b587963be957f853eccf834a67bb9ecba6ec80f189",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "eaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a",
-            feedObject: "0x5dec622733a204ca27f5a90d8c2fad453cc6665186fd5dff13a83d0b6c9027ab"
-          }
-        }
-      },
-      usdt: {
-        id: "0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c",
-        metaData: "0xfb0e3eb97dd158a5ae979dddfa24348063843c5b20eb8381dd5fa7c93699e45c",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "2b89b9dc8fdf9f34709a5b106b472f0f39bb6ca9ce04b0fd7f2e971688e2e53b",
-            feedObject: "0x985e3db9f93f76ee8bace7c3dd5cc676a096accd5d9e09e9ae0fb6e492b14572"
-          }
-        }
-      },
-      sui: {
-        id: "0x0000000000000000000000000000000000000000000000000000000000000002",
-        metaData: "0x9258181f5ceac8dbffb7030890243caed69a9599d2886d957a9cb7656af3bdb3",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "0xbca474133638352ba83ccf7b5c931d50f764b09550e16612c9f70f1e21f3f594",
-          pyth: {
-            feed: "23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744",
-            feedObject: "0x801dbc2f0053d34734814b2d6df491ce7807a725fe9a01ad74a07e9c51396c37"
-          }
-        }
-      },
-      afsui: {
-        id: "0xf325ce1300e8dac124071d3152c5c5ee6174914f8bc2161e88329cf579246efc",
-        metaData: "0x2f9217f533e51334873a39b8026a4aa6919497b47f49d0986a4f1aec66f8a34d",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744",
-            feedObject: "0x801dbc2f0053d34734814b2d6df491ce7807a725fe9a01ad74a07e9c51396c37"
-          }
-        }
-      },
-      hasui: {
-        id: "0xbde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d",
-        metaData: "0x2c5f33af93f6511df699aaaa5822d823aac6ed99d4a0de2a4a50b3afa0172e24",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744",
-            feedObject: "0x801dbc2f0053d34734814b2d6df491ce7807a725fe9a01ad74a07e9c51396c37"
-          }
-        }
-      },
-      vsui: {
-        id: "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55",
-        metaData: "0xabd84a23467b33854ab25cf862006fd97479f8f6f53e50fe732c43a274d939bd",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744",
-            feedObject: "0x801dbc2f0053d34734814b2d6df491ce7807a725fe9a01ad74a07e9c51396c37"
-          }
-        }
-      },
-      sca: {
-        id: "0x7016aae72cfc67f2fadf55769c0a7dd54291a583b63051a5ed71081cce836ac6",
-        metaData: "0x5d26a1e9a55c88147ac870bfa31b729d7f49f8804b8b3adfdf3582d301cca844",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "7e17f0ac105abe9214deb9944c30264f5986bf292869c6bd8e8da3ccd92d79bc",
-            feedObject: "0xf6de1d3279a269a597d813cbaca59aa906543ab9a8c64e84a4722f1a20863985"
-          }
-        }
-      }
-    },
-    oracles: {
-      xOracle: "0x93d5bf0936b71eb27255941e532fac33b5a5c7759e377b4923af0a1359ad494f",
-      xOracleCap: "0x1edeae568fde99e090dbdec4bcdbd33a15f53a1ce1f87aeef1a560dedf4b4a90",
-      supra: { registry: "", registryCap: "", holder: "" },
-      switchboard: { registry: "", registryCap: "" },
-      pyth: {
-        registry: "0xedc293f9413a5a7a5d53bdba1fd889d0a4030894469228f0acdae4aa3c55a213",
-        registryCap: "0xbcb07141eb1f7e01fbda4130ecf5f5adaeabb77f5d9c32158b7532bcd2197acd",
-        state: "0x1f9310238ee9298fb703c3419030b35b22bb1cc37113e3bb5007c99aec79e5b8",
-        wormhole: "0x5306f64e312b581766351c07af79c72fcb1cd25147157fdc2f8ad76de9a3fb6a",
-        wormholeState: "0xaeab97f96cf9877fee2883315d459552b2b921edc16d7ceac6eab944dd88919c"
-      }
-    },
-    packages: {
-      coinDecimalsRegistry: {
-        id: "0xca5a5a62f01c79a104bf4d31669e29daa387f325c241de4edbe30986a9bc8b0d",
-        upgradeCap: "0x34e76a945d29f195bc53ca704fa70877d1cf3a5d7bbfdda1b13e633fff13c0f6"
-      },
-      math: {
-        id: "0xad013d5fde39e15eabda32b3dbdafd67dac32b798ce63237c27a8f73339b9b6f",
-        upgradeCap: "0x3a329598231de02e6135c62284b66005b41cad1d9ab7ca2dc79c08293aba2ec6"
-      },
-      whitelist: {
-        id: "0x1318fdc90319ec9c24df1456d960a447521b0a658316155895014a6e39b5482f",
-        upgradeCap: "0xf5a22aea23db664f7b69855b6a546747f17c1ec4230319cfc17225e462b05761"
-      },
-      x: {
-        id: "0x779b5c547976899f5474f3a5bc0db36ddf4697ad7e5a901db0415c2281d28162",
-        upgradeCap: "0x3f203f6fff6a69d151e4f1cd931f22b68c489ef2759765662fc7baf673943c9e"
-      },
-      protocol: {
-        id: "0x87ddec2984645dbbe2403a509cc6edf393a43acdba9b77d45da2bcbefcf733c1",
-        upgradeCap: "0x38527d154618d1fd5a644b90717fe07cf0e9f26b46b63e9568e611a3f86d5c1a"
-      },
-      // protocol: {
-      //   id: '0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e',
-      //   upgradeCap:
-      //     '0x38527d154618d1fd5a644b90717fe07cf0e9f26b46b63e9568e611a3f86d5c1a',
-      // },
-      protocolWhitelist: {
-        id: "0x4c262d9343dac53ecb28f482a2a3f62c73d0ebac5b5f03d57383d56ff219acdf",
-        upgradeCap: "0x4a5e88a75039b00988f633f811f58117f31b8627a46bf822aa114d9010049449"
-      },
-      // query: {
-      //   id: '0xb8d603a39114a5efef3dd0bf84df0bed1be1fbd39b78b7dd6e8a61ccc5e6006f',
-      //   upgradeCap:
-      //     '0x0d535c35f608b9b01b7ccce11acf43b1dd80c1b72bf8b541744a6e28e8d2745f',
-      // },
-      query: {
-        id: "0xe4f9d62d17746d5b9dbf0d5557747430021a71575780b515161210cdba0a4c1c",
-        upgradeCap: "0x0d535c35f608b9b01b7ccce11acf43b1dd80c1b72bf8b541744a6e28e8d2745f"
-      },
-      supra: { id: "", upgradeCap: "" },
-      pyth: {
-        id: "0x910f30cbc7f601f75a5141a01265cd47c62d468707c5e1aecb32a18f448cb25a",
-        upgradeCap: "0xdf0ffbae1ea5bb25fbca5efba433dcf00c7cced65679af2f04728901275c6157"
-      },
-      switchboard: { id: "", upgradeCap: "" },
-      xOracle: {
-        id: "0x1478a432123e4b3d61878b629f2c692969fdb375644f1251cd278a4b1e7d7cd6",
-        upgradeCap: "0x0f928a6b2e26b73330fecaf9b44acfc9800a4a9794d6415c2a3153bc70e3c1f0"
-      },
-      testCoin: { id: "", upgradeCap: "" }
-    }
-  },
-  spool: {
-    // id: '0x7c4fdabe81c31b19a45d1e572a52a539997a90903fbb5bfab71480abe0fa62c3',
-    id: "0x1742655fe5872dfa6456673f9e38612a4965e6979e6cd7696a7f1225f28bae21",
-    adminCap: "0xdd8a047cbbf802bfcde5288b8ef1910965d789cc614da11d39af05fca0bd020a",
-    // object:
-    //   '0xe87f1b2d498106a2c61421cec75b7b5c5e348512b0dc263949a0e7a3c256571a',
-    object: "0x1742655fe5872dfa6456673f9e38612a4965e6979e6cd7696a7f1225f28bae21",
-    pools: {
-      seth: {
-        id: "0xeec40beccb07c575bebd842eeaabb835f77cd3dab73add433477e57f583a6787",
-        rewardPoolId: "0x957de68a18d87817de8309b30c1ec269a4d87ae513abbeed86b5619cb9ce1077"
-      },
-      ssui: {
-        // id: '0x4f0ba970d3c11db05c8f40c64a15b6a33322db3702d634ced6536960ab6f3ee4',
-        id: "0xb9617f83c06ebdeac0a8834782b1015e1cc7ea23739e30c132c4bfb95c37a579",
-        rewardPoolId: (
-          // '0x162250ef72393a4ad3d46294c4e1bdfcb03f04c869d390e7efbfc995353a7ee9',
-          "0xc3206071a8d43212efb6e3b5504f2321f8df97ab122b466c0bc7cfdf398dc13a"
-        )
-      },
-      susdc: {
-        // id: '0x4ace6648ddc64e646ba47a957c562c32c9599b3bba8f5ac1aadb2ae23a2f8ca0',
-        id: "0xf1b383b9cf2e9f515fc69567df1053098f273849d09cd84b0278a773429bd2b2",
-        rewardPoolId: (
-          // '0xf4268cc9b9413b9bfe09e8966b8de650494c9e5784bf0930759cfef4904daff8',
-          "0xc71c53ee6505d928ba15bea4fe4f45d98c9c31eced94b72d00a7827d4b7ba3ff"
-        )
-      },
-      susdt: {
-        // id: '0xcb328f7ffa7f9342ed85af3fdb2f22919e1a06dfb2f713c04c73543870d7548f',
-        id: "0xb5567dfa5c7fc17a249e959732664c50713dd8c23db1a11376b27df800c17418",
-        rewardPoolId: (
-          // '0x2c9f934d67a5baa586ceec2cc24163a2f049a6af3d5ba36b84d8ac40f25c4080',
-          "0x60768b0687ff0235e376a039709a683e4c436098785e473b67b32dbab47b69ab"
-        )
-      },
-      scetus: {
-        id: "0xac1bb13bf4472a637c18c2415fb0e3c1227ea2bcf35242e50563c98215bd298e",
-        rewardPoolId: "0x6835c1224126a45086fc6406adc249e3f30df18d779ca4f4e570e38716a17f3f"
-      },
-      safsui: {
-        // id: '0xeedf438abcaa6ce4d9625ffca110920592d5867e4c5637d84ad9f466c4feb800',
-        id: "0xc568bb4c991258e839aa54802ecda04fcd9838c826bc3b42b40af81b23c458c8",
-        rewardPoolId: (
-          // '0x89255a2f86ed7fbfef35ab8b7be48cc7667015975be2685dd9a55a9a64baf76e',
-          "0x389a3cbeda742b918941bb24fd00e077bad3367484394d6234f8209b9a6aa03d"
-        )
-      },
-      shasui: {
-        // id: '0xa6148bc1b623e936d39a952ceb5bea79e8b37228a8f595067bf1852efd3c34aa',
-        id: "0x93f3f4499bf89f2d05ddc1f8b15f51701a7c6c4d0ac0b9c3bc99462cbbd8e321",
-        rewardPoolId: (
-          // '0x6f3563644d3e2ef13176dbf9d865bd93479df60ccbe07b7e66db57f6309f5a66',
-          "0x94cee1be7f5ff34193f3aabef0b14142cb28af4d905fe487a9a7d85a15edb6aa"
-        )
-      },
-      svsui: {
-        // id: '0x69ce8e537e750a95381e6040794afa5ab1758353a1a2e1de7760391b01f91670',
-        id: "0xa970e9087f80cb59e9299b8e7af7175d977ad6c9af0322aa4440e138fbd7ae00",
-        rewardPoolId: (
-          // '0xbca914adce058ad0902c7f3cfcd698392a475f00dcfdc3f76001d0370b98777a',
-          "0x38eee9699c4fc132a6623e54b865f047df4fc6eb83af807300f44e8f4b235ff0"
-        )
-      }
-    },
-    config: ""
-  },
-  borrowIncentive: {
-    id: "0x6152f696fc3a658f33c4b891764731a59153125ffedfa8bff7167c42823f58a9",
-    adminCap: "0xc486afa253646f4d381e81d7f1df8aa4723b845a6bb356f69bad635ffefffe2c",
-    object: "0x002875153e09f8145ab63527bc85c00f2bd102e12f9573c47f8cdf1a1cb62934",
-    query: "0x529edc54a3dce2207703ceebbccb0ac14133f7825c1f528775ba0d85a4063489",
-    incentivePools: "0x6547e143d406b5ccd5f46aae482497de279cc1a68c406f701df70a05f9212ab4",
-    incentiveAccounts: "0xc4701fdbc1c92f9a636d334d66012b3027659e9fb8aff27279a82edfb6b77d02",
-    config: "0xdf5d04b4691cc67e82fd4db8394d89ff44823a9de29716c924f74bb4f11cc1f7"
-  },
-  referral: {
-    id: "0xa3654ebb63eb06c0f4ff52f8aa6512df9f164f7772bdf15dac3709bd3798dda9",
-    object: "0x5658d4bf5ddcba27e4337b4262108b3ad1716643cac8c2054ac341538adc72ec",
-    adminCap: "0xc5dc06b9074291259f2cac460c940012c781c4430e42125c541cc43101c3bcbd",
-    referralBindings: "0xf63299d58789d99de94092b9011323466e55ca0c1ea1a7a3786a589af46e1c09",
-    bindingTableId: "0x1c8202b17267ec8d6cf97ca013615354181a04f179570e42601ff2dae19294b1",
-    referralRevenuePool: "0x6abd852caf90769c1b185cdf636d841673fa95528f0550f018b8a138bd283c07",
-    revenueTableId: "0x595baa3654c297bff84ab7786a2d250f019cefc66e8df8e89fd9d41e02bd30dd",
-    referralTiers: "0x962cb903d8d7346190c5204785ccbb91b61086aa764f674c8145df82335cf83e",
-    tiersTableId: "0xeac755a7a8b7798530905ac79e8c114f19d0f130f6eab012954f08faac29c75d",
-    // authorizedWitnessList:
-    //   '0xf21b0ed043c9bb70842c0129159f4943dbcc3c9ef2f2f808af65f8be25cfd20e',
-    authorizedWitnessList: "0x9d6223dc52015b8a3986a573590ef2af8f1b8f3e4685513888c052f001b87e7f",
-    version: "0x1bd4b7285f72e11c316b828c7c47b3f4da18dcec9f9b3dba6d8629cbb6f93e5e"
-  },
-  vesca: {
-    id: "0xb15b6e0cdd85afb5028bea851dd249405e734d800a259147bbc24980629723a4",
-    object: "0xb15b6e0cdd85afb5028bea851dd249405e734d800a259147bbc24980629723a4",
-    adminCap: "0x8ffa76135c5b85c5fbd73a6448a4a733d826cb63a267ab817656acb77c72d4a5",
-    tableId: "0xe3153b2bf124be0b86cb8bd468346a861efd0da52fc42197b54d2f616488a311",
-    table: "0x611cb8d9d4d90867467b5ebdf4cc447a0047ed5b01334a28a29fcfe733e3d609",
-    treasury: "0xe8c112c09b88158dc6c8e23d1fbae5b3c7136cdee54b7dafc08e65db28c4a5bc",
-    config: "0xe0a2ff281e73c1d53cfa85807080f87e833e4f1a7f93dcf8800b3865269a76b9"
-  },
-  loyaltyProgram: {
-    id: "0xd17bcf8b5a59652c36225d478564a8593ae0ed7d650bcacdda1d6fe179127907",
-    object: "0xd17bcf8b5a59652c36225d478564a8593ae0ed7d650bcacdda1d6fe179127907",
-    rewardPool: "0xf9c090492ef476bd542109d0913ffe871cbfa28578b7114eca2a8c0e5671786f",
-    userRewardTableId: "0x748a80395849ed37db1b0e14f2ab5d1d96458d2359ab3a84eb079d0f4ac7cf2e"
-  },
-  scoin: {
-    id: "0xad2ca2aa5089df94bb2d444d5eb3520378c2f2dfb3a0bd2a2c994145ac4b0a53",
-    coins: {
-      ssui: {
-        coinType: "0xfac769100bccc0caebcf4f4e2d00ac2f8883f07f724be28940df90605f5e7e9a::scallop_sui::SCALLOP_SUI",
-        treasury: "0x9cb4551b36c17d37e19d700147fa819ea1c487ff8bcf18374de2cceb2e9d4845"
-      },
-      scetus: {
-        coinType: "0x8b71e6d323ed78515af2bead13bf3d0da1562ba4a99234eb7c4f14fd39ef0427::scallop_cetus::SCALLOP_CETUS",
-        treasury: "0xd786f4b2d26278cc7911a3445b1b085eab60f269ef9dbb6b87e803d52f155003"
-      },
-      ssca: {
-        coinType: "0x0a9d3c6c9af9f6e8def82921541bcbd17f73ed31bed3adcb684f2a4c267e42f0::scallop_sca::SCALLOP_SCA",
-        treasury: "0xe818636d1d6c46d6ea1a2dce9d94696d7cbc18ce27451b603eeaa47aba8d75e0"
-      },
-      susdc: {
-        coinType: "0xaedc3ab75db8680b81a755015fa90124d217be93457b893c05bac033817defaf::scallop_wormhole_usdc::SCALLOP_WORMHOLE_USDC",
-        treasury: "0xfc6971648f867f7fd6928d1b873af71577e2eaf2c7543ef8bc82c431d833ae78"
-      },
-      susdt: {
-        coinType: "0xbf02fc87ddc104b342ad8414c85ceadf5b0c823c055a06fb0ed776272c01a52a::scallop_wormhole_usdt::SCALLOP_WORMHOLE_USDT",
-        treasury: "0xb9593e2c3a0ba796ee815012b75ae46468ea78cda0188b9ac6816efe65503521"
-      },
-      seth: {
-        coinType: "0x27d54f43e3eda701be56b82e5756e41c84467cd202f5cf713d5f9e45a9f1b6bc::scallop_wormhole_eth::SCALLOP_WORMHOLE_ETH",
-        treasury: "0x032b4c8fac94c038dbe986f7587e9b1e4ef580b5ee06d2ef249d85459b7ef05d"
-      },
-      safsui: {
-        coinType: "0xb75b46d975d8d80670b53a6bee90baaa8ce2e0b7d397f079447d641eef6b44ad::scallop_af_sui::SCALLOP_AF_SUI",
-        treasury: "0x21450ef0570ef3d224ffa3b873ab802e439ece7b93cc7efad10ae0c1e3b3fcfe"
-      },
-      shasui: {
-        coinType: "0xd973a723874e2c7cde196602a79155a1343a933f8cf87d9b1bb7408bc1acbc58::scallop_ha_sui::SCALLOP_HA_SUI",
-        treasury: "0xf822fc1402207e47d2e3ba8ff6e1e594bf1de777dc5ebd2744619cd2726e3b0d"
-      },
-      svsui: {
-        coinType: "0x97023a317320c4498cc4cd239dd02fd30c28246e5e8f81325d63f2bd8d70f6b3::scallop_v_sui::SCALLOP_V_SUI",
-        treasury: "0x327114f0bf3559d7e2de10282147ed76a236c7c6775029165c4db09a6062ead6\u0192"
-      }
-    }
-  }
+// src/utils/query.ts
+var import_bignumber = __toESM(require("bignumber.js"));
+var import_utils = require("@mysten/sui.js/utils");
+var parseOriginMarketPoolData = (originMarketPoolData) => {
+  return {
+    coinType: (0, import_utils.normalizeStructTag)(originMarketPoolData.type.name),
+    // Parse origin data required for basic calculations.
+    maxBorrowRate: Number(originMarketPoolData.maxBorrowRate.value) / 2 ** 32,
+    borrowRate: Number(originMarketPoolData.interestRate.value) / 2 ** 32,
+    borrowRateScale: Number(originMarketPoolData.interestRateScale),
+    borrowIndex: Number(originMarketPoolData.borrowIndex),
+    lastUpdated: Number(originMarketPoolData.lastUpdated),
+    cashAmount: Number(originMarketPoolData.cash),
+    debtAmount: Number(originMarketPoolData.debt),
+    marketCoinSupplyAmount: Number(originMarketPoolData.marketCoinSupply),
+    reserveAmount: Number(originMarketPoolData.reserve),
+    reserveFactor: Number(originMarketPoolData.reserveFactor.value) / 2 ** 32,
+    borrowWeight: Number(originMarketPoolData.borrowWeight.value) / 2 ** 32,
+    borrowFee: Number(originMarketPoolData.borrowFeeRate.value) / 2 ** 32,
+    // Parse origin data required for additional display.
+    baseBorrowRate: Number(originMarketPoolData.baseBorrowRatePerSec.value) / 2 ** 32,
+    borrowRateOnHighKink: Number(originMarketPoolData.borrowRateOnHighKink.value) / 2 ** 32,
+    borrowRateOnMidKink: Number(originMarketPoolData.borrowRateOnMidKink.value) / 2 ** 32,
+    highKink: Number(originMarketPoolData.highKink.value) / 2 ** 32,
+    midKink: Number(originMarketPoolData.midKink.value) / 2 ** 32,
+    minBorrowAmount: Number(originMarketPoolData.minBorrowAmount)
+  };
 };
-
-// src/models/scallopAddress.ts
-var EMPTY_ADDRESSES = {
-  core: {
-    version: "",
-    versionCap: "",
-    object: "",
-    market: "",
-    adminCap: "",
-    coinDecimalsRegistry: "",
-    obligationAccessStore: "",
-    coins: {
-      cetus: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
-          }
-        }
-      },
-      apt: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
-          }
-        }
-      },
-      sol: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
-          }
-        }
-      },
-      btc: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
-          }
-        }
-      },
-      eth: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
-          }
-        }
+var calculateMarketPoolData = (utils, parsedMarketPoolData) => {
+  const poolCoinName = utils.parseCoinNameFromType(
+    parsedMarketPoolData.coinType
+  );
+  const coinDecimal = utils.getCoinDecimal(poolCoinName);
+  const borrowYearFactor = 24 * 365 * 3600;
+  const baseBorrowApr = parsedMarketPoolData.baseBorrowRate * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
+  const borrowAprOnHighKink = parsedMarketPoolData.borrowRateOnHighKink * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
+  const borrowAprOnMidKink = parsedMarketPoolData.borrowRateOnMidKink * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
+  const maxBorrowApr = parsedMarketPoolData.maxBorrowRate * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
+  const borrowApr = parsedMarketPoolData.borrowRate * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
+  const timeDelta = Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedMarketPoolData.lastUpdated;
+  const borrowIndexDelta = (0, import_bignumber.default)(parsedMarketPoolData.borrowIndex).multipliedBy(
+    (0, import_bignumber.default)(timeDelta).multipliedBy(parsedMarketPoolData.borrowRate)
+  ).dividedBy(parsedMarketPoolData.borrowRateScale);
+  const currentBorrowIndex = (0, import_bignumber.default)(parsedMarketPoolData.borrowIndex).plus(
+    borrowIndexDelta
+  );
+  const growthInterest = (0, import_bignumber.default)(currentBorrowIndex).dividedBy(parsedMarketPoolData.borrowIndex).minus(1);
+  const increasedDebtAmount = (0, import_bignumber.default)(
+    parsedMarketPoolData.debtAmount
+  ).multipliedBy(growthInterest);
+  const borrowAmount = increasedDebtAmount.plus(
+    parsedMarketPoolData.debtAmount
+  );
+  const borrowCoin = borrowAmount.shiftedBy(-1 * coinDecimal);
+  const reserveAmount = (0, import_bignumber.default)(parsedMarketPoolData.reserveAmount).plus(
+    increasedDebtAmount.multipliedBy(parsedMarketPoolData.reserveFactor)
+  );
+  const reserveCoin = reserveAmount.shiftedBy(-1 * coinDecimal);
+  const supplyAmount = (0, import_bignumber.default)(borrowAmount).plus(
+    Math.max(parsedMarketPoolData.cashAmount - reserveAmount.toNumber(), 0)
+  );
+  const supplyCoin = supplyAmount.shiftedBy(-1 * coinDecimal);
+  let utilizationRate = (0, import_bignumber.default)(borrowAmount).dividedBy(supplyAmount);
+  utilizationRate = utilizationRate.isFinite() ? utilizationRate : (0, import_bignumber.default)(0);
+  let supplyApr = (0, import_bignumber.default)(borrowApr).multipliedBy(utilizationRate).multipliedBy(1 - parsedMarketPoolData.reserveFactor);
+  supplyApr = supplyApr.isFinite() ? supplyApr : (0, import_bignumber.default)(0);
+  let conversionRate = supplyAmount.dividedBy(
+    parsedMarketPoolData.marketCoinSupplyAmount
+  );
+  conversionRate = conversionRate.isFinite() && !conversionRate.isNaN() ? conversionRate : (0, import_bignumber.default)(1);
+  return {
+    baseBorrowApr,
+    baseBorrowApy: utils.parseAprToApy(baseBorrowApr),
+    borrowAprOnHighKink,
+    borrowApyOnHighKink: utils.parseAprToApy(borrowAprOnHighKink),
+    borrowAprOnMidKink,
+    borrowApyOnMidKink: utils.parseAprToApy(borrowAprOnMidKink),
+    maxBorrowApr,
+    maxBorrowApy: utils.parseAprToApy(maxBorrowApr),
+    borrowApr: Math.min(borrowApr, maxBorrowApr),
+    borrowApy: Math.min(
+      utils.parseAprToApy(borrowApr),
+      utils.parseAprToApy(maxBorrowApr)
+    ),
+    borrowIndex: currentBorrowIndex.toNumber(),
+    growthInterest: growthInterest.toNumber(),
+    supplyAmount: supplyAmount.toNumber(),
+    supplyCoin: supplyCoin.toNumber(),
+    borrowAmount: borrowAmount.toNumber(),
+    borrowCoin: borrowCoin.toNumber(),
+    reserveAmount: reserveAmount.toNumber(),
+    reserveCoin: reserveCoin.toNumber(),
+    utilizationRate: utilizationRate.toNumber(),
+    supplyApr: supplyApr.toNumber(),
+    supplyApy: utils.parseAprToApy(supplyApr.toNumber()),
+    conversionRate: conversionRate.toNumber()
+  };
+};
+var parseOriginMarketCollateralData = (originMarketCollateralData) => {
+  const divisor = 2 ** 32;
+  return {
+    coinType: (0, import_utils.normalizeStructTag)(originMarketCollateralData.type.name),
+    collateralFactor: Number(originMarketCollateralData.collateralFactor.value) / divisor,
+    liquidationFactor: Number(originMarketCollateralData.liquidationFactor.value) / divisor,
+    liquidationDiscount: Number(originMarketCollateralData.liquidationDiscount.value) / divisor,
+    liquidationPanelty: Number(originMarketCollateralData.liquidationPanelty.value) / divisor,
+    liquidationReserveFactor: Number(originMarketCollateralData.liquidationReserveFactor.value) / divisor,
+    maxCollateralAmount: Number(originMarketCollateralData.maxCollateralAmount),
+    totalCollateralAmount: Number(
+      originMarketCollateralData.totalCollateralAmount
+    )
+  };
+};
+var calculateMarketCollateralData = (utils, parsedMarketCollateralData) => {
+  const collateralCoinName = utils.parseCoinNameFromType(
+    parsedMarketCollateralData.coinType
+  );
+  const coinDecimal = utils.getCoinDecimal(collateralCoinName);
+  const maxCollateralCoin = (0, import_bignumber.default)(
+    parsedMarketCollateralData.maxCollateralAmount
+  ).shiftedBy(-1 * coinDecimal);
+  const depositCoin = (0, import_bignumber.default)(
+    parsedMarketCollateralData.totalCollateralAmount
+  ).shiftedBy(-1 * coinDecimal);
+  return {
+    maxDepositAmount: parsedMarketCollateralData.maxCollateralAmount,
+    maxDepositCoin: maxCollateralCoin.toNumber(),
+    depositAmount: parsedMarketCollateralData.totalCollateralAmount,
+    depositCoin: depositCoin.toNumber()
+  };
+};
+var parseOriginSpoolData = (originSpoolData) => {
+  return {
+    stakeType: (0, import_utils.normalizeStructTag)(originSpoolData.stakeType.fields.name),
+    maxPoint: Number(originSpoolData.maxDistributedPoint),
+    distributedPoint: Number(originSpoolData.distributedPoint),
+    pointPerPeriod: Number(originSpoolData.distributedPointPerPeriod),
+    period: Number(originSpoolData.pointDistributionTime),
+    maxStake: Number(originSpoolData.maxStake),
+    staked: Number(originSpoolData.stakes),
+    index: Number(originSpoolData.index),
+    createdAt: Number(originSpoolData.createdAt),
+    lastUpdate: Number(originSpoolData.lastUpdate)
+  };
+};
+var calculateSpoolData = (parsedSpoolData, stakeMarketCoinPrice, stakeMarketCoinDecimal) => {
+  const baseIndexRate = 1e9;
+  const distributedPointPerSec = (0, import_bignumber.default)(
+    parsedSpoolData.pointPerPeriod
+  ).dividedBy(parsedSpoolData.period);
+  const pointPerSec = (0, import_bignumber.default)(parsedSpoolData.pointPerPeriod).dividedBy(
+    parsedSpoolData.period
+  );
+  const remainingPeriod = pointPerSec.gt(0) ? (0, import_bignumber.default)(parsedSpoolData.maxPoint).minus(parsedSpoolData.distributedPoint).dividedBy(pointPerSec) : (0, import_bignumber.default)(0);
+  const startDate = parsedSpoolData.createdAt;
+  const endDate = remainingPeriod.plus(parsedSpoolData.lastUpdate).integerValue().toNumber();
+  const timeDelta = (0, import_bignumber.default)(
+    Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedSpoolData.lastUpdate
+  ).dividedBy(parsedSpoolData.period).toFixed(0);
+  const remainingPoints = (0, import_bignumber.default)(parsedSpoolData.maxPoint).minus(
+    parsedSpoolData.distributedPoint
+  );
+  const accumulatedPoints = import_bignumber.default.minimum(
+    (0, import_bignumber.default)(timeDelta).multipliedBy(parsedSpoolData.pointPerPeriod),
+    remainingPoints
+  );
+  const currentPointIndex = (0, import_bignumber.default)(parsedSpoolData.index).plus(
+    accumulatedPoints.dividedBy(parsedSpoolData.staked).isFinite() ? (0, import_bignumber.default)(baseIndexRate).multipliedBy(accumulatedPoints).dividedBy(parsedSpoolData.staked) : 0
+  );
+  const currentTotalDistributedPoint = (0, import_bignumber.default)(
+    parsedSpoolData.distributedPoint
+  ).plus(accumulatedPoints);
+  const stakedAmount = (0, import_bignumber.default)(parsedSpoolData.staked);
+  const stakedCoin = stakedAmount.shiftedBy(-1 * stakeMarketCoinDecimal);
+  const stakedValue = stakedCoin.multipliedBy(stakeMarketCoinPrice);
+  return {
+    distributedPointPerSec: distributedPointPerSec.toNumber(),
+    accumulatedPoints: accumulatedPoints.toNumber(),
+    currentPointIndex: currentPointIndex.toNumber(),
+    currentTotalDistributedPoint: currentTotalDistributedPoint.toNumber(),
+    startDate: new Date(startDate * 1e3),
+    endDate: new Date(endDate * 1e3),
+    stakedAmount: stakedAmount.toNumber(),
+    stakedCoin: stakedCoin.toNumber(),
+    stakedValue: stakedValue.toNumber()
+  };
+};
+var parseOriginSpoolRewardPoolData = (originSpoolRewardPoolData) => {
+  return {
+    claimedRewards: Number(originSpoolRewardPoolData.claimed_rewards),
+    exchangeRateDenominator: Number(
+      originSpoolRewardPoolData.exchange_rate_denominator
+    ),
+    exchangeRateNumerator: Number(
+      originSpoolRewardPoolData.exchange_rate_numerator
+    ),
+    rewards: Number(originSpoolRewardPoolData.rewards),
+    spoolId: String(originSpoolRewardPoolData.spool_id)
+  };
+};
+var calculateSpoolRewardPoolData = (parsedSpoolData, parsedSpoolRewardPoolData, calculatedSpoolData, rewardCoinPrice, rewardCoinDecimal) => {
+  const rateYearFactor = 365 * 24 * 60 * 60;
+  const rewardPerSec = (0, import_bignumber.default)(calculatedSpoolData.distributedPointPerSec).multipliedBy(parsedSpoolRewardPoolData.exchangeRateNumerator).dividedBy(parsedSpoolRewardPoolData.exchangeRateDenominator);
+  const totalRewardAmount = (0, import_bignumber.default)(parsedSpoolData.maxPoint).multipliedBy(parsedSpoolRewardPoolData.exchangeRateNumerator).dividedBy(parsedSpoolRewardPoolData.exchangeRateDenominator);
+  const totalRewardCoin = totalRewardAmount.shiftedBy(-1 * rewardCoinDecimal);
+  const totalRewardValue = totalRewardCoin.multipliedBy(rewardCoinPrice);
+  const remaindRewardAmount = (0, import_bignumber.default)(parsedSpoolRewardPoolData.rewards);
+  const remaindRewardCoin = remaindRewardAmount.shiftedBy(
+    -1 * rewardCoinDecimal
+  );
+  const remaindRewardValue = remaindRewardCoin.multipliedBy(rewardCoinPrice);
+  const claimedRewardAmount = (0, import_bignumber.default)(
+    parsedSpoolRewardPoolData.claimedRewards
+  );
+  const claimedRewardCoin = claimedRewardAmount.shiftedBy(
+    -1 * rewardCoinDecimal
+  );
+  const claimedRewardValue = claimedRewardCoin.multipliedBy(rewardCoinPrice);
+  const rewardValueForYear = (0, import_bignumber.default)(rewardPerSec).shiftedBy(-1 * rewardCoinDecimal).multipliedBy(rateYearFactor).multipliedBy(rewardCoinPrice);
+  let rewardRate = rewardValueForYear.dividedBy(calculatedSpoolData.stakedValue).isFinite() ? rewardValueForYear.dividedBy(calculatedSpoolData.stakedValue).toNumber() : Infinity;
+  if (parsedSpoolData.maxPoint <= parsedSpoolData.distributedPoint || parsedSpoolData.pointPerPeriod === 0) {
+    rewardRate = Infinity;
+  }
+  return {
+    rewardApr: rewardRate,
+    totalRewardAmount: totalRewardAmount.toNumber(),
+    totalRewardCoin: totalRewardCoin.toNumber(),
+    totalRewardValue: totalRewardValue.toNumber(),
+    remaindRewardAmount: remaindRewardAmount.toNumber(),
+    remaindRewardCoin: remaindRewardCoin.toNumber(),
+    remaindRewardValue: remaindRewardValue.toNumber(),
+    claimedRewardAmount: claimedRewardAmount.toNumber(),
+    claimedRewardCoin: claimedRewardCoin.toNumber(),
+    claimedRewardValue: claimedRewardValue.toNumber(),
+    rewardPerSec: rewardPerSec.toNumber()
+  };
+};
+var parseOriginBorrowIncentivesPoolPointData = (originBorrowIncentivePoolPointData) => {
+  return {
+    pointType: (0, import_utils.normalizeStructTag)(
+      originBorrowIncentivePoolPointData.point_type.name
+    ),
+    distributedPointPerPeriod: Number(
+      originBorrowIncentivePoolPointData.distributed_point_per_period
+    ),
+    period: Number(originBorrowIncentivePoolPointData.point_distribution_time),
+    distributedPoint: Number(
+      originBorrowIncentivePoolPointData.distributed_point
+    ),
+    points: Number(originBorrowIncentivePoolPointData.points),
+    index: Number(originBorrowIncentivePoolPointData.index),
+    baseWeight: Number(originBorrowIncentivePoolPointData.base_weight),
+    weightedAmount: Number(originBorrowIncentivePoolPointData.weighted_amount),
+    lastUpdate: Number(originBorrowIncentivePoolPointData.last_update)
+  };
+};
+var parseOriginBorrowIncentivePoolData = (originBorrowIncentivePoolData) => {
+  return {
+    poolType: (0, import_utils.normalizeStructTag)(originBorrowIncentivePoolData.pool_type.name),
+    minStakes: Number(originBorrowIncentivePoolData.min_stakes),
+    maxStakes: Number(originBorrowIncentivePoolData.max_stakes),
+    staked: Number(originBorrowIncentivePoolData.stakes),
+    createdAt: Number(originBorrowIncentivePoolData.created_at),
+    poolPoints: originBorrowIncentivePoolData.points.reduce(
+      (acc, point) => {
+        const parsed = parseOriginBorrowIncentivesPoolPointData(point);
+        const name = (0, import_utils.parseStructTag)(
+          parsed.pointType
+        ).name.toLowerCase();
+        acc[name] = parsed;
+        return acc;
       },
-      usdc: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
-          }
-        }
+      {}
+    )
+  };
+};
+var calculateBorrowIncentivePoolPointData = (parsedBorrowIncentivePoolData, parsedBorrowIncentivePoolPointData, rewardCoinPrice, rewardCoinDecimal, poolCoinPrice, poolCoinDecimal) => {
+  const baseIndexRate = 1e9;
+  const distributedPointPerSec = (0, import_bignumber.default)(
+    parsedBorrowIncentivePoolPointData.distributedPointPerPeriod
+  ).dividedBy(parsedBorrowIncentivePoolPointData.period);
+  const timeDelta = (0, import_bignumber.default)(
+    Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedBorrowIncentivePoolPointData.lastUpdate
+  ).dividedBy(parsedBorrowIncentivePoolPointData.period).toFixed(0);
+  const accumulatedPoints = import_bignumber.default.minimum(
+    (0, import_bignumber.default)(timeDelta).multipliedBy(
+      parsedBorrowIncentivePoolPointData.distributedPointPerPeriod
+    ),
+    (0, import_bignumber.default)(parsedBorrowIncentivePoolPointData.points)
+  );
+  const currentPointIndex = (0, import_bignumber.default)(
+    parsedBorrowIncentivePoolPointData.index
+  ).plus(
+    accumulatedPoints.dividedBy(parsedBorrowIncentivePoolPointData.weightedAmount).isFinite() ? (0, import_bignumber.default)(baseIndexRate).multipliedBy(accumulatedPoints).dividedBy(parsedBorrowIncentivePoolPointData.weightedAmount) : 0
+  );
+  const currentTotalDistributedPoint = (0, import_bignumber.default)(
+    parsedBorrowIncentivePoolPointData.distributedPoint
+  ).plus(accumulatedPoints);
+  const baseWeight = (0, import_bignumber.default)(parsedBorrowIncentivePoolPointData.baseWeight);
+  const weightedStakedAmount = (0, import_bignumber.default)(
+    parsedBorrowIncentivePoolPointData.weightedAmount
+  );
+  const weightedStakedCoin = weightedStakedAmount.shiftedBy(
+    -1 * poolCoinDecimal
+  );
+  const weightedStakedValue = weightedStakedCoin.multipliedBy(poolCoinPrice);
+  const rateYearFactor = 365 * 24 * 60 * 60;
+  const rewardPerSec = (0, import_bignumber.default)(distributedPointPerSec).shiftedBy(
+    -1 * rewardCoinDecimal
+  );
+  const rewardValueForYear = (0, import_bignumber.default)(rewardPerSec).multipliedBy(rateYearFactor).multipliedBy(rewardCoinPrice);
+  const weightScale = (0, import_bignumber.default)(1e12);
+  const rewardRate = rewardValueForYear.multipliedBy(
+    (0, import_bignumber.default)(parsedBorrowIncentivePoolPointData.baseWeight).dividedBy(
+      weightScale
+    )
+  ).dividedBy(weightedStakedValue).isFinite() && parsedBorrowIncentivePoolPointData.points > 0 ? rewardValueForYear.multipliedBy(
+    (0, import_bignumber.default)(parsedBorrowIncentivePoolPointData.baseWeight).dividedBy(
+      weightScale
+    )
+  ).dividedBy(weightedStakedValue).toNumber() : Infinity;
+  return {
+    distributedPointPerSec: distributedPointPerSec.toNumber(),
+    accumulatedPoints: accumulatedPoints.toNumber(),
+    currentPointIndex: currentPointIndex.toNumber(),
+    currentTotalDistributedPoint: currentTotalDistributedPoint.toNumber(),
+    baseWeight: baseWeight.toNumber(),
+    weightedStakedAmount: weightedStakedAmount.toNumber(),
+    weightedStakedCoin: weightedStakedCoin.toNumber(),
+    weightedStakedValue: weightedStakedValue.toNumber(),
+    rewardApr: rewardRate,
+    rewardPerSec: rewardPerSec.toNumber()
+  };
+};
+var parseOriginBorrowIncentiveAccountPoolPointData = (originBorrowIncentiveAccountPoolPointData) => {
+  return {
+    pointType: (0, import_utils.normalizeStructTag)(
+      originBorrowIncentiveAccountPoolPointData.point_type.name
+    ),
+    weightedAmount: Number(
+      originBorrowIncentiveAccountPoolPointData.weighted_amount
+    ),
+    points: Number(originBorrowIncentiveAccountPoolPointData.points),
+    totalPoints: Number(originBorrowIncentiveAccountPoolPointData.total_points),
+    index: Number(originBorrowIncentiveAccountPoolPointData.index)
+  };
+};
+var parseOriginBorrowIncentiveAccountData = (originBorrowIncentiveAccountData) => {
+  return {
+    poolType: (0, import_utils.normalizeStructTag)(
+      originBorrowIncentiveAccountData.pool_type.name
+    ),
+    debtAmount: Number(originBorrowIncentiveAccountData.debt_amount),
+    pointList: originBorrowIncentiveAccountData.points_list.reduce(
+      (acc, point) => {
+        const parsed = parseOriginBorrowIncentiveAccountPoolPointData(point);
+        const name = (0, import_utils.parseStructTag)(
+          parsed.pointType
+        ).name.toLowerCase();
+        acc[name] = parsed;
+        return acc;
       },
-      usdt: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
-          }
-        }
+      {}
+    )
+  };
+};
+var minBigNumber = (...args) => {
+  return (0, import_bignumber.default)(
+    args.reduce(
+      (min, current) => new import_bignumber.default(current).lt(min) ? current : min
+    )
+  );
+};
+var estimatedFactor = (amount, scaleStep, type) => {
+  const amountOfDigits = Math.max(
+    1,
+    Math.floor(Math.log10(Math.abs(amount)) + 1)
+  );
+  const adjustScale = Math.max(Math.floor((amountOfDigits - 1) / scaleStep), 1) + 1;
+  let adjustFactor = Math.pow(10, -adjustScale);
+  adjustFactor = type === "increase" ? 1 - adjustFactor : 1 + adjustFactor;
+  return adjustFactor;
+};
+
+// src/utils/util.ts
+var COIN_SET = Array.from(
+  /* @__PURE__ */ new Set([
+    ...SUPPORT_POOLS,
+    ...SUPPORT_COLLATERALS,
+    ...SUPPORT_SPOOLS_REWARDS,
+    ...SUPPORT_BORROW_INCENTIVE_REWARDS,
+    ...SUPPORT_SCOIN
+  ])
+);
+var isMarketCoin = (coinName) => {
+  const assetCoinName = coinName.slice(1).toLowerCase();
+  return coinName.charAt(0).toLowerCase() === "s" && COIN_SET.includes(assetCoinName);
+};
+var parseAssetSymbol = (coinName) => {
+  switch (coinName) {
+    case "afsui":
+      return "afSUI";
+    case "hasui":
+      return "haSUI";
+    case "vsui":
+      return "vSUI";
+    default:
+      return coinName.toUpperCase();
+  }
+};
+var parseDataFromPythPriceFeed = (feed, address) => {
+  const assetCoinNames = COIN_SET;
+  const assetCoinName = assetCoinNames.find((assetCoinName2) => {
+    return address.get(`core.coins.${assetCoinName2}.oracle.pyth.feed`) === feed.id;
+  });
+  if (assetCoinName) {
+    const price = feed.price.price * 10 ** feed.price.expo;
+    return {
+      coinName: assetCoinName,
+      price,
+      publishTime: Number(feed.price.publishTime) * 10 ** 3
+    };
+  } else {
+    throw new Error("Invalid feed id");
+  }
+};
+var findClosestUnlockRound = (unlockAtInSecondTimestamp) => {
+  const unlockDate = new Date(unlockAtInSecondTimestamp * 1e3);
+  const closestTwelveAM = new Date(unlockAtInSecondTimestamp * 1e3);
+  closestTwelveAM.setUTCHours(0, 0, 0, 0);
+  if (unlockDate.getUTCHours() >= 0) {
+    closestTwelveAM.setUTCDate(closestTwelveAM.getUTCDate() + 1);
+  }
+  const now = (/* @__PURE__ */ new Date()).getTime();
+  if (closestTwelveAM.getTime() - now > MAX_LOCK_DURATION * 1e3) {
+    closestTwelveAM.setUTCDate(closestTwelveAM.getUTCDate() - 1);
+  }
+  return Math.floor(closestTwelveAM.getTime() / 1e3);
+};
+
+// src/constants/tokenBucket.ts
+var DEFAULT_TOKENS_PER_INTERVAL = 10;
+var DEFAULT_INTERVAL_IN_MS = 1e3;
+
+// src/utils/tokenBucket.ts
+var TokenBucket = class {
+  constructor(tokensPerInterval, intervalInMs) {
+    this.tokensPerInterval = tokensPerInterval;
+    this.interval = intervalInMs;
+    this.tokens = tokensPerInterval;
+    this.lastRefill = Date.now();
+  }
+  refill() {
+    const now = Date.now();
+    const elapsed = now - this.lastRefill;
+    if (elapsed > this.interval) {
+      const tokensToAdd = Math.floor(elapsed / this.interval) * this.tokensPerInterval;
+      this.tokens = Math.min(this.tokens + tokensToAdd, this.tokensPerInterval);
+      this.lastRefill = now;
+    }
+  }
+  removeTokens(count) {
+    this.refill();
+    if (this.tokens >= count) {
+      this.tokens -= count;
+      return true;
+    }
+    return false;
+  }
+};
+var callWithRateLimit = async (tokenBucket, fn, retryDelayInMs = DEFAULT_INTERVAL_IN_MS, maxRetries = 5) => {
+  let retries = 0;
+  const tryRequest = async () => {
+    if (tokenBucket.removeTokens(1)) {
+      return await fn();
+    } else if (retries < maxRetries) {
+      retries++;
+      await new Promise((resolve) => setTimeout(resolve, retryDelayInMs));
+      return tryRequest();
+    } else {
+      console.error("Maximum retries reached");
+      return null;
+    }
+  };
+  return tryRequest();
+};
+
+// src/models/scallopCache.ts
+var ScallopCache = class {
+  constructor(cacheOptions, suiKit, tokenBucket) {
+    this.queryClient = new import_query_core.QueryClient(cacheOptions ?? DEFAULT_CACHE_OPTIONS);
+    this._suiKit = suiKit;
+    this.tokenBucket = tokenBucket ?? new TokenBucket(DEFAULT_TOKENS_PER_INTERVAL, DEFAULT_INTERVAL_IN_MS);
+  }
+  get suiKit() {
+    if (!this._suiKit) {
+      throw new Error("SuiKit instance is not initialized");
+    }
+    return this._suiKit;
+  }
+  get client() {
+    return this.suiKit.client();
+  }
+  /**
+   * @description Invalidate cache based on the refetchType parameter
+   * @param refetchType Determines the type of queries to be refetched. Defaults to `active`.
+   *
+   * - `active`: Only queries that match the refetch predicate and are actively being rendered via useQuery and related functions will be refetched in the background.
+   * - `inactive`: Only queries that match the refetch predicate and are NOT actively being rendered via useQuery and related functions will be refetched in the background.
+   * - `all`: All queries that match the refetch predicate will be refetched in the background.
+   * - `none`: No queries will be refetched. Queries that match the refetch predicate will only be marked as invalid.
+   */
+  invalidateAndRefetchAllCache(refetchType) {
+    return this.queryClient.invalidateQueries({
+      refetchType
+    });
+  }
+  /**
+   * @description Cache protocol config call for 60 seconds.
+   * @returns Promise<ProtocolConfig>
+   */
+  async getProtocolConfig() {
+    return await this.queryClient.fetchQuery({
+      queryKey: ["getProtocolConfig"],
+      queryFn: async () => {
+        return await callWithRateLimit(
+          this.tokenBucket,
+          () => this.client.getProtocolConfig()
+        );
       },
-      sui: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
-          }
+      staleTime: 3e4
+    });
+  }
+  /**
+   * @description Provides cache for inspectTxn of the SuiKit.
+   * @param QueryInspectTxnParams
+   * @param txBlock
+   * @returns Promise<DevInspectResults>
+   */
+  async queryInspectTxn({
+    queryTarget,
+    args,
+    typeArgs
+  }) {
+    const txBlock = new import_sui_kit.SuiTxBlock();
+    const resolvedArgs = await Promise.all(
+      args.map(async (arg) => {
+        if (typeof arg === "string") {
+          return (await this.queryGetObject(arg, { showContent: true }))?.data;
         }
-      },
-      afsui: {
-        id: "",
-        metaData: "",
+        return arg;
+      })
+    );
+    txBlock.moveCall(queryTarget, resolvedArgs, typeArgs);
+    const txBytes = await txBlock.txBlock.build({
+      client: this.client,
+      onlyTransactionKind: true,
+      protocolConfig: await this.getProtocolConfig() ?? void 0
+    });
+    const query = await this.queryClient.fetchQuery({
+      queryKey: typeArgs ? ["inspectTxn", queryTarget, JSON.stringify(args)] : [
+        "inspectTxn",
+        queryTarget,
+        JSON.stringify(args),
+        JSON.stringify(typeArgs)
+      ],
+      queryFn: async () => {
+        return await callWithRateLimit(
+          this.tokenBucket,
+          () => this.suiKit.inspectTxn(txBytes)
+        );
+      }
+    });
+    return query;
+  }
+  /**
+   * @description Provides cache for getObject of the SuiKit.
+   * @param objectId
+   * @param QueryObjectParams
+   * @returns Promise<SuiObjectResponse>
+   */
+  async queryGetObject(objectId, options) {
+    const queryKey = ["getObject", objectId, this.suiKit.currentAddress()];
+    if (options) {
+      queryKey.push(JSON.stringify(options));
+    }
+    return this.queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => {
+        return await callWithRateLimit(
+          this.tokenBucket,
+          () => this.client.getObject({
+            id: objectId,
+            options
+          })
+        );
+      }
+    });
+  }
+  /**
+   * @description Provides cache for getObjects of the SuiKit.
+   * @param objectIds
+   * @returns Promise<SuiObjectData[]>
+   */
+  async queryGetObjects(objectIds, options) {
+    if (objectIds.length === 0)
+      return [];
+    const queryKey = [
+      "getObjects",
+      JSON.stringify(objectIds),
+      this.suiKit.currentAddress()
+    ];
+    if (options) {
+      queryKey.push(JSON.stringify(options));
+    }
+    return this.queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => {
+        return await callWithRateLimit(
+          this.tokenBucket,
+          () => this.suiKit.getObjects(objectIds, options)
+        );
+      }
+    });
+  }
+  /**
+   * @description Provides cache for getOwnedObjects of the SuiKit.
+   * @param input
+   * @returns Promise<PaginatedObjectsResponse>
+   */
+  async queryGetOwnedObjects(input) {
+    const queryKey = ["getOwnedObjects", input.owner];
+    if (input.cursor) {
+      queryKey.push(JSON.stringify(input.cursor));
+    }
+    if (input.options) {
+      queryKey.push(JSON.stringify(input.options));
+    }
+    if (input.filter) {
+      queryKey.push(JSON.stringify(input.filter));
+    }
+    if (input.limit) {
+      queryKey.push(JSON.stringify(input.limit));
+    }
+    return this.queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => {
+        return await callWithRateLimit(
+          this.tokenBucket,
+          () => this.client.getOwnedObjects(input)
+        );
+      }
+    });
+  }
+  async queryGetDynamicFields(input) {
+    const queryKey = ["getDynamicFields", input.parentId];
+    if (input.cursor) {
+      queryKey.push(JSON.stringify(input.cursor));
+    }
+    if (input.limit) {
+      queryKey.push(JSON.stringify(input.limit));
+    }
+    return this.queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => {
+        return await callWithRateLimit(
+          this.tokenBucket,
+          () => this.client.getDynamicFields(input)
+        );
+      }
+    });
+  }
+  async queryGetDynamicFieldObject(input) {
+    const queryKey = [
+      "getDynamicFieldObject",
+      input.parentId,
+      input.name.type,
+      input.name.value
+    ];
+    return this.queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => {
+        return await callWithRateLimit(
+          this.tokenBucket,
+          () => this.client.getDynamicFieldObject(input)
+        );
+      }
+    });
+  }
+  async queryGetAllCoinBalances(owner) {
+    const queryKey = ["getAllCoinBalances", owner];
+    return this.queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => {
+        const allBalances = await callWithRateLimit(
+          this.tokenBucket,
+          () => this.client.getAllBalances({ owner })
+        );
+        if (!allBalances)
+          return {};
+        const balances = allBalances.reduce(
+          (acc, coinBalance) => {
+            if (coinBalance.totalBalance !== "0") {
+              acc[(0, import_sui_kit.normalizeStructTag)(coinBalance.coinType)] = coinBalance.totalBalance;
+            }
+            return acc;
+          },
+          {}
+        );
+        for (const coinType in balances) {
+          const coinBalanceQueryKey = [
+            "getCoinBalance",
+            (0, import_sui_kit.normalizeSuiAddress)(owner),
+            (0, import_sui_kit.normalizeStructTag)(coinType)
+          ];
+          this.queryClient.setQueryData(
+            coinBalanceQueryKey,
+            balances[coinType]
+          );
+        }
+        return balances;
+      }
+    });
+  }
+  async queryGetCoinBalance(input) {
+    if (!input.coinType)
+      return "0";
+    const queryKey = [
+      "getCoinBalance",
+      (0, import_sui_kit.normalizeSuiAddress)(input.owner),
+      (0, import_sui_kit.normalizeStructTag)(input.coinType)
+    ];
+    return this.queryClient.fetchQuery({
+      queryKey,
+      queryFn: async () => {
+        if (!input.coinType)
+          return "0";
+        return (await this.queryGetAllCoinBalances(input.owner))[(0, import_sui_kit.normalizeStructTag)(input.coinType)] ?? "0";
+      }
+    });
+  }
+};
+
+// src/models/scallopAddress.ts
+var import_axios = __toESM(require("axios"));
+
+// src/constants/testAddress.ts
+var TEST_ADDRESSES = {
+  core: {
+    // version:
+    //   '0x07871c4b3c847a0f674510d4978d5cf6f960452795e8ff6f189fd2088a3f6ac7',
+    version: "0x6156d5cd1538bec8a167a40fe1209a4ec9cf8137921fe0a697f191ac561f0b09",
+    versionCap: "0x590a4011cb649b3878f3ea14b3a78674642a9548d79b7e091ef679574b158a07",
+    // object:
+    //   '0xefe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf',
+    object: "0x87ddec2984645dbbe2403a509cc6edf393a43acdba9b77d45da2bcbefcf733c1",
+    // market:
+    //   '0xa757975255146dc9686aa823b7838b507f315d704f428cbadad2f4ea061939d9',
+    market: "0x8606ed145cc887985b8ed793f7753ff5dc762a42c379dac035f568e1bac58490",
+    adminCap: "0x09689d018e71c337d9db6d67cbca06b74ed92196103624028ccc3ecea411777c",
+    coinDecimalsRegistry: "0x200abe9bf19751cc566ae35aa58e2b7e4ff688fc1130f8d8909ea09bc137d668",
+    // obligationAccessStore:
+    //   '0x733e30b7c94d619d78cb8f5bc4bfbb759ced9a531239028caabb2474e5be59c9',
+    obligationAccessStore: "0x48b472d68ca910c45f7f3b6c26836b6aa6d2569810d94b1b939023da05ae0a23",
+    coins: {
+      cetus: {
+        id: "0x06864a6f921804860930db6ddbe2e16acdf8504495ea7481637a1c8b9a8fe54b",
+        metaData: "0x4c0dce55eff2db5419bbd2d239d1aa22b4a400c01bbb648b058a9883989025da",
         treasury: "",
         oracle: {
           supra: "",
           switchboard: "",
           pyth: {
-            feed: "",
-            feedObject: ""
+            feed: "e5b274b2611143df055d6e7cd8d93fe1961716bcd4dca1cad87a83bc1e78c1ef",
+            feedObject: "0x24c0247fb22457a719efac7f670cdc79be321b521460bd6bd2ccfa9f80713b14"
           }
         }
       },
-      hasui: {
-        id: "",
-        metaData: "",
+      apt: {
+        id: "0x3a5143bb1196e3bcdfab6203d1683ae29edd26294fc8bfeafe4aaa9d2704df37",
+        metaData: "0xc969c5251f372c0f34c32759f1d315cf1ea0ee5e4454b52aea08778eacfdd0a8",
         treasury: "",
         oracle: {
           supra: "",
           switchboard: "",
           pyth: {
-            feed: "",
-            feedObject: ""
+            feed: "03ae4db29ed4ae33d323568895aa00337e658e348b37509f5372ae51f0af00d5",
+            feedObject: "0x7c5b7837c44a69b469325463ac0673ac1aa8435ff44ddb4191c9ae380463647f"
           }
         }
       },
-      vsui: {
-        id: "",
-        metaData: "",
+      sol: {
+        id: "0xb7844e289a8410e50fb3ca48d69eb9cf29e27d223ef90353fe1bd8e27ff8f3f8",
+        metaData: "0x4d2c39082b4477e3e79dc4562d939147ab90c42fc5f3e4acf03b94383cd69b6e",
         treasury: "",
         oracle: {
           supra: "",
           switchboard: "",
           pyth: {
-            feed: "",
-            feedObject: ""
+            feed: "ef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d",
+            feedObject: "0x9d0d275efbd37d8a8855f6f2c761fa5983293dd8ce202ee5196626de8fcd4469"
           }
         }
       },
-      sca: {
-        id: "",
-        metaData: "",
+      btc: {
+        id: "0x027792d9fed7f9844eb4839566001bb6f6cb4804f66aa2da6fe1ee242d896881",
+        metaData: "0x5d3c6e60eeff8a05b693b481539e7847dfe33013e7070cdcb387f5c0cac05dfd",
         treasury: "",
         oracle: {
           supra: "",
           switchboard: "",
           pyth: {
-            feed: "",
-            feedObject: ""
+            feed: "e62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43",
+            feedObject: "0x9a62b4863bdeaabdc9500fce769cf7e72d5585eeb28a6d26e4cafadc13f76ab2"
           }
         }
-      }
-    },
-    oracles: {
-      xOracle: "",
-      xOracleCap: "",
-      supra: { registry: "", registryCap: "", holder: "" },
-      switchboard: { registry: "", registryCap: "" },
-      pyth: {
-        registry: "",
-        registryCap: "",
-        state: "",
-        wormhole: "",
-        wormholeState: ""
-      }
-    },
-    packages: {
-      coinDecimalsRegistry: {
-        id: "",
-        upgradeCap: ""
-      },
-      math: {
-        id: "",
-        upgradeCap: ""
-      },
-      whitelist: {
-        id: "",
-        upgradeCap: ""
+      },
+      eth: {
+        id: "0xaf8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5",
+        metaData: "0x8900e4ceede3363bef086d6b50ca89d816d0e90bf6bc46efefe1f8455e08f50f",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "ff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace",
+            feedObject: "0x9193fd47f9a0ab99b6e365a464c8a9ae30e6150fc37ed2a89c1586631f6fc4ab"
+          }
+        }
+      },
+      usdc: {
+        id: "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf",
+        metaData: "0x4fbf84f3029bd0c0b77164b587963be957f853eccf834a67bb9ecba6ec80f189",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "eaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a",
+            feedObject: "0x5dec622733a204ca27f5a90d8c2fad453cc6665186fd5dff13a83d0b6c9027ab"
+          }
+        }
+      },
+      usdt: {
+        id: "0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c",
+        metaData: "0xfb0e3eb97dd158a5ae979dddfa24348063843c5b20eb8381dd5fa7c93699e45c",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "2b89b9dc8fdf9f34709a5b106b472f0f39bb6ca9ce04b0fd7f2e971688e2e53b",
+            feedObject: "0x985e3db9f93f76ee8bace7c3dd5cc676a096accd5d9e09e9ae0fb6e492b14572"
+          }
+        }
+      },
+      sui: {
+        id: "0x0000000000000000000000000000000000000000000000000000000000000002",
+        metaData: "0x9258181f5ceac8dbffb7030890243caed69a9599d2886d957a9cb7656af3bdb3",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "0xbca474133638352ba83ccf7b5c931d50f764b09550e16612c9f70f1e21f3f594",
+          pyth: {
+            feed: "23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744",
+            feedObject: "0x801dbc2f0053d34734814b2d6df491ce7807a725fe9a01ad74a07e9c51396c37"
+          }
+        }
+      },
+      afsui: {
+        id: "0xf325ce1300e8dac124071d3152c5c5ee6174914f8bc2161e88329cf579246efc",
+        metaData: "0x2f9217f533e51334873a39b8026a4aa6919497b47f49d0986a4f1aec66f8a34d",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744",
+            feedObject: "0x801dbc2f0053d34734814b2d6df491ce7807a725fe9a01ad74a07e9c51396c37"
+          }
+        }
+      },
+      hasui: {
+        id: "0xbde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d",
+        metaData: "0x2c5f33af93f6511df699aaaa5822d823aac6ed99d4a0de2a4a50b3afa0172e24",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744",
+            feedObject: "0x801dbc2f0053d34734814b2d6df491ce7807a725fe9a01ad74a07e9c51396c37"
+          }
+        }
+      },
+      vsui: {
+        id: "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55",
+        metaData: "0xabd84a23467b33854ab25cf862006fd97479f8f6f53e50fe732c43a274d939bd",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744",
+            feedObject: "0x801dbc2f0053d34734814b2d6df491ce7807a725fe9a01ad74a07e9c51396c37"
+          }
+        }
+      },
+      sca: {
+        id: "0x7016aae72cfc67f2fadf55769c0a7dd54291a583b63051a5ed71081cce836ac6",
+        metaData: "0x5d26a1e9a55c88147ac870bfa31b729d7f49f8804b8b3adfdf3582d301cca844",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "7e17f0ac105abe9214deb9944c30264f5986bf292869c6bd8e8da3ccd92d79bc",
+            feedObject: "0xf6de1d3279a269a597d813cbaca59aa906543ab9a8c64e84a4722f1a20863985"
+          }
+        }
+      }
+    },
+    oracles: {
+      xOracle: "0x93d5bf0936b71eb27255941e532fac33b5a5c7759e377b4923af0a1359ad494f",
+      xOracleCap: "0x1edeae568fde99e090dbdec4bcdbd33a15f53a1ce1f87aeef1a560dedf4b4a90",
+      supra: { registry: "", registryCap: "", holder: "" },
+      switchboard: { registry: "", registryCap: "" },
+      pyth: {
+        registry: "0xedc293f9413a5a7a5d53bdba1fd889d0a4030894469228f0acdae4aa3c55a213",
+        registryCap: "0xbcb07141eb1f7e01fbda4130ecf5f5adaeabb77f5d9c32158b7532bcd2197acd",
+        state: "0x1f9310238ee9298fb703c3419030b35b22bb1cc37113e3bb5007c99aec79e5b8",
+        wormhole: "0x5306f64e312b581766351c07af79c72fcb1cd25147157fdc2f8ad76de9a3fb6a",
+        wormholeState: "0xaeab97f96cf9877fee2883315d459552b2b921edc16d7ceac6eab944dd88919c"
+      }
+    },
+    packages: {
+      coinDecimalsRegistry: {
+        id: "0xca5a5a62f01c79a104bf4d31669e29daa387f325c241de4edbe30986a9bc8b0d",
+        upgradeCap: "0x34e76a945d29f195bc53ca704fa70877d1cf3a5d7bbfdda1b13e633fff13c0f6"
+      },
+      math: {
+        id: "0xad013d5fde39e15eabda32b3dbdafd67dac32b798ce63237c27a8f73339b9b6f",
+        upgradeCap: "0x3a329598231de02e6135c62284b66005b41cad1d9ab7ca2dc79c08293aba2ec6"
+      },
+      whitelist: {
+        id: "0x1318fdc90319ec9c24df1456d960a447521b0a658316155895014a6e39b5482f",
+        upgradeCap: "0xf5a22aea23db664f7b69855b6a546747f17c1ec4230319cfc17225e462b05761"
       },
       x: {
-        id: "",
-        upgradeCap: ""
+        id: "0x779b5c547976899f5474f3a5bc0db36ddf4697ad7e5a901db0415c2281d28162",
+        upgradeCap: "0x3f203f6fff6a69d151e4f1cd931f22b68c489ef2759765662fc7baf673943c9e"
       },
       protocol: {
-        id: "",
-        upgradeCap: ""
+        id: "0x87ddec2984645dbbe2403a509cc6edf393a43acdba9b77d45da2bcbefcf733c1",
+        upgradeCap: "0x38527d154618d1fd5a644b90717fe07cf0e9f26b46b63e9568e611a3f86d5c1a"
       },
+      // protocol: {
+      //   id: '0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e',
+      //   upgradeCap:
+      //     '0x38527d154618d1fd5a644b90717fe07cf0e9f26b46b63e9568e611a3f86d5c1a',
+      // },
       protocolWhitelist: {
-        id: "",
-        upgradeCap: ""
+        id: "0x4c262d9343dac53ecb28f482a2a3f62c73d0ebac5b5f03d57383d56ff219acdf",
+        upgradeCap: "0x4a5e88a75039b00988f633f811f58117f31b8627a46bf822aa114d9010049449"
       },
+      // query: {
+      //   id: '0xb8d603a39114a5efef3dd0bf84df0bed1be1fbd39b78b7dd6e8a61ccc5e6006f',
+      //   upgradeCap:
+      //     '0x0d535c35f608b9b01b7ccce11acf43b1dd80c1b72bf8b541744a6e28e8d2745f',
+      // },
       query: {
-        id: "",
-        upgradeCap: ""
+        id: "0xe4f9d62d17746d5b9dbf0d5557747430021a71575780b515161210cdba0a4c1c",
+        upgradeCap: "0x0d535c35f608b9b01b7ccce11acf43b1dd80c1b72bf8b541744a6e28e8d2745f"
       },
       supra: { id: "", upgradeCap: "" },
       pyth: {
-        id: "",
-        upgradeCap: ""
+        id: "0x910f30cbc7f601f75a5141a01265cd47c62d468707c5e1aecb32a18f448cb25a",
+        upgradeCap: "0xdf0ffbae1ea5bb25fbca5efba433dcf00c7cced65679af2f04728901275c6157"
       },
       switchboard: { id: "", upgradeCap: "" },
       xOracle: {
-        id: "",
-        upgradeCap: ""
+        id: "0x1478a432123e4b3d61878b629f2c692969fdb375644f1251cd278a4b1e7d7cd6",
+        upgradeCap: "0x0f928a6b2e26b73330fecaf9b44acfc9800a4a9794d6415c2a3153bc70e3c1f0"
       },
       testCoin: { id: "", upgradeCap: "" }
     }
   },
   spool: {
-    id: "",
-    adminCap: "",
-    object: "",
+    // id: '0x7c4fdabe81c31b19a45d1e572a52a539997a90903fbb5bfab71480abe0fa62c3',
+    id: "0x1742655fe5872dfa6456673f9e38612a4965e6979e6cd7696a7f1225f28bae21",
+    adminCap: "0xdd8a047cbbf802bfcde5288b8ef1910965d789cc614da11d39af05fca0bd020a",
+    // object:
+    //   '0xe87f1b2d498106a2c61421cec75b7b5c5e348512b0dc263949a0e7a3c256571a',
+    object: "0x1742655fe5872dfa6456673f9e38612a4965e6979e6cd7696a7f1225f28bae21",
     pools: {
       seth: {
-        id: "",
-        rewardPoolId: ""
+        id: "0xeec40beccb07c575bebd842eeaabb835f77cd3dab73add433477e57f583a6787",
+        rewardPoolId: "0x957de68a18d87817de8309b30c1ec269a4d87ae513abbeed86b5619cb9ce1077"
       },
       ssui: {
-        id: "",
-        rewardPoolId: ""
+        // id: '0x4f0ba970d3c11db05c8f40c64a15b6a33322db3702d634ced6536960ab6f3ee4',
+        id: "0xb9617f83c06ebdeac0a8834782b1015e1cc7ea23739e30c132c4bfb95c37a579",
+        rewardPoolId: (
+          // '0x162250ef72393a4ad3d46294c4e1bdfcb03f04c869d390e7efbfc995353a7ee9',
+          "0xc3206071a8d43212efb6e3b5504f2321f8df97ab122b466c0bc7cfdf398dc13a"
+        )
       },
       susdc: {
-        id: "",
-        rewardPoolId: ""
+        // id: '0x4ace6648ddc64e646ba47a957c562c32c9599b3bba8f5ac1aadb2ae23a2f8ca0',
+        id: "0xf1b383b9cf2e9f515fc69567df1053098f273849d09cd84b0278a773429bd2b2",
+        rewardPoolId: (
+          // '0xf4268cc9b9413b9bfe09e8966b8de650494c9e5784bf0930759cfef4904daff8',
+          "0xc71c53ee6505d928ba15bea4fe4f45d98c9c31eced94b72d00a7827d4b7ba3ff"
+        )
       },
       susdt: {
-        id: "",
-        rewardPoolId: ""
-      },
-      scetus: {
-        id: "",
-        rewardPoolId: ""
-      },
-      safsui: {
-        id: "",
-        rewardPoolId: ""
-      },
-      shasui: {
-        id: "",
-        rewardPoolId: ""
-      },
-      svsui: {
-        id: "",
-        rewardPoolId: ""
-      }
-    },
-    config: ""
-  },
-  borrowIncentive: {
-    id: "",
-    adminCap: "",
-    object: "",
-    query: "",
-    incentivePools: "",
-    incentiveAccounts: "",
-    config: ""
-  },
-  vesca: {
-    id: "",
-    object: "",
-    adminCap: "",
-    tableId: "",
-    table: "",
-    treasury: "",
-    config: ""
-  },
-  referral: {
-    id: "",
-    version: "",
-    object: "",
-    adminCap: "",
-    referralBindings: "",
-    bindingTableId: "",
-    referralRevenuePool: "",
-    revenueTableId: "",
-    referralTiers: "",
-    tiersTableId: "",
-    authorizedWitnessList: ""
-  },
-  loyaltyProgram: {
-    id: "",
-    object: "",
-    rewardPool: "",
-    userRewardTableId: ""
-  },
-  scoin: {
-    id: "",
-    coins: {
-      ssui: {
-        coinType: "",
-        treasury: ""
-      },
-      scetus: {
-        coinType: "",
-        treasury: ""
-      },
-      ssca: {
-        coinType: "",
-        treasury: ""
-      },
-      susdc: {
-        coinType: "",
-        treasury: ""
-      },
-      susdt: {
-        coinType: "",
-        treasury: ""
-      },
-      seth: {
-        coinType: "",
-        treasury: ""
-      },
-      safsui: {
-        coinType: "",
-        treasury: ""
-      },
-      shasui: {
-        coinType: "",
-        treasury: ""
-      },
-      svsui: {
-        coinType: "",
-        treasury: ""
-      }
-    }
-  }
-};
-var ScallopAddress = class {
-  constructor(params, cache) {
-    const { id, auth, network } = params;
-    this._cache = cache ?? new ScallopCache(DEFAULT_CACHE_OPTIONS);
-    this._requestClient = import_axios.default.create({
-      baseURL: API_BASE_URL,
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json"
-      },
-      timeout: 3e4
-    });
-    if (auth)
-      this._auth = auth;
-    this._id = id;
-    this._network = network || "mainnet";
-    this._addressesMap = USE_TEST_ADDRESS ? /* @__PURE__ */ new Map([["mainnet", TEST_ADDRESSES]]) : /* @__PURE__ */ new Map();
-    if (USE_TEST_ADDRESS)
-      this._currentAddresses = TEST_ADDRESSES;
-  }
-  /**
-   * Get addresses API id.
-   *
-   * @return The addresses API id.
-   */
-  getId() {
-    return this._id || void 0;
-  }
-  /**
-   * Get the address at the provided path.
-   *
-   * @param path - The path of the address to get.
-   * @return The address at the provided path.
-   */
-  get(path) {
-    if (this._currentAddresses) {
-      const value = path.split(".").reduce(
-        (nestedAddressObj, key) => typeof nestedAddressObj === "object" ? nestedAddressObj[key] : nestedAddressObj,
-        this._currentAddresses
-      );
-      return value || void 0;
-    } else {
-      return void 0;
-    }
-  }
-  /**
-   * Sets the address for the specified path, it does not interact with the API.
-   *
-   * @param path - The path of the address to set.
-   * @param address - The address be setted to the tartget path.
-   * @return The addresses.
-   */
-  set(path, address) {
-    if (this._currentAddresses) {
-      const keys = path.split(".");
-      keys.reduce((nestedAddressObj, key, index) => {
-        if (index === keys.length - 1) {
-          nestedAddressObj[key] = address;
-        } else {
-          return nestedAddressObj[key];
-        }
-      }, this._currentAddresses);
-    }
-    return this._currentAddresses;
-  }
-  /**
-   * Synchronize the specified network addresses from the addresses map to the
-   * current addresses and change the default network to specified network.
-   *
-   * @param network - Specifies which network's addresses you want to get.
-   * @return Current addresses.
-   */
-  switchCurrentAddresses(network) {
-    if (this._addressesMap.has(network)) {
-      this._currentAddresses = this._addressesMap.get(network);
-      this._network = network;
-    }
-    return this._currentAddresses;
-  }
-  /**
-   * Get the addresses, If `network` is not provided, returns the current
-   * addresses or the default network addresses in the addresses map.
-   *
-   * @param network - Specifies which network's addresses you want to get.
-   */
-  getAddresses(network) {
-    if (network) {
-      return this._addressesMap.get(network);
-    } else {
-      return this._currentAddresses ?? this._addressesMap.get(this._network);
-    }
-  }
-  /**
-   * Set the addresses into addresses map. If the specified network is the same
-   * as the current network, the current addresses will be updated at the same time.
-   *
-   * @param addresses - The addresses be setted to the tartget network.
-   * @param network - Specifies which network's addresses you want to set.
-   * @return The addresses.
-   */
-  setAddresses(addresses, network) {
-    const targetNetwork = network || this._network;
-    if (targetNetwork === this._network)
-      this._currentAddresses = addresses;
-    this._addressesMap.set(targetNetwork, addresses);
-  }
-  /**
-   * Get all addresses.
-   *
-   * @return All addresses.
-   */
-  getAllAddresses() {
-    return Object.fromEntries(this._addressesMap);
-  }
-  /**
-   * Create a new addresses through the API and synchronize it back to the
-   * instance.
-   *
-   * @description
-   * If the `network` is not specified, the mainnet is used by default.
-   * If no `addresses` from instance or parameter is provided, an addresses with
-   * all empty strings is created by default.
-   *
-   * This function only allows for one addresses to be input into a specific network
-   * at a time, and does not provide an addresses map for setting addresses
-   * across all networks at once.
-   *
-   * @param params.addresses - The addresses be setted to the tartget network.
-   * @param params.network - Specifies which network's addresses you want to set.
-   * @param params.auth - The authentication API key.
-   * @param params.memo - Add memo to the addresses created in the API.
-   * @return All addresses.
-   */
-  async create(params) {
-    const { addresses, network, auth, memo } = params ?? {};
-    const apiKey = auth || this._auth || void 0;
-    const targetNetwork = network || this._network;
-    const targetAddresses = addresses || this._currentAddresses || this._addressesMap.get(targetNetwork) || EMPTY_ADDRESSES;
-    if (apiKey !== void 0) {
-      this._addressesMap.clear();
-      this.setAddresses(targetAddresses, targetNetwork);
-      const response = await this._requestClient.post(
-        `/addresses`,
-        JSON.stringify({ ...Object.fromEntries(this._addressesMap), memo }),
-        {
-          headers: {
-            "Content-Type": "application/json",
-            "api-key": auth || this._auth
-          }
-        }
-      );
-      if (response.status === 201) {
-        for (const [network2, addresses2] of Object.entries(
-          response.data
-        )) {
-          if (["localnet", "devnet", "testnet", "mainnet"].includes(network2)) {
-            if (network2 === this._network)
-              this._currentAddresses = addresses2;
-            this._addressesMap.set(network2, addresses2);
-          }
-        }
-        this._id = response.data.id;
-        return this.getAllAddresses();
-      } else {
-        throw Error("Failed to create addresses.");
-      }
-    } else {
-      throw Error("You don't have permission to access this request.");
-    }
-  }
-  /**
-   * Read and synchronizes all addresses from the API into instance.
-   *
-   * @param id - The id of the addresses to get.
-   * @return All addresses.
-   */
-  async read(id) {
-    const addressesId = id || this._id || void 0;
-    if (addressesId !== void 0) {
-      const response = await this._cache.queryClient.fetchQuery({
-        queryKey: ["api-getAddresses", addressesId],
-        queryFn: async () => {
-          return await this._requestClient.get(`/addresses/${addressesId}`, {
-            headers: {
-              "Content-Type": "application/json"
-            }
-          });
-        }
-      });
-      if (response.status === 200) {
-        for (const [network, addresses] of Object.entries(
-          response.data
-        )) {
-          if (["localnet", "devnet", "testnet", "mainnet"].includes(network)) {
-            if (network === this._network)
-              this._currentAddresses = addresses;
-            this._addressesMap.set(network, addresses);
-          }
-        }
-        this._id = response.data.id;
-        return this.getAllAddresses();
-      } else {
-        throw Error("Failed to create addresses.");
-      }
-    } else {
-      throw Error("Please provide API addresses id.");
-    }
-  }
-  /**
-   * Update the addresses through the API and synchronize it back to the
-   * instance.
-   *
-   * @description
-   * If the `network` is not specified, the mainnet is used by default.
-   * If no `addresses` from instance or parameter is provided, an addresses with
-   * all empty strings is created by default.
-   *
-   * This function only allows for one addresses to be input into a specific network
-   * at a time, and does not provide an addresses map for setting addresses
-   * across all networks at once.
-   *
-   * @param params.id - The id of the addresses to update.
-   * @param params.addresses - The addresses be setted to the tartget network.
-   * @param params.network - Specifies which network's addresses you want to set.
-   * @param params.auth - The authentication api key.
-   * @param params.memo - Add memo to the addresses created in the API.
-   * @return All addresses.
-   */
-  async update(params) {
-    const { id, addresses, network, auth, memo } = params ?? {};
-    const apiKey = auth || this._auth || void 0;
-    const targetId = id || this._id || void 0;
-    const targetNetwork = network || this._network;
-    const targetAddresses = addresses || this._currentAddresses || this._addressesMap.get(targetNetwork) || EMPTY_ADDRESSES;
-    if (targetId === void 0)
-      throw Error("Require specific addresses id to be updated.");
-    if (apiKey !== void 0) {
-      if (id !== this._id) {
-        this._addressesMap.clear();
-      }
-      this.setAddresses(targetAddresses, targetNetwork);
-      const response = await this._requestClient.put(
-        `/addresses/${targetId}`,
-        JSON.stringify({ ...Object.fromEntries(this._addressesMap), memo }),
-        {
-          headers: {
-            "Content-Type": "application/json",
-            "api-key": auth || this._auth
-          }
-        }
-      );
-      if (response.status === 200) {
-        for (const [network2, addresses2] of Object.entries(
-          response.data
-        )) {
-          if (["localnet", "devnet", "testnet", "mainnet"].includes(network2)) {
-            if (network2 === this._network)
-              this._currentAddresses = addresses2;
-            this._addressesMap.set(network2, addresses2);
-          }
-        }
-        this._id = response.data.id;
-        return this.getAllAddresses();
-      } else {
-        throw Error("Failed to update addresses.");
-      }
-    } else {
-      throw Error("You don't have permission to access this request.");
-    }
-  }
-  /**
-   * Deletes all addresses of a specified id through the API and clear all
-   * addresses in the instance.
-   *
-   * @param id - The id of the addresses to delete.
-   * @param auth - The authentication API key.
-   */
-  async delete(id, auth) {
-    const apiKey = auth || this._auth || void 0;
-    const targetId = id || this._id || void 0;
-    if (targetId === void 0)
-      throw Error("Require specific addresses id to be deleted.");
-    if (apiKey !== void 0) {
-      const response = await this._requestClient.delete(
-        `/addresses/${targetId}`,
-        {
-          headers: {
-            "Content-Type": "application/json",
-            "api-key": auth || this._auth
-          }
-        }
-      );
-      if (response.status === 200) {
-        this._id = void 0;
-        this._currentAddresses = void 0;
-        this._addressesMap.clear();
-      } else {
-        throw Error("Failed to delete addresses.");
-      }
-    } else {
-      throw Error("You don't have permission to access this request.");
-    }
-  }
-};
-
-// src/models/scallopClient.ts
-var import_utils24 = require("@mysten/sui.js/utils");
-var import_sui_kit13 = require("@scallop-io/sui-kit");
-
-// src/models/scallopUtils.ts
-var import_utils10 = require("@mysten/sui.js/utils");
-var import_sui_kit4 = require("@scallop-io/sui-kit");
-var import_pyth_sui_js = require("@pythnetwork/pyth-sui-js");
-
-// src/models/scallopQuery.ts
-var import_sui_kit3 = require("@scallop-io/sui-kit");
-
-// src/queries/coreQuery.ts
-var import_utils2 = require("@mysten/sui.js/utils");
-
-// src/utils/builder.ts
-var requireSender = (txBlock) => {
-  const sender = txBlock.blockData.sender;
-  if (!sender) {
-    throw new Error("Sender is required");
-  }
-  return sender;
-};
-var checkVesca = (prevUnlockAtInMillisTimestamp) => {
-  if (prevUnlockAtInMillisTimestamp === void 0) {
-    throw new Error("veSca not found");
-  }
-};
-var checkVescaExpired = (prevUnlockAtInMillisTimestamp) => {
-  if (prevUnlockAtInMillisTimestamp <= (/* @__PURE__ */ new Date()).getTime()) {
-    throw new Error("veSca is expired, use renewExpiredVeScaQuick instead");
-  }
-};
-var checkExtendLockPeriod = (lockPeriodInDays, newUnlockAtInSecondTimestamp, prevUnlockAtInMillisTimestamp) => {
-  checkVesca(prevUnlockAtInMillisTimestamp);
-  checkVescaExpired(prevUnlockAtInMillisTimestamp);
-  const prevUnlockAtInSecondTimestamp = Math.floor(
-    prevUnlockAtInMillisTimestamp / 1e3
-  );
-  if (lockPeriodInDays < 1) {
-    throw new Error("Minimum lock period is 1 day");
-  }
-  const availableLockPeriodInDays = Math.floor(
-    (newUnlockAtInSecondTimestamp - prevUnlockAtInSecondTimestamp) / UNLOCK_ROUND_DURATION
-  );
-  if (lockPeriodInDays > availableLockPeriodInDays) {
-    throw new Error(
-      `Cannot extend lock period by ${lockPeriodInDays} days, maximum lock period is ~4 years (${MAX_LOCK_ROUNDS} days), remaining lock period is ${MAX_LOCK_ROUNDS - availableLockPeriodInDays}`
-    );
-  }
-};
-var checkLockSca = (scaAmountOrCoin, lockPeriodInDays, newUnlockAtInSecondTimestamp, prevUnlockAtInMillisTimestamp) => {
-  const prevUnlockAtInSecondTimestamp = prevUnlockAtInMillisTimestamp ? Math.floor(prevUnlockAtInMillisTimestamp / 1e3) : void 0;
-  const isInitialLock = !prevUnlockAtInSecondTimestamp;
-  const isLockExpired = !isInitialLock && prevUnlockAtInSecondTimestamp * 1e3 <= (/* @__PURE__ */ new Date()).getTime();
-  if (isInitialLock || isLockExpired) {
-    if (scaAmountOrCoin !== void 0 && lockPeriodInDays !== void 0) {
-      if (lockPeriodInDays <= 0) {
-        throw new Error("Lock period must be greater than 0");
-      }
-      if (typeof scaAmountOrCoin === "number" && scaAmountOrCoin < MIN_INITIAL_LOCK_AMOUNT) {
-        throw new Error(
-          `Minimum lock amount for ${isLockExpired ? "renewing expired veSca" : "initial lock"} is 10 SCA`
-        );
-      }
-      const extendLockPeriodInSecond = lockPeriodInDays * UNLOCK_ROUND_DURATION;
-      if (extendLockPeriodInSecond > MAX_LOCK_DURATION) {
-        throw new Error(
-          `Maximum lock period is ~4 years (${MAX_LOCK_ROUNDS} days)`
-        );
-      }
-    } else {
-      throw new Error(
-        `SCA amount and lock period is required for ${isLockExpired ? "renewing expired veSca" : "initial lock"}`
-      );
-    }
-  } else {
-    checkVesca(prevUnlockAtInMillisTimestamp);
-    checkVescaExpired(prevUnlockAtInMillisTimestamp);
-    if (typeof scaAmountOrCoin === "number" && scaAmountOrCoin < MIN_TOP_UP_AMOUNT) {
-      throw new Error("Minimum top up amount is 1 SCA");
-    }
-    if (newUnlockAtInSecondTimestamp && lockPeriodInDays) {
-      checkExtendLockPeriod(
-        lockPeriodInDays,
-        newUnlockAtInSecondTimestamp,
-        prevUnlockAtInMillisTimestamp
-      );
-    }
-  }
-};
-var checkExtendLockAmount = (scaAmount, prevUnlockAtInMillisTimestamp) => {
-  checkVesca(prevUnlockAtInMillisTimestamp);
-  checkVescaExpired(prevUnlockAtInMillisTimestamp);
-  if (scaAmount < MIN_TOP_UP_AMOUNT) {
-    throw new Error("Minimum top up amount is 1 SCA");
-  }
-  const isInitialLock = !prevUnlockAtInMillisTimestamp;
-  const isLockExpired = !isInitialLock && prevUnlockAtInMillisTimestamp <= (/* @__PURE__ */ new Date()).getTime();
-  if (isLockExpired) {
-    throw new Error("veSca is expired, use renewExpiredVeScaQuick instead");
-  }
-};
-var checkRenewExpiredVeSca = (scaAmount, lockPeriodInDays, prevUnlockAtInMillisTimestamp) => {
-  if (!prevUnlockAtInMillisTimestamp || prevUnlockAtInMillisTimestamp > (/* @__PURE__ */ new Date()).getTime()) {
-    throw new Error("Renew method can only be used for expired veSca");
-  }
-  if (scaAmount < MIN_INITIAL_LOCK_AMOUNT) {
-    throw new Error("Minimum lock amount for renewing expired vesca 10 SCA");
-  }
-  const extendLockPeriodInSecond = lockPeriodInDays * UNLOCK_ROUND_DURATION;
-  if (extendLockPeriodInSecond >= MAX_LOCK_DURATION - UNLOCK_ROUND_DURATION) {
-    throw new Error(
-      `Maximum lock period is ~4 years (${MAX_LOCK_ROUNDS - 1} days)`
-    );
-  }
-};
-
-// src/utils/query.ts
-var import_bignumber = __toESM(require("bignumber.js"));
-var import_utils = require("@mysten/sui.js/utils");
-var parseOriginMarketPoolData = (originMarketPoolData) => {
-  return {
-    coinType: (0, import_utils.normalizeStructTag)(originMarketPoolData.type.name),
-    // Parse origin data required for basic calculations.
-    maxBorrowRate: Number(originMarketPoolData.maxBorrowRate.value) / 2 ** 32,
-    borrowRate: Number(originMarketPoolData.interestRate.value) / 2 ** 32,
-    borrowRateScale: Number(originMarketPoolData.interestRateScale),
-    borrowIndex: Number(originMarketPoolData.borrowIndex),
-    lastUpdated: Number(originMarketPoolData.lastUpdated),
-    cashAmount: Number(originMarketPoolData.cash),
-    debtAmount: Number(originMarketPoolData.debt),
-    marketCoinSupplyAmount: Number(originMarketPoolData.marketCoinSupply),
-    reserveAmount: Number(originMarketPoolData.reserve),
-    reserveFactor: Number(originMarketPoolData.reserveFactor.value) / 2 ** 32,
-    borrowWeight: Number(originMarketPoolData.borrowWeight.value) / 2 ** 32,
-    borrowFee: Number(originMarketPoolData.borrowFeeRate.value) / 2 ** 32,
-    // Parse origin data required for additional display.
-    baseBorrowRate: Number(originMarketPoolData.baseBorrowRatePerSec.value) / 2 ** 32,
-    borrowRateOnHighKink: Number(originMarketPoolData.borrowRateOnHighKink.value) / 2 ** 32,
-    borrowRateOnMidKink: Number(originMarketPoolData.borrowRateOnMidKink.value) / 2 ** 32,
-    highKink: Number(originMarketPoolData.highKink.value) / 2 ** 32,
-    midKink: Number(originMarketPoolData.midKink.value) / 2 ** 32,
-    minBorrowAmount: Number(originMarketPoolData.minBorrowAmount)
-  };
-};
-var calculateMarketPoolData = (utils, parsedMarketPoolData) => {
-  const poolCoinName = utils.parseCoinNameFromType(
-    parsedMarketPoolData.coinType
-  );
-  const coinDecimal = utils.getCoinDecimal(poolCoinName);
-  const borrowYearFactor = 24 * 365 * 3600;
-  const baseBorrowApr = parsedMarketPoolData.baseBorrowRate * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
-  const borrowAprOnHighKink = parsedMarketPoolData.borrowRateOnHighKink * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
-  const borrowAprOnMidKink = parsedMarketPoolData.borrowRateOnMidKink * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
-  const maxBorrowApr = parsedMarketPoolData.maxBorrowRate * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
-  const borrowApr = parsedMarketPoolData.borrowRate * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
-  const timeDelta = Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedMarketPoolData.lastUpdated;
-  const borrowIndexDelta = (0, import_bignumber.default)(parsedMarketPoolData.borrowIndex).multipliedBy(
-    (0, import_bignumber.default)(timeDelta).multipliedBy(parsedMarketPoolData.borrowRate)
-  ).dividedBy(parsedMarketPoolData.borrowRateScale);
-  const currentBorrowIndex = (0, import_bignumber.default)(parsedMarketPoolData.borrowIndex).plus(
-    borrowIndexDelta
-  );
-  const growthInterest = (0, import_bignumber.default)(currentBorrowIndex).dividedBy(parsedMarketPoolData.borrowIndex).minus(1);
-  const increasedDebtAmount = (0, import_bignumber.default)(
-    parsedMarketPoolData.debtAmount
-  ).multipliedBy(growthInterest);
-  const borrowAmount = increasedDebtAmount.plus(
-    parsedMarketPoolData.debtAmount
-  );
-  const borrowCoin = borrowAmount.shiftedBy(-1 * coinDecimal);
-  const reserveAmount = (0, import_bignumber.default)(parsedMarketPoolData.reserveAmount).plus(
-    increasedDebtAmount.multipliedBy(parsedMarketPoolData.reserveFactor)
-  );
-  const reserveCoin = reserveAmount.shiftedBy(-1 * coinDecimal);
-  const supplyAmount = (0, import_bignumber.default)(borrowAmount).plus(
-    Math.max(parsedMarketPoolData.cashAmount - reserveAmount.toNumber(), 0)
-  );
-  const supplyCoin = supplyAmount.shiftedBy(-1 * coinDecimal);
-  let utilizationRate = (0, import_bignumber.default)(borrowAmount).dividedBy(supplyAmount);
-  utilizationRate = utilizationRate.isFinite() ? utilizationRate : (0, import_bignumber.default)(0);
-  let supplyApr = (0, import_bignumber.default)(borrowApr).multipliedBy(utilizationRate).multipliedBy(1 - parsedMarketPoolData.reserveFactor);
-  supplyApr = supplyApr.isFinite() ? supplyApr : (0, import_bignumber.default)(0);
-  let conversionRate = supplyAmount.dividedBy(
-    parsedMarketPoolData.marketCoinSupplyAmount
-  );
-  conversionRate = conversionRate.isFinite() && !conversionRate.isNaN() ? conversionRate : (0, import_bignumber.default)(1);
-  return {
-    baseBorrowApr,
-    baseBorrowApy: utils.parseAprToApy(baseBorrowApr),
-    borrowAprOnHighKink,
-    borrowApyOnHighKink: utils.parseAprToApy(borrowAprOnHighKink),
-    borrowAprOnMidKink,
-    borrowApyOnMidKink: utils.parseAprToApy(borrowAprOnMidKink),
-    maxBorrowApr,
-    maxBorrowApy: utils.parseAprToApy(maxBorrowApr),
-    borrowApr: Math.min(borrowApr, maxBorrowApr),
-    borrowApy: Math.min(
-      utils.parseAprToApy(borrowApr),
-      utils.parseAprToApy(maxBorrowApr)
-    ),
-    borrowIndex: currentBorrowIndex.toNumber(),
-    growthInterest: growthInterest.toNumber(),
-    supplyAmount: supplyAmount.toNumber(),
-    supplyCoin: supplyCoin.toNumber(),
-    borrowAmount: borrowAmount.toNumber(),
-    borrowCoin: borrowCoin.toNumber(),
-    reserveAmount: reserveAmount.toNumber(),
-    reserveCoin: reserveCoin.toNumber(),
-    utilizationRate: utilizationRate.toNumber(),
-    supplyApr: supplyApr.toNumber(),
-    supplyApy: utils.parseAprToApy(supplyApr.toNumber()),
-    conversionRate: conversionRate.toNumber()
-  };
-};
-var parseOriginMarketCollateralData = (originMarketCollateralData) => {
-  const divisor = 2 ** 32;
-  return {
-    coinType: (0, import_utils.normalizeStructTag)(originMarketCollateralData.type.name),
-    collateralFactor: Number(originMarketCollateralData.collateralFactor.value) / divisor,
-    liquidationFactor: Number(originMarketCollateralData.liquidationFactor.value) / divisor,
-    liquidationDiscount: Number(originMarketCollateralData.liquidationDiscount.value) / divisor,
-    liquidationPanelty: Number(originMarketCollateralData.liquidationPanelty.value) / divisor,
-    liquidationReserveFactor: Number(originMarketCollateralData.liquidationReserveFactor.value) / divisor,
-    maxCollateralAmount: Number(originMarketCollateralData.maxCollateralAmount),
-    totalCollateralAmount: Number(
-      originMarketCollateralData.totalCollateralAmount
-    )
-  };
-};
-var calculateMarketCollateralData = (utils, parsedMarketCollateralData) => {
-  const collateralCoinName = utils.parseCoinNameFromType(
-    parsedMarketCollateralData.coinType
-  );
-  const coinDecimal = utils.getCoinDecimal(collateralCoinName);
-  const maxCollateralCoin = (0, import_bignumber.default)(
-    parsedMarketCollateralData.maxCollateralAmount
-  ).shiftedBy(-1 * coinDecimal);
-  const depositCoin = (0, import_bignumber.default)(
-    parsedMarketCollateralData.totalCollateralAmount
-  ).shiftedBy(-1 * coinDecimal);
-  return {
-    maxDepositAmount: parsedMarketCollateralData.maxCollateralAmount,
-    maxDepositCoin: maxCollateralCoin.toNumber(),
-    depositAmount: parsedMarketCollateralData.totalCollateralAmount,
-    depositCoin: depositCoin.toNumber()
-  };
-};
-var parseOriginSpoolData = (originSpoolData) => {
-  return {
-    stakeType: (0, import_utils.normalizeStructTag)(originSpoolData.stakeType.fields.name),
-    maxPoint: Number(originSpoolData.maxDistributedPoint),
-    distributedPoint: Number(originSpoolData.distributedPoint),
-    pointPerPeriod: Number(originSpoolData.distributedPointPerPeriod),
-    period: Number(originSpoolData.pointDistributionTime),
-    maxStake: Number(originSpoolData.maxStake),
-    staked: Number(originSpoolData.stakes),
-    index: Number(originSpoolData.index),
-    createdAt: Number(originSpoolData.createdAt),
-    lastUpdate: Number(originSpoolData.lastUpdate)
-  };
-};
-var calculateSpoolData = (parsedSpoolData, stakeMarketCoinPrice, stakeMarketCoinDecimal) => {
-  const baseIndexRate = 1e9;
-  const distributedPointPerSec = (0, import_bignumber.default)(
-    parsedSpoolData.pointPerPeriod
-  ).dividedBy(parsedSpoolData.period);
-  const pointPerSec = (0, import_bignumber.default)(parsedSpoolData.pointPerPeriod).dividedBy(
-    parsedSpoolData.period
-  );
-  const remainingPeriod = pointPerSec.gt(0) ? (0, import_bignumber.default)(parsedSpoolData.maxPoint).minus(parsedSpoolData.distributedPoint).dividedBy(pointPerSec) : (0, import_bignumber.default)(0);
-  const startDate = parsedSpoolData.createdAt;
-  const endDate = remainingPeriod.plus(parsedSpoolData.lastUpdate).integerValue().toNumber();
-  const timeDelta = (0, import_bignumber.default)(
-    Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedSpoolData.lastUpdate
-  ).dividedBy(parsedSpoolData.period).toFixed(0);
-  const remainingPoints = (0, import_bignumber.default)(parsedSpoolData.maxPoint).minus(
-    parsedSpoolData.distributedPoint
-  );
-  const accumulatedPoints = import_bignumber.default.minimum(
-    (0, import_bignumber.default)(timeDelta).multipliedBy(parsedSpoolData.pointPerPeriod),
-    remainingPoints
-  );
-  const currentPointIndex = (0, import_bignumber.default)(parsedSpoolData.index).plus(
-    accumulatedPoints.dividedBy(parsedSpoolData.staked).isFinite() ? (0, import_bignumber.default)(baseIndexRate).multipliedBy(accumulatedPoints).dividedBy(parsedSpoolData.staked) : 0
-  );
-  const currentTotalDistributedPoint = (0, import_bignumber.default)(
-    parsedSpoolData.distributedPoint
-  ).plus(accumulatedPoints);
-  const stakedAmount = (0, import_bignumber.default)(parsedSpoolData.staked);
-  const stakedCoin = stakedAmount.shiftedBy(-1 * stakeMarketCoinDecimal);
-  const stakedValue = stakedCoin.multipliedBy(stakeMarketCoinPrice);
-  return {
-    distributedPointPerSec: distributedPointPerSec.toNumber(),
-    accumulatedPoints: accumulatedPoints.toNumber(),
-    currentPointIndex: currentPointIndex.toNumber(),
-    currentTotalDistributedPoint: currentTotalDistributedPoint.toNumber(),
-    startDate: new Date(startDate * 1e3),
-    endDate: new Date(endDate * 1e3),
-    stakedAmount: stakedAmount.toNumber(),
-    stakedCoin: stakedCoin.toNumber(),
-    stakedValue: stakedValue.toNumber()
-  };
-};
-var parseOriginSpoolRewardPoolData = (originSpoolRewardPoolData) => {
-  return {
-    claimedRewards: Number(originSpoolRewardPoolData.claimed_rewards),
-    exchangeRateDenominator: Number(
-      originSpoolRewardPoolData.exchange_rate_denominator
-    ),
-    exchangeRateNumerator: Number(
-      originSpoolRewardPoolData.exchange_rate_numerator
-    ),
-    rewards: Number(originSpoolRewardPoolData.rewards),
-    spoolId: String(originSpoolRewardPoolData.spool_id)
-  };
-};
-var calculateSpoolRewardPoolData = (parsedSpoolData, parsedSpoolRewardPoolData, calculatedSpoolData, rewardCoinPrice, rewardCoinDecimal) => {
-  const rateYearFactor = 365 * 24 * 60 * 60;
-  const rewardPerSec = (0, import_bignumber.default)(calculatedSpoolData.distributedPointPerSec).multipliedBy(parsedSpoolRewardPoolData.exchangeRateNumerator).dividedBy(parsedSpoolRewardPoolData.exchangeRateDenominator);
-  const totalRewardAmount = (0, import_bignumber.default)(parsedSpoolData.maxPoint).multipliedBy(parsedSpoolRewardPoolData.exchangeRateNumerator).dividedBy(parsedSpoolRewardPoolData.exchangeRateDenominator);
-  const totalRewardCoin = totalRewardAmount.shiftedBy(-1 * rewardCoinDecimal);
-  const totalRewardValue = totalRewardCoin.multipliedBy(rewardCoinPrice);
-  const remaindRewardAmount = (0, import_bignumber.default)(parsedSpoolRewardPoolData.rewards);
-  const remaindRewardCoin = remaindRewardAmount.shiftedBy(
-    -1 * rewardCoinDecimal
-  );
-  const remaindRewardValue = remaindRewardCoin.multipliedBy(rewardCoinPrice);
-  const claimedRewardAmount = (0, import_bignumber.default)(
-    parsedSpoolRewardPoolData.claimedRewards
-  );
-  const claimedRewardCoin = claimedRewardAmount.shiftedBy(
-    -1 * rewardCoinDecimal
-  );
-  const claimedRewardValue = claimedRewardCoin.multipliedBy(rewardCoinPrice);
-  const rewardValueForYear = (0, import_bignumber.default)(rewardPerSec).shiftedBy(-1 * rewardCoinDecimal).multipliedBy(rateYearFactor).multipliedBy(rewardCoinPrice);
-  let rewardRate = rewardValueForYear.dividedBy(calculatedSpoolData.stakedValue).isFinite() ? rewardValueForYear.dividedBy(calculatedSpoolData.stakedValue).toNumber() : Infinity;
-  if (parsedSpoolData.maxPoint <= parsedSpoolData.distributedPoint || parsedSpoolData.pointPerPeriod === 0) {
-    rewardRate = Infinity;
+        // id: '0xcb328f7ffa7f9342ed85af3fdb2f22919e1a06dfb2f713c04c73543870d7548f',
+        id: "0xb5567dfa5c7fc17a249e959732664c50713dd8c23db1a11376b27df800c17418",
+        rewardPoolId: (
+          // '0x2c9f934d67a5baa586ceec2cc24163a2f049a6af3d5ba36b84d8ac40f25c4080',
+          "0x60768b0687ff0235e376a039709a683e4c436098785e473b67b32dbab47b69ab"
+        )
+      },
+      scetus: {
+        id: "0xac1bb13bf4472a637c18c2415fb0e3c1227ea2bcf35242e50563c98215bd298e",
+        rewardPoolId: "0x6835c1224126a45086fc6406adc249e3f30df18d779ca4f4e570e38716a17f3f"
+      },
+      safsui: {
+        // id: '0xeedf438abcaa6ce4d9625ffca110920592d5867e4c5637d84ad9f466c4feb800',
+        id: "0xc568bb4c991258e839aa54802ecda04fcd9838c826bc3b42b40af81b23c458c8",
+        rewardPoolId: (
+          // '0x89255a2f86ed7fbfef35ab8b7be48cc7667015975be2685dd9a55a9a64baf76e',
+          "0x389a3cbeda742b918941bb24fd00e077bad3367484394d6234f8209b9a6aa03d"
+        )
+      },
+      shasui: {
+        // id: '0xa6148bc1b623e936d39a952ceb5bea79e8b37228a8f595067bf1852efd3c34aa',
+        id: "0x93f3f4499bf89f2d05ddc1f8b15f51701a7c6c4d0ac0b9c3bc99462cbbd8e321",
+        rewardPoolId: (
+          // '0x6f3563644d3e2ef13176dbf9d865bd93479df60ccbe07b7e66db57f6309f5a66',
+          "0x94cee1be7f5ff34193f3aabef0b14142cb28af4d905fe487a9a7d85a15edb6aa"
+        )
+      },
+      svsui: {
+        // id: '0x69ce8e537e750a95381e6040794afa5ab1758353a1a2e1de7760391b01f91670',
+        id: "0xa970e9087f80cb59e9299b8e7af7175d977ad6c9af0322aa4440e138fbd7ae00",
+        rewardPoolId: (
+          // '0xbca914adce058ad0902c7f3cfcd698392a475f00dcfdc3f76001d0370b98777a',
+          "0x38eee9699c4fc132a6623e54b865f047df4fc6eb83af807300f44e8f4b235ff0"
+        )
+      }
+    },
+    config: ""
+  },
+  borrowIncentive: {
+    id: "0x6152f696fc3a658f33c4b891764731a59153125ffedfa8bff7167c42823f58a9",
+    adminCap: "0xc486afa253646f4d381e81d7f1df8aa4723b845a6bb356f69bad635ffefffe2c",
+    object: "0x002875153e09f8145ab63527bc85c00f2bd102e12f9573c47f8cdf1a1cb62934",
+    query: "0x529edc54a3dce2207703ceebbccb0ac14133f7825c1f528775ba0d85a4063489",
+    incentivePools: "0x6547e143d406b5ccd5f46aae482497de279cc1a68c406f701df70a05f9212ab4",
+    incentiveAccounts: "0xc4701fdbc1c92f9a636d334d66012b3027659e9fb8aff27279a82edfb6b77d02",
+    config: "0xdf5d04b4691cc67e82fd4db8394d89ff44823a9de29716c924f74bb4f11cc1f7"
+  },
+  referral: {
+    id: "0xa3654ebb63eb06c0f4ff52f8aa6512df9f164f7772bdf15dac3709bd3798dda9",
+    object: "0x5658d4bf5ddcba27e4337b4262108b3ad1716643cac8c2054ac341538adc72ec",
+    adminCap: "0xc5dc06b9074291259f2cac460c940012c781c4430e42125c541cc43101c3bcbd",
+    referralBindings: "0xf63299d58789d99de94092b9011323466e55ca0c1ea1a7a3786a589af46e1c09",
+    bindingTableId: "0x1c8202b17267ec8d6cf97ca013615354181a04f179570e42601ff2dae19294b1",
+    referralRevenuePool: "0x6abd852caf90769c1b185cdf636d841673fa95528f0550f018b8a138bd283c07",
+    revenueTableId: "0x595baa3654c297bff84ab7786a2d250f019cefc66e8df8e89fd9d41e02bd30dd",
+    referralTiers: "0x962cb903d8d7346190c5204785ccbb91b61086aa764f674c8145df82335cf83e",
+    tiersTableId: "0xeac755a7a8b7798530905ac79e8c114f19d0f130f6eab012954f08faac29c75d",
+    // authorizedWitnessList:
+    //   '0xf21b0ed043c9bb70842c0129159f4943dbcc3c9ef2f2f808af65f8be25cfd20e',
+    authorizedWitnessList: "0x9d6223dc52015b8a3986a573590ef2af8f1b8f3e4685513888c052f001b87e7f",
+    version: "0x1bd4b7285f72e11c316b828c7c47b3f4da18dcec9f9b3dba6d8629cbb6f93e5e"
+  },
+  vesca: {
+    id: "0xb15b6e0cdd85afb5028bea851dd249405e734d800a259147bbc24980629723a4",
+    object: "0xb15b6e0cdd85afb5028bea851dd249405e734d800a259147bbc24980629723a4",
+    adminCap: "0x8ffa76135c5b85c5fbd73a6448a4a733d826cb63a267ab817656acb77c72d4a5",
+    tableId: "0xe3153b2bf124be0b86cb8bd468346a861efd0da52fc42197b54d2f616488a311",
+    table: "0x611cb8d9d4d90867467b5ebdf4cc447a0047ed5b01334a28a29fcfe733e3d609",
+    treasury: "0xe8c112c09b88158dc6c8e23d1fbae5b3c7136cdee54b7dafc08e65db28c4a5bc",
+    config: "0xe0a2ff281e73c1d53cfa85807080f87e833e4f1a7f93dcf8800b3865269a76b9"
+  },
+  loyaltyProgram: {
+    id: "0xd17bcf8b5a59652c36225d478564a8593ae0ed7d650bcacdda1d6fe179127907",
+    object: "0xd17bcf8b5a59652c36225d478564a8593ae0ed7d650bcacdda1d6fe179127907",
+    rewardPool: "0xf9c090492ef476bd542109d0913ffe871cbfa28578b7114eca2a8c0e5671786f",
+    userRewardTableId: "0x748a80395849ed37db1b0e14f2ab5d1d96458d2359ab3a84eb079d0f4ac7cf2e"
+  },
+  scoin: {
+    id: "0xad2ca2aa5089df94bb2d444d5eb3520378c2f2dfb3a0bd2a2c994145ac4b0a53",
+    coins: {
+      ssui: {
+        coinType: "0xfac769100bccc0caebcf4f4e2d00ac2f8883f07f724be28940df90605f5e7e9a::scallop_sui::SCALLOP_SUI",
+        treasury: "0x9cb4551b36c17d37e19d700147fa819ea1c487ff8bcf18374de2cceb2e9d4845"
+      },
+      scetus: {
+        coinType: "0x8b71e6d323ed78515af2bead13bf3d0da1562ba4a99234eb7c4f14fd39ef0427::scallop_cetus::SCALLOP_CETUS",
+        treasury: "0xd786f4b2d26278cc7911a3445b1b085eab60f269ef9dbb6b87e803d52f155003"
+      },
+      ssca: {
+        coinType: "0x0a9d3c6c9af9f6e8def82921541bcbd17f73ed31bed3adcb684f2a4c267e42f0::scallop_sca::SCALLOP_SCA",
+        treasury: "0xe818636d1d6c46d6ea1a2dce9d94696d7cbc18ce27451b603eeaa47aba8d75e0"
+      },
+      susdc: {
+        coinType: "0xaedc3ab75db8680b81a755015fa90124d217be93457b893c05bac033817defaf::scallop_wormhole_usdc::SCALLOP_WORMHOLE_USDC",
+        treasury: "0xfc6971648f867f7fd6928d1b873af71577e2eaf2c7543ef8bc82c431d833ae78"
+      },
+      susdt: {
+        coinType: "0xbf02fc87ddc104b342ad8414c85ceadf5b0c823c055a06fb0ed776272c01a52a::scallop_wormhole_usdt::SCALLOP_WORMHOLE_USDT",
+        treasury: "0xb9593e2c3a0ba796ee815012b75ae46468ea78cda0188b9ac6816efe65503521"
+      },
+      seth: {
+        coinType: "0x27d54f43e3eda701be56b82e5756e41c84467cd202f5cf713d5f9e45a9f1b6bc::scallop_wormhole_eth::SCALLOP_WORMHOLE_ETH",
+        treasury: "0x032b4c8fac94c038dbe986f7587e9b1e4ef580b5ee06d2ef249d85459b7ef05d"
+      },
+      safsui: {
+        coinType: "0xb75b46d975d8d80670b53a6bee90baaa8ce2e0b7d397f079447d641eef6b44ad::scallop_af_sui::SCALLOP_AF_SUI",
+        treasury: "0x21450ef0570ef3d224ffa3b873ab802e439ece7b93cc7efad10ae0c1e3b3fcfe"
+      },
+      shasui: {
+        coinType: "0xd973a723874e2c7cde196602a79155a1343a933f8cf87d9b1bb7408bc1acbc58::scallop_ha_sui::SCALLOP_HA_SUI",
+        treasury: "0xf822fc1402207e47d2e3ba8ff6e1e594bf1de777dc5ebd2744619cd2726e3b0d"
+      },
+      svsui: {
+        coinType: "0x97023a317320c4498cc4cd239dd02fd30c28246e5e8f81325d63f2bd8d70f6b3::scallop_v_sui::SCALLOP_V_SUI",
+        treasury: "0x327114f0bf3559d7e2de10282147ed76a236c7c6775029165c4db09a6062ead6\u0192"
+      }
+    }
   }
-  return {
-    rewardApr: rewardRate,
-    totalRewardAmount: totalRewardAmount.toNumber(),
-    totalRewardCoin: totalRewardCoin.toNumber(),
-    totalRewardValue: totalRewardValue.toNumber(),
-    remaindRewardAmount: remaindRewardAmount.toNumber(),
-    remaindRewardCoin: remaindRewardCoin.toNumber(),
-    remaindRewardValue: remaindRewardValue.toNumber(),
-    claimedRewardAmount: claimedRewardAmount.toNumber(),
-    claimedRewardCoin: claimedRewardCoin.toNumber(),
-    claimedRewardValue: claimedRewardValue.toNumber(),
-    rewardPerSec: rewardPerSec.toNumber()
-  };
-};
-var parseOriginBorrowIncentivesPoolPointData = (originBorrowIncentivePoolPointData) => {
-  return {
-    pointType: (0, import_utils.normalizeStructTag)(
-      originBorrowIncentivePoolPointData.point_type.name
-    ),
-    distributedPointPerPeriod: Number(
-      originBorrowIncentivePoolPointData.distributed_point_per_period
-    ),
-    period: Number(originBorrowIncentivePoolPointData.point_distribution_time),
-    distributedPoint: Number(
-      originBorrowIncentivePoolPointData.distributed_point
-    ),
-    points: Number(originBorrowIncentivePoolPointData.points),
-    index: Number(originBorrowIncentivePoolPointData.index),
-    baseWeight: Number(originBorrowIncentivePoolPointData.base_weight),
-    weightedAmount: Number(originBorrowIncentivePoolPointData.weighted_amount),
-    lastUpdate: Number(originBorrowIncentivePoolPointData.last_update)
-  };
 };
-var parseOriginBorrowIncentivePoolData = (originBorrowIncentivePoolData) => {
-  return {
-    poolType: (0, import_utils.normalizeStructTag)(originBorrowIncentivePoolData.pool_type.name),
-    minStakes: Number(originBorrowIncentivePoolData.min_stakes),
-    maxStakes: Number(originBorrowIncentivePoolData.max_stakes),
-    staked: Number(originBorrowIncentivePoolData.stakes),
-    createdAt: Number(originBorrowIncentivePoolData.created_at),
-    poolPoints: originBorrowIncentivePoolData.points.reduce(
-      (acc, point) => {
-        const parsed = parseOriginBorrowIncentivesPoolPointData(point);
-        const name = (0, import_utils.parseStructTag)(
-          parsed.pointType
-        ).name.toLowerCase();
-        acc[name] = parsed;
-        return acc;
+
+// src/models/scallopAddress.ts
+var EMPTY_ADDRESSES = {
+  core: {
+    version: "",
+    versionCap: "",
+    object: "",
+    market: "",
+    adminCap: "",
+    coinDecimalsRegistry: "",
+    obligationAccessStore: "",
+    coins: {
+      cetus: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      apt: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      sol: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      btc: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      eth: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      usdc: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      usdt: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
       },
-      {}
-    )
-  };
-};
-var calculateBorrowIncentivePoolPointData = (parsedBorrowIncentivePoolData, parsedBorrowIncentivePoolPointData, rewardCoinPrice, rewardCoinDecimal, poolCoinPrice, poolCoinDecimal) => {
-  const baseIndexRate = 1e9;
-  const distributedPointPerSec = (0, import_bignumber.default)(
-    parsedBorrowIncentivePoolPointData.distributedPointPerPeriod
-  ).dividedBy(parsedBorrowIncentivePoolPointData.period);
-  const timeDelta = (0, import_bignumber.default)(
-    Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedBorrowIncentivePoolPointData.lastUpdate
-  ).dividedBy(parsedBorrowIncentivePoolPointData.period).toFixed(0);
-  const accumulatedPoints = import_bignumber.default.minimum(
-    (0, import_bignumber.default)(timeDelta).multipliedBy(
-      parsedBorrowIncentivePoolPointData.distributedPointPerPeriod
-    ),
-    (0, import_bignumber.default)(parsedBorrowIncentivePoolPointData.points)
-  );
-  const currentPointIndex = (0, import_bignumber.default)(
-    parsedBorrowIncentivePoolPointData.index
-  ).plus(
-    accumulatedPoints.dividedBy(parsedBorrowIncentivePoolPointData.weightedAmount).isFinite() ? (0, import_bignumber.default)(baseIndexRate).multipliedBy(accumulatedPoints).dividedBy(parsedBorrowIncentivePoolPointData.weightedAmount) : 0
-  );
-  const currentTotalDistributedPoint = (0, import_bignumber.default)(
-    parsedBorrowIncentivePoolPointData.distributedPoint
-  ).plus(accumulatedPoints);
-  const baseWeight = (0, import_bignumber.default)(parsedBorrowIncentivePoolPointData.baseWeight);
-  const weightedStakedAmount = (0, import_bignumber.default)(
-    parsedBorrowIncentivePoolPointData.weightedAmount
-  );
-  const weightedStakedCoin = weightedStakedAmount.shiftedBy(
-    -1 * poolCoinDecimal
-  );
-  const weightedStakedValue = weightedStakedCoin.multipliedBy(poolCoinPrice);
-  const rateYearFactor = 365 * 24 * 60 * 60;
-  const rewardPerSec = (0, import_bignumber.default)(distributedPointPerSec).shiftedBy(
-    -1 * rewardCoinDecimal
-  );
-  const rewardValueForYear = (0, import_bignumber.default)(rewardPerSec).multipliedBy(rateYearFactor).multipliedBy(rewardCoinPrice);
-  const weightScale = (0, import_bignumber.default)(1e12);
-  const rewardRate = rewardValueForYear.multipliedBy(
-    (0, import_bignumber.default)(parsedBorrowIncentivePoolPointData.baseWeight).dividedBy(
-      weightScale
-    )
-  ).dividedBy(weightedStakedValue).isFinite() && parsedBorrowIncentivePoolPointData.points > 0 ? rewardValueForYear.multipliedBy(
-    (0, import_bignumber.default)(parsedBorrowIncentivePoolPointData.baseWeight).dividedBy(
-      weightScale
-    )
-  ).dividedBy(weightedStakedValue).toNumber() : Infinity;
-  return {
-    distributedPointPerSec: distributedPointPerSec.toNumber(),
-    accumulatedPoints: accumulatedPoints.toNumber(),
-    currentPointIndex: currentPointIndex.toNumber(),
-    currentTotalDistributedPoint: currentTotalDistributedPoint.toNumber(),
-    baseWeight: baseWeight.toNumber(),
-    weightedStakedAmount: weightedStakedAmount.toNumber(),
-    weightedStakedCoin: weightedStakedCoin.toNumber(),
-    weightedStakedValue: weightedStakedValue.toNumber(),
-    rewardApr: rewardRate,
-    rewardPerSec: rewardPerSec.toNumber()
-  };
-};
-var parseOriginBorrowIncentiveAccountPoolPointData = (originBorrowIncentiveAccountPoolPointData) => {
-  return {
-    pointType: (0, import_utils.normalizeStructTag)(
-      originBorrowIncentiveAccountPoolPointData.point_type.name
-    ),
-    weightedAmount: Number(
-      originBorrowIncentiveAccountPoolPointData.weighted_amount
-    ),
-    points: Number(originBorrowIncentiveAccountPoolPointData.points),
-    totalPoints: Number(originBorrowIncentiveAccountPoolPointData.total_points),
-    index: Number(originBorrowIncentiveAccountPoolPointData.index)
-  };
-};
-var parseOriginBorrowIncentiveAccountData = (originBorrowIncentiveAccountData) => {
-  return {
-    poolType: (0, import_utils.normalizeStructTag)(
-      originBorrowIncentiveAccountData.pool_type.name
-    ),
-    debtAmount: Number(originBorrowIncentiveAccountData.debt_amount),
-    pointList: originBorrowIncentiveAccountData.points_list.reduce(
-      (acc, point) => {
-        const parsed = parseOriginBorrowIncentiveAccountPoolPointData(point);
-        const name = (0, import_utils.parseStructTag)(
-          parsed.pointType
-        ).name.toLowerCase();
-        acc[name] = parsed;
-        return acc;
+      sui: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      afsui: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      hasui: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      vsui: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      sca: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      }
+    },
+    oracles: {
+      xOracle: "",
+      xOracleCap: "",
+      supra: { registry: "", registryCap: "", holder: "" },
+      switchboard: { registry: "", registryCap: "" },
+      pyth: {
+        registry: "",
+        registryCap: "",
+        state: "",
+        wormhole: "",
+        wormholeState: ""
+      }
+    },
+    packages: {
+      coinDecimalsRegistry: {
+        id: "",
+        upgradeCap: ""
+      },
+      math: {
+        id: "",
+        upgradeCap: ""
+      },
+      whitelist: {
+        id: "",
+        upgradeCap: ""
+      },
+      x: {
+        id: "",
+        upgradeCap: ""
+      },
+      protocol: {
+        id: "",
+        upgradeCap: ""
+      },
+      protocolWhitelist: {
+        id: "",
+        upgradeCap: ""
+      },
+      query: {
+        id: "",
+        upgradeCap: ""
+      },
+      supra: { id: "", upgradeCap: "" },
+      pyth: {
+        id: "",
+        upgradeCap: ""
+      },
+      switchboard: { id: "", upgradeCap: "" },
+      xOracle: {
+        id: "",
+        upgradeCap: ""
+      },
+      testCoin: { id: "", upgradeCap: "" }
+    }
+  },
+  spool: {
+    id: "",
+    adminCap: "",
+    object: "",
+    pools: {
+      seth: {
+        id: "",
+        rewardPoolId: ""
+      },
+      ssui: {
+        id: "",
+        rewardPoolId: ""
+      },
+      susdc: {
+        id: "",
+        rewardPoolId: ""
+      },
+      susdt: {
+        id: "",
+        rewardPoolId: ""
+      },
+      scetus: {
+        id: "",
+        rewardPoolId: ""
+      },
+      safsui: {
+        id: "",
+        rewardPoolId: ""
+      },
+      shasui: {
+        id: "",
+        rewardPoolId: ""
+      },
+      svsui: {
+        id: "",
+        rewardPoolId: ""
+      }
+    },
+    config: ""
+  },
+  borrowIncentive: {
+    id: "",
+    adminCap: "",
+    object: "",
+    query: "",
+    incentivePools: "",
+    incentiveAccounts: "",
+    config: ""
+  },
+  vesca: {
+    id: "",
+    object: "",
+    adminCap: "",
+    tableId: "",
+    table: "",
+    treasury: "",
+    config: ""
+  },
+  referral: {
+    id: "",
+    version: "",
+    object: "",
+    adminCap: "",
+    referralBindings: "",
+    bindingTableId: "",
+    referralRevenuePool: "",
+    revenueTableId: "",
+    referralTiers: "",
+    tiersTableId: "",
+    authorizedWitnessList: ""
+  },
+  loyaltyProgram: {
+    id: "",
+    object: "",
+    rewardPool: "",
+    userRewardTableId: ""
+  },
+  scoin: {
+    id: "",
+    coins: {
+      ssui: {
+        coinType: "",
+        treasury: ""
       },
-      {}
-    )
-  };
-};
-var minBigNumber = (...args) => {
-  return (0, import_bignumber.default)(
-    args.reduce(
-      (min, current) => new import_bignumber.default(current).lt(min) ? current : min
-    )
-  );
-};
-var estimatedFactor = (amount, scaleStep, type) => {
-  const amountOfDigits = Math.max(
-    1,
-    Math.floor(Math.log10(Math.abs(amount)) + 1)
-  );
-  const adjustScale = Math.max(Math.floor((amountOfDigits - 1) / scaleStep), 1) + 1;
-  let adjustFactor = Math.pow(10, -adjustScale);
-  adjustFactor = type === "increase" ? 1 - adjustFactor : 1 + adjustFactor;
-  return adjustFactor;
-};
-
-// src/utils/util.ts
-var COIN_SET = Array.from(
-  /* @__PURE__ */ new Set([
-    ...SUPPORT_POOLS,
-    ...SUPPORT_COLLATERALS,
-    ...SUPPORT_SPOOLS_REWARDS,
-    ...SUPPORT_BORROW_INCENTIVE_REWARDS,
-    ...SUPPORT_SCOIN
-  ])
-);
-var isMarketCoin = (coinName) => {
-  const assetCoinName = coinName.slice(1).toLowerCase();
-  return coinName.charAt(0).toLowerCase() === "s" && COIN_SET.includes(assetCoinName);
+      scetus: {
+        coinType: "",
+        treasury: ""
+      },
+      ssca: {
+        coinType: "",
+        treasury: ""
+      },
+      susdc: {
+        coinType: "",
+        treasury: ""
+      },
+      susdt: {
+        coinType: "",
+        treasury: ""
+      },
+      seth: {
+        coinType: "",
+        treasury: ""
+      },
+      safsui: {
+        coinType: "",
+        treasury: ""
+      },
+      shasui: {
+        coinType: "",
+        treasury: ""
+      },
+      svsui: {
+        coinType: "",
+        treasury: ""
+      }
+    }
+  }
 };
-var parseAssetSymbol = (coinName) => {
-  switch (coinName) {
-    case "afsui":
-      return "afSUI";
-    case "hasui":
-      return "haSUI";
-    case "vsui":
-      return "vSUI";
-    default:
-      return coinName.toUpperCase();
+var ScallopAddress = class {
+  constructor(params, cache) {
+    const { id, auth, network } = params;
+    this._cache = cache ?? new ScallopCache(DEFAULT_CACHE_OPTIONS);
+    this._requestClient = import_axios.default.create({
+      baseURL: API_BASE_URL,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      timeout: 3e4
+    });
+    if (auth)
+      this._auth = auth;
+    this._id = id;
+    this._network = network || "mainnet";
+    this._addressesMap = USE_TEST_ADDRESS ? /* @__PURE__ */ new Map([["mainnet", TEST_ADDRESSES]]) : /* @__PURE__ */ new Map();
+    if (USE_TEST_ADDRESS)
+      this._currentAddresses = TEST_ADDRESSES;
+  }
+  /**
+   * Get addresses API id.
+   *
+   * @return The addresses API id.
+   */
+  getId() {
+    return this._id || void 0;
+  }
+  /**
+   * Get the address at the provided path.
+   *
+   * @param path - The path of the address to get.
+   * @return The address at the provided path.
+   */
+  get(path) {
+    if (this._currentAddresses) {
+      const value = path.split(".").reduce(
+        (nestedAddressObj, key) => typeof nestedAddressObj === "object" ? nestedAddressObj[key] : nestedAddressObj,
+        this._currentAddresses
+      );
+      return value || void 0;
+    } else {
+      return void 0;
+    }
+  }
+  /**
+   * Sets the address for the specified path, it does not interact with the API.
+   *
+   * @param path - The path of the address to set.
+   * @param address - The address be setted to the tartget path.
+   * @return The addresses.
+   */
+  set(path, address) {
+    if (this._currentAddresses) {
+      const keys = path.split(".");
+      keys.reduce((nestedAddressObj, key, index) => {
+        if (index === keys.length - 1) {
+          nestedAddressObj[key] = address;
+        } else {
+          return nestedAddressObj[key];
+        }
+      }, this._currentAddresses);
+    }
+    return this._currentAddresses;
+  }
+  /**
+   * Synchronize the specified network addresses from the addresses map to the
+   * current addresses and change the default network to specified network.
+   *
+   * @param network - Specifies which network's addresses you want to get.
+   * @return Current addresses.
+   */
+  switchCurrentAddresses(network) {
+    if (this._addressesMap.has(network)) {
+      this._currentAddresses = this._addressesMap.get(network);
+      this._network = network;
+    }
+    return this._currentAddresses;
+  }
+  /**
+   * Get the addresses, If `network` is not provided, returns the current
+   * addresses or the default network addresses in the addresses map.
+   *
+   * @param network - Specifies which network's addresses you want to get.
+   */
+  getAddresses(network) {
+    if (network) {
+      return this._addressesMap.get(network);
+    } else {
+      return this._currentAddresses ?? this._addressesMap.get(this._network);
+    }
+  }
+  /**
+   * Set the addresses into addresses map. If the specified network is the same
+   * as the current network, the current addresses will be updated at the same time.
+   *
+   * @param addresses - The addresses be setted to the tartget network.
+   * @param network - Specifies which network's addresses you want to set.
+   * @return The addresses.
+   */
+  setAddresses(addresses, network) {
+    const targetNetwork = network || this._network;
+    if (targetNetwork === this._network)
+      this._currentAddresses = addresses;
+    this._addressesMap.set(targetNetwork, addresses);
+  }
+  /**
+   * Get all addresses.
+   *
+   * @return All addresses.
+   */
+  getAllAddresses() {
+    return Object.fromEntries(this._addressesMap);
+  }
+  /**
+   * Create a new addresses through the API and synchronize it back to the
+   * instance.
+   *
+   * @description
+   * If the `network` is not specified, the mainnet is used by default.
+   * If no `addresses` from instance or parameter is provided, an addresses with
+   * all empty strings is created by default.
+   *
+   * This function only allows for one addresses to be input into a specific network
+   * at a time, and does not provide an addresses map for setting addresses
+   * across all networks at once.
+   *
+   * @param params.addresses - The addresses be setted to the tartget network.
+   * @param params.network - Specifies which network's addresses you want to set.
+   * @param params.auth - The authentication API key.
+   * @param params.memo - Add memo to the addresses created in the API.
+   * @return All addresses.
+   */
+  async create(params) {
+    const { addresses, network, auth, memo } = params ?? {};
+    const apiKey = auth || this._auth || void 0;
+    const targetNetwork = network || this._network;
+    const targetAddresses = addresses || this._currentAddresses || this._addressesMap.get(targetNetwork) || EMPTY_ADDRESSES;
+    if (apiKey !== void 0) {
+      this._addressesMap.clear();
+      this.setAddresses(targetAddresses, targetNetwork);
+      const response = await this._requestClient.post(
+        `/addresses`,
+        JSON.stringify({ ...Object.fromEntries(this._addressesMap), memo }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            "api-key": auth || this._auth
+          }
+        }
+      );
+      if (response.status === 201) {
+        for (const [network2, addresses2] of Object.entries(
+          response.data
+        )) {
+          if (["localnet", "devnet", "testnet", "mainnet"].includes(network2)) {
+            if (network2 === this._network)
+              this._currentAddresses = addresses2;
+            this._addressesMap.set(network2, addresses2);
+          }
+        }
+        this._id = response.data.id;
+        return this.getAllAddresses();
+      } else {
+        throw Error("Failed to create addresses.");
+      }
+    } else {
+      throw Error("You don't have permission to access this request.");
+    }
   }
-};
-var parseDataFromPythPriceFeed = (feed, address) => {
-  const assetCoinNames = COIN_SET;
-  const assetCoinName = assetCoinNames.find((assetCoinName2) => {
-    return address.get(`core.coins.${assetCoinName2}.oracle.pyth.feed`) === feed.id;
-  });
-  if (assetCoinName) {
-    const price = feed.price.price * 10 ** feed.price.expo;
-    return {
-      coinName: assetCoinName,
-      price,
-      publishTime: Number(feed.price.publishTime) * 10 ** 3
-    };
-  } else {
-    throw new Error("Invalid feed id");
+  /**
+   * Read and synchronizes all addresses from the API into instance.
+   *
+   * @param id - The id of the addresses to get.
+   * @return All addresses.
+   */
+  async read(id) {
+    const addressesId = id || this._id || void 0;
+    if (addressesId !== void 0) {
+      const response = await this._cache.queryClient.fetchQuery({
+        queryKey: ["api-getAddresses", addressesId],
+        queryFn: async () => {
+          return await this._requestClient.get(`/addresses/${addressesId}`, {
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+        }
+      });
+      if (response.status === 200) {
+        for (const [network, addresses] of Object.entries(
+          response.data
+        )) {
+          if (["localnet", "devnet", "testnet", "mainnet"].includes(network)) {
+            if (network === this._network)
+              this._currentAddresses = addresses;
+            this._addressesMap.set(network, addresses);
+          }
+        }
+        this._id = response.data.id;
+        return this.getAllAddresses();
+      } else {
+        throw Error("Failed to create addresses.");
+      }
+    } else {
+      throw Error("Please provide API addresses id.");
+    }
   }
-};
-var findClosestUnlockRound = (unlockAtInSecondTimestamp) => {
-  const unlockDate = new Date(unlockAtInSecondTimestamp * 1e3);
-  const closestTwelveAM = new Date(unlockAtInSecondTimestamp * 1e3);
-  closestTwelveAM.setUTCHours(0, 0, 0, 0);
-  if (unlockDate.getUTCHours() >= 0) {
-    closestTwelveAM.setUTCDate(closestTwelveAM.getUTCDate() + 1);
+  /**
+   * Update the addresses through the API and synchronize it back to the
+   * instance.
+   *
+   * @description
+   * If the `network` is not specified, the mainnet is used by default.
+   * If no `addresses` from instance or parameter is provided, an addresses with
+   * all empty strings is created by default.
+   *
+   * This function only allows for one addresses to be input into a specific network
+   * at a time, and does not provide an addresses map for setting addresses
+   * across all networks at once.
+   *
+   * @param params.id - The id of the addresses to update.
+   * @param params.addresses - The addresses be setted to the tartget network.
+   * @param params.network - Specifies which network's addresses you want to set.
+   * @param params.auth - The authentication api key.
+   * @param params.memo - Add memo to the addresses created in the API.
+   * @return All addresses.
+   */
+  async update(params) {
+    const { id, addresses, network, auth, memo } = params ?? {};
+    const apiKey = auth || this._auth || void 0;
+    const targetId = id || this._id || void 0;
+    const targetNetwork = network || this._network;
+    const targetAddresses = addresses || this._currentAddresses || this._addressesMap.get(targetNetwork) || EMPTY_ADDRESSES;
+    if (targetId === void 0)
+      throw Error("Require specific addresses id to be updated.");
+    if (apiKey !== void 0) {
+      if (id !== this._id) {
+        this._addressesMap.clear();
+      }
+      this.setAddresses(targetAddresses, targetNetwork);
+      const response = await this._requestClient.put(
+        `/addresses/${targetId}`,
+        JSON.stringify({ ...Object.fromEntries(this._addressesMap), memo }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            "api-key": auth || this._auth
+          }
+        }
+      );
+      if (response.status === 200) {
+        for (const [network2, addresses2] of Object.entries(
+          response.data
+        )) {
+          if (["localnet", "devnet", "testnet", "mainnet"].includes(network2)) {
+            if (network2 === this._network)
+              this._currentAddresses = addresses2;
+            this._addressesMap.set(network2, addresses2);
+          }
+        }
+        this._id = response.data.id;
+        return this.getAllAddresses();
+      } else {
+        throw Error("Failed to update addresses.");
+      }
+    } else {
+      throw Error("You don't have permission to access this request.");
+    }
   }
-  const now = (/* @__PURE__ */ new Date()).getTime();
-  if (closestTwelveAM.getTime() - now > MAX_LOCK_DURATION * 1e3) {
-    closestTwelveAM.setUTCDate(closestTwelveAM.getUTCDate() - 1);
+  /**
+   * Deletes all addresses of a specified id through the API and clear all
+   * addresses in the instance.
+   *
+   * @param id - The id of the addresses to delete.
+   * @param auth - The authentication API key.
+   */
+  async delete(id, auth) {
+    const apiKey = auth || this._auth || void 0;
+    const targetId = id || this._id || void 0;
+    if (targetId === void 0)
+      throw Error("Require specific addresses id to be deleted.");
+    if (apiKey !== void 0) {
+      const response = await this._requestClient.delete(
+        `/addresses/${targetId}`,
+        {
+          headers: {
+            "Content-Type": "application/json",
+            "api-key": auth || this._auth
+          }
+        }
+      );
+      if (response.status === 200) {
+        this._id = void 0;
+        this._currentAddresses = void 0;
+        this._addressesMap.clear();
+      } else {
+        throw Error("Failed to delete addresses.");
+      }
+    } else {
+      throw Error("You don't have permission to access this request.");
+    }
   }
-  return Math.floor(closestTwelveAM.getTime() / 1e3);
 };
 
+// src/models/scallopClient.ts
+var import_utils25 = require("@mysten/sui.js/utils");
+var import_sui_kit13 = require("@scallop-io/sui-kit");
+
+// src/models/scallopUtils.ts
+var import_utils11 = require("@mysten/sui.js/utils");
+var import_sui_kit4 = require("@scallop-io/sui-kit");
+var import_pyth_sui_js = require("@pythnetwork/pyth-sui-js");
+
+// src/models/scallopQuery.ts
+var import_sui_kit3 = require("@scallop-io/sui-kit");
+
 // src/queries/coreQuery.ts
+var import_utils3 = require("@mysten/sui.js/utils");
 var import_bignumber2 = __toESM(require("bignumber.js"));
 var queryMarket = async (query, indexer = false) => {
   const coinPrices = await query.utils.getCoinPrices();
@@ -2187,9 +2262,9 @@ var queryMarket = async (query, indexer = false) => {
   const queryTarget = `${packageId}::market_query::market_data`;
   const args = [marketId];
   const queryResult = await query.cache.queryInspectTxn({ queryTarget, args });
-  const marketData = queryResult.events[0].parsedJson;
-  for (const pool of marketData.pools) {
-    const coinType = (0, import_utils2.normalizeStructTag)(pool.type.name);
+  const marketData = queryResult?.events[0].parsedJson;
+  for (const pool of marketData?.pools ?? []) {
+    const coinType = (0, import_utils3.normalizeStructTag)(pool.type.name);
     const poolCoinName = query.utils.parseCoinNameFromType(coinType);
     const coinPrice = coinPrices[poolCoinName] ?? 0;
     if (!SUPPORT_POOLS.includes(poolCoinName)) {
@@ -2238,8 +2313,8 @@ var queryMarket = async (query, indexer = false) => {
       ...calculatedMarketPoolData
     };
   }
-  for (const collateral of marketData.collaterals) {
-    const coinType = (0, import_utils2.normalizeStructTag)(collateral.type.name);
+  for (const collateral of marketData?.collaterals ?? []) {
+    const coinType = (0, import_utils3.normalizeStructTag)(collateral.type.name);
     const collateralCoinName = query.utils.parseCoinNameFromType(coinType);
     const coinPrice = coinPrices[collateralCoinName] ?? 0;
     if (!SUPPORT_COLLATERALS.includes(collateralCoinName)) {
@@ -2308,7 +2383,7 @@ var getMarketPools = async (query, poolCoinNames, indexer = false) => {
         query,
         poolCoinName,
         indexer,
-        marketObjectResponse.data,
+        marketObjectResponse?.data,
         coinPrices?.[poolCoinName]
       );
       if (marketPool) {
@@ -2335,7 +2410,7 @@ var getMarketPool = async (query, poolCoinName, indexer = false, marketObject, c
   const marketId = query.address.get("core.market");
   marketObject = marketObject || (await query.cache.queryGetObject(marketId, {
     showContent: true
-  })).data;
+  }))?.data;
   coinPrice = coinPrice || (await query.utils.getCoinPrices([poolCoinName]))?.[poolCoinName];
   if (marketObject) {
     if (marketObject.content && "fields" in marketObject.content) {
@@ -2351,6 +2426,8 @@ var getMarketPool = async (query, poolCoinName, indexer = false, marketObject, c
           }
         }
       });
+      if (!balanceSheetDynamicFieldObjectResponse)
+        return void 0;
       const balanceSheetDynamicFieldObject = balanceSheetDynamicFieldObjectResponse.data;
       if (balanceSheetDynamicFieldObject && balanceSheetDynamicFieldObject.content && "fields" in balanceSheetDynamicFieldObject.content) {
         const dynamicFields = balanceSheetDynamicFieldObject.content.fields;
@@ -2366,6 +2443,8 @@ var getMarketPool = async (query, poolCoinName, indexer = false, marketObject, c
           }
         }
       });
+      if (!borrowIndexDynamicFieldObjectResponse)
+        return void 0;
       const borrowIndexDynamicFieldObject = borrowIndexDynamicFieldObjectResponse.data;
       if (borrowIndexDynamicFieldObject && borrowIndexDynamicFieldObject.content && "fields" in borrowIndexDynamicFieldObject.content) {
         const dynamicFields = borrowIndexDynamicFieldObject.content.fields;
@@ -2381,6 +2460,8 @@ var getMarketPool = async (query, poolCoinName, indexer = false, marketObject, c
           }
         }
       });
+      if (!interestModelDynamicFieldObjectResponse)
+        return void 0;
       const interestModelDynamicFieldObject = interestModelDynamicFieldObjectResponse.data;
       if (interestModelDynamicFieldObject && interestModelDynamicFieldObject.content && "fields" in interestModelDynamicFieldObject.content) {
         const dynamicFields = interestModelDynamicFieldObject.content.fields;
@@ -2397,6 +2478,8 @@ var getMarketPool = async (query, poolCoinName, indexer = false, marketObject, c
           }
         }
       });
+      if (!borrowFeeDynamicFieldObjectResponse)
+        return void 0;
       const borrowFeeDynamicFieldObject = borrowFeeDynamicFieldObjectResponse.data;
       if (borrowFeeDynamicFieldObject && borrowFeeDynamicFieldObject.content && "fields" in borrowFeeDynamicFieldObject.content) {
         const dynamicFields = borrowFeeDynamicFieldObject.content.fields;
@@ -2479,7 +2562,7 @@ var getMarketCollaterals = async (query, collateralCoinNames, indexer = false) =
         query,
         collateralCoinName,
         indexer,
-        marketObjectResponse.data,
+        marketObjectResponse?.data,
         coinPrices?.[collateralCoinName]
       );
       if (marketCollateral) {
@@ -2504,7 +2587,7 @@ var getMarketCollateral = async (query, collateralCoinName, indexer = false, mar
   const marketId = query.address.get("core.market");
   marketObject = marketObject || (await query.cache.queryGetObject(marketId, {
     showContent: true
-  })).data;
+  }))?.data;
   coinPrice = coinPrice || (await query.utils.getCoinPrices([collateralCoinName]))?.[collateralCoinName];
   if (marketObject) {
     if (marketObject.content && "fields" in marketObject.content) {
@@ -2520,6 +2603,8 @@ var getMarketCollateral = async (query, collateralCoinName, indexer = false, mar
           }
         }
       });
+      if (!riskModelDynamicFieldObjectResponse)
+        return void 0;
       const riskModelDynamicFieldObject = riskModelDynamicFieldObjectResponse.data;
       if (riskModelDynamicFieldObject && riskModelDynamicFieldObject.content && "fields" in riskModelDynamicFieldObject.content) {
         const dynamicFields = riskModelDynamicFieldObject.content.fields;
@@ -2535,6 +2620,8 @@ var getMarketCollateral = async (query, collateralCoinName, indexer = false, mar
           }
         }
       });
+      if (!collateralStatDynamicFieldObjectResponse)
+        return void 0;
       const collateralStatDynamicFieldObject = collateralStatDynamicFieldObjectResponse.data;
       if (collateralStatDynamicFieldObject && collateralStatDynamicFieldObject.content && "fields" in collateralStatDynamicFieldObject.content) {
         const dynamicFields = collateralStatDynamicFieldObject.content.fields;
@@ -2589,6 +2676,8 @@ var getObligations = async (query, ownerAddress) => {
       },
       cursor: nextCursor
     });
+    if (!paginatedKeyObjectsResponse)
+      continue;
     keyObjectsResponse.push(...paginatedKeyObjectsResponse.data);
     if (paginatedKeyObjectsResponse.hasNextPage && paginatedKeyObjectsResponse.nextCursor) {
       hasNextPage = true;
@@ -2619,7 +2708,7 @@ var getObligationLocked = async (query, obligationId) => {
     { showContent: true }
   );
   let obligationLocked = false;
-  if (obligationObjectResponse.data && obligationObjectResponse?.data?.content?.dataType === "moveObject" && "lock_key" in obligationObjectResponse.data.content.fields) {
+  if (obligationObjectResponse?.data && obligationObjectResponse?.data?.content?.dataType === "moveObject" && "lock_key" in obligationObjectResponse.data.content.fields) {
     obligationLocked = Boolean(
       obligationObjectResponse.data.content.fields.lock_key
     );
@@ -2634,7 +2723,7 @@ var queryObligation = async (query, obligationId) => {
     { queryTarget, args }
     // txBlock
   );
-  return queryResult.events[0].parsedJson;
+  return queryResult?.events[0].parsedJson;
 };
 var getCoinAmounts = async (query, assetCoinNames, ownerAddress) => {
   assetCoinNames = assetCoinNames || [...SUPPORT_POOLS];
@@ -2711,7 +2800,7 @@ var getFlashLoanFees = async (query, assetNames) => {
     const marketObjectRes = await query.cache.queryGetObject(marketObjectId, {
       showContent: true
     });
-    if (marketObjectRes.data?.content?.dataType !== "moveObject")
+    if (marketObjectRes?.data?.content?.dataType !== "moveObject")
       throw new Error("Failed to get market object");
     const vault = marketObjectRes.data.content.fields.vault;
     const flashloanFeesTableId = vault.fields.flash_loan_fees.fields.table.fields.id.id;
@@ -2719,10 +2808,10 @@ var getFlashLoanFees = async (query, assetNames) => {
       parentId: flashloanFeesTableId,
       limit: 50
     });
-    const dynamicFieldObjectIds = balanceSheetDynamicFields.data.filter((field) => {
+    const dynamicFieldObjectIds = balanceSheetDynamicFields?.data.filter((field) => {
       const assetType = field.name.value.name;
       return !!assetTypeMap[assetType];
-    }).map((field) => field.objectId);
+    }).map((field) => field.objectId) ?? [];
     flashloanFeeObjects.push(
       ...await query.cache.queryGetObjects(dynamicFieldObjectIds, {
         showContent: true
@@ -2744,7 +2833,7 @@ var getFlashLoanFees = async (query, assetNames) => {
 };
 
 // src/queries/spoolQuery.ts
-var import_utils4 = require("@mysten/sui.js/utils");
+var import_utils5 = require("@mysten/sui.js/utils");
 var getSpools = async (query, stakeMarketCoinNames, indexer = false) => {
   stakeMarketCoinNames = stakeMarketCoinNames || [...SUPPORT_SPOOLS];
   const stakeCoinNames = stakeMarketCoinNames.map(
@@ -2901,6 +2990,8 @@ var getStakeAccounts = async (query, ownerAddress) => {
       },
       cursor: nextCursor
     });
+    if (!paginatedStakeObjectsResponse)
+      continue;
     stakeObjectsResponse.push(...paginatedStakeObjectsResponse.data);
     if (paginatedStakeObjectsResponse.hasNextPage && paginatedStakeObjectsResponse.nextCursor) {
       hasNextPage = true;
@@ -2942,89 +3033,89 @@ var getStakeAccounts = async (query, ownerAddress) => {
       const index = Number(fields.index);
       const points = Number(fields.points);
       const totalPoints = Number(fields.total_points);
-      if ((0, import_utils4.normalizeStructTag)(type) === stakeMarketCoinTypes.seth) {
+      if ((0, import_utils5.normalizeStructTag)(type) === stakeMarketCoinTypes.seth) {
         stakeAccounts.seth.push({
           id,
-          type: (0, import_utils4.normalizeStructTag)(type),
+          type: (0, import_utils5.normalizeStructTag)(type),
           stakePoolId,
-          stakeType: (0, import_utils4.normalizeStructTag)(stakeType),
+          stakeType: (0, import_utils5.normalizeStructTag)(stakeType),
           staked,
           index,
           points,
           totalPoints
         });
-      } else if ((0, import_utils4.normalizeStructTag)(type) === stakeMarketCoinTypes.ssui) {
+      } else if ((0, import_utils5.normalizeStructTag)(type) === stakeMarketCoinTypes.ssui) {
         stakeAccounts.ssui.push({
           id,
-          type: (0, import_utils4.normalizeStructTag)(type),
+          type: (0, import_utils5.normalizeStructTag)(type),
           stakePoolId,
-          stakeType: (0, import_utils4.normalizeStructTag)(stakeType),
+          stakeType: (0, import_utils5.normalizeStructTag)(stakeType),
           staked,
           index,
           points,
           totalPoints
         });
-      } else if ((0, import_utils4.normalizeStructTag)(type) === stakeMarketCoinTypes.susdc) {
+      } else if ((0, import_utils5.normalizeStructTag)(type) === stakeMarketCoinTypes.susdc) {
         stakeAccounts.susdc.push({
           id,
-          type: (0, import_utils4.normalizeStructTag)(type),
+          type: (0, import_utils5.normalizeStructTag)(type),
           stakePoolId,
-          stakeType: (0, import_utils4.normalizeStructTag)(stakeType),
+          stakeType: (0, import_utils5.normalizeStructTag)(stakeType),
           staked,
           index,
           points,
           totalPoints
         });
-      } else if ((0, import_utils4.normalizeStructTag)(type) === stakeMarketCoinTypes.susdt) {
+      } else if ((0, import_utils5.normalizeStructTag)(type) === stakeMarketCoinTypes.susdt) {
         stakeAccounts.susdt.push({
           id,
-          type: (0, import_utils4.normalizeStructTag)(type),
+          type: (0, import_utils5.normalizeStructTag)(type),
           stakePoolId,
-          stakeType: (0, import_utils4.normalizeStructTag)(stakeType),
+          stakeType: (0, import_utils5.normalizeStructTag)(stakeType),
           staked,
           index,
           points,
           totalPoints
         });
-      } else if ((0, import_utils4.normalizeStructTag)(type) === stakeMarketCoinTypes.scetus) {
+      } else if ((0, import_utils5.normalizeStructTag)(type) === stakeMarketCoinTypes.scetus) {
         stakeAccounts.scetus.push({
           id,
-          type: (0, import_utils4.normalizeStructTag)(type),
+          type: (0, import_utils5.normalizeStructTag)(type),
           stakePoolId,
-          stakeType: (0, import_utils4.normalizeStructTag)(stakeType),
+          stakeType: (0, import_utils5.normalizeStructTag)(stakeType),
           staked,
           index,
           points,
           totalPoints
         });
-      } else if ((0, import_utils4.normalizeStructTag)(type) === stakeMarketCoinTypes.safsui) {
+      } else if ((0, import_utils5.normalizeStructTag)(type) === stakeMarketCoinTypes.safsui) {
         stakeAccounts.safsui.push({
           id,
-          type: (0, import_utils4.normalizeStructTag)(type),
+          type: (0, import_utils5.normalizeStructTag)(type),
           stakePoolId,
-          stakeType: (0, import_utils4.normalizeStructTag)(stakeType),
+          stakeType: (0, import_utils5.normalizeStructTag)(stakeType),
           staked,
           index,
           points,
           totalPoints
         });
-      } else if ((0, import_utils4.normalizeStructTag)(type) === stakeMarketCoinTypes.shasui) {
+      } else if ((0, import_utils5.normalizeStructTag)(type) === stakeMarketCoinTypes.shasui) {
         stakeAccounts.shasui.push({
           id,
-          type: (0, import_utils4.normalizeStructTag)(type),
+          type: (0, import_utils5.normalizeStructTag)(type),
           stakePoolId,
-          stakeType: (0, import_utils4.normalizeStructTag)(stakeType),
+          stakeType: (0, import_utils5.normalizeStructTag)(stakeType),
           staked,
           index,
           points,
           totalPoints
         });
-      } else if ((0, import_utils4.normalizeStructTag)(type) === stakeMarketCoinTypes.svsui) {
+      } else if ((0, import_utils5.normalizeStructTag)(type) === stakeMarketCoinTypes.svsui) {
         stakeAccounts.svsui.push({
           id,
-          type: (0, import_utils4.normalizeStructTag)(type),
+          type: (0, import_utils5.normalizeStructTag)(type),
           stakePoolId,
-          stakeType: (0, import_utils4.normalizeStructTag)(stakeType),
+          stakeType: (0, import_utils5.normalizeStructTag)(stakeType),
           staked,
           index,
           points,
@@ -3042,7 +3133,7 @@ var getStakePool = async (query, marketCoinName) => {
     showContent: true,
     showType: true
   });
-  if (stakePoolObjectResponse.data) {
+  if (stakePoolObjectResponse?.data) {
     const stakePoolObject = stakePoolObjectResponse.data;
     const id = stakePoolObject.objectId;
     const type = stakePoolObject.type;
@@ -3060,13 +3151,13 @@ var getStakePool = async (query, marketCoinName) => {
       const lastUpdate = Number(fields.last_update);
       stakePool = {
         id,
-        type: (0, import_utils4.normalizeStructTag)(type),
+        type: (0, import_utils5.normalizeStructTag)(type),
         maxPoint,
         distributedPoint,
         pointPerPeriod,
         period,
         maxStake,
-        stakeType: (0, import_utils4.normalizeStructTag)(stakeType),
+        stakeType: (0, import_utils5.normalizeStructTag)(stakeType),
         totalStaked,
         index,
         createdAt,
@@ -3088,7 +3179,7 @@ var getStakeRewardPool = async (query, marketCoinName) => {
       showType: true
     }
   );
-  if (stakeRewardPoolObjectResponse.data) {
+  if (stakeRewardPoolObjectResponse?.data) {
     const stakeRewardPoolObject = stakeRewardPoolObjectResponse.data;
     const id = stakeRewardPoolObject.objectId;
     const type = stakeRewardPoolObject.type;
@@ -3103,7 +3194,7 @@ var getStakeRewardPool = async (query, marketCoinName) => {
       const claimedRewards = Number(rewardPoolFields.claimed_rewards);
       stakeRewardPool = {
         id,
-        type: (0, import_utils4.normalizeStructTag)(type),
+        type: (0, import_utils5.normalizeStructTag)(type),
         stakePoolId,
         ratioNumerator,
         ratioDenominator,
@@ -3116,7 +3207,7 @@ var getStakeRewardPool = async (query, marketCoinName) => {
 };
 
 // src/queries/borrowIncentiveQuery.ts
-var import_utils6 = require("@mysten/sui.js/utils");
+var import_utils7 = require("@mysten/sui.js/utils");
 var import_bignumber3 = __toESM(require("bignumber.js"));
 var queryBorrowIncentivePools = async (query, borrowIncentiveCoinNames, indexer = false) => {
   borrowIncentiveCoinNames = borrowIncentiveCoinNames || [
@@ -3148,11 +3239,11 @@ var queryBorrowIncentivePools = async (query, borrowIncentiveCoinNames, indexer
   const queryTarget = `${queryPkgId}::incentive_pools_query::incentive_pools_data`;
   const args = [incentivePoolsId];
   const queryResult = await query.cache.queryInspectTxn({ queryTarget, args });
-  const borrowIncentivePoolsQueryData = queryResult.events[0].parsedJson;
-  for (const pool of borrowIncentivePoolsQueryData.incentive_pools) {
+  const borrowIncentivePoolsQueryData = queryResult?.events[0].parsedJson;
+  for (const pool of borrowIncentivePoolsQueryData?.incentive_pools ?? []) {
     const borrowIncentivePoolPoints = {};
     const parsedBorrowIncentivePoolData = parseOriginBorrowIncentivePoolData(pool);
-    const poolCoinType = (0, import_utils6.normalizeStructTag)(pool.pool_type.name);
+    const poolCoinType = (0, import_utils7.normalizeStructTag)(pool.pool_type.name);
     const poolCoinName = query.utils.parseCoinNameFromType(
       poolCoinType
     );
@@ -3164,7 +3255,7 @@ var queryBorrowIncentivePools = async (query, borrowIncentiveCoinNames, indexer
     for (const [coinName, poolPoint] of Object.entries(
       parsedBorrowIncentivePoolData.poolPoints
     )) {
-      const rewardCoinType = (0, import_utils6.normalizeStructTag)(poolPoint.pointType);
+      const rewardCoinType = (0, import_utils7.normalizeStructTag)(poolPoint.pointType);
       const rewardCoinName = query.utils.parseCoinNameFromType(
         rewardCoinType
       );
@@ -3220,9 +3311,9 @@ var queryBorrowIncentiveAccounts = async (query, obligationId, borrowIncentiveCo
   const queryTarget = `${queryPkgId}::incentive_account_query::incentive_account_data`;
   const args = [incentiveAccountsId, obligationId];
   const queryResult = await query.cache.queryInspectTxn({ queryTarget, args });
-  const borrowIncentiveAccountsQueryData = queryResult.events[0].parsedJson;
+  const borrowIncentiveAccountsQueryData = queryResult?.events[0].parsedJson;
   const borrowIncentiveAccounts = Object.values(
-    borrowIncentiveAccountsQueryData.pool_records
+    borrowIncentiveAccountsQueryData?.pool_records ?? []
   ).reduce((accounts, accountData) => {
     const parsedBorrowIncentiveAccount = parseOriginBorrowIncentiveAccountData(accountData);
     const poolType = parsedBorrowIncentiveAccount.poolType;
@@ -3244,7 +3335,7 @@ var getBindedObligationId = async (query, veScaKeyId) => {
       showContent: true
     }
   );
-  if (incentivePoolsResponse.data?.content?.dataType !== "moveObject")
+  if (incentivePoolsResponse?.data?.content?.dataType !== "moveObject")
     return null;
   const incentivePoolFields = incentivePoolsResponse.data.content.fields;
   const veScaBindTableId = incentivePoolFields.ve_sca_bind.fields.id.id;
@@ -3256,7 +3347,7 @@ var getBindedObligationId = async (query, veScaKeyId) => {
       value: veScaKeyId
     }
   });
-  if (veScaBindTableResponse.data?.content?.dataType !== "moveObject")
+  if (veScaBindTableResponse?.data?.content?.dataType !== "moveObject")
     return null;
   const veScaBindTableFields = veScaBindTableResponse.data.content.fields;
   const obligationId = veScaBindTableFields.value.fields.id;
@@ -3274,7 +3365,7 @@ var getBindedVeScaKey = async (query, obliationId) => {
       showContent: true
     }
   );
-  if (incentiveAccountsObject.data?.content?.dataType !== "moveObject")
+  if (incentiveAccountsObject?.data?.content?.dataType !== "moveObject")
     return null;
   const incentiveAccountsTableId = incentiveAccountsObject.data.content.fields.accounts.fields.id.id;
   const bindedIncentiveAcc = await query.cache.queryGetDynamicFieldObject({
@@ -3284,7 +3375,7 @@ var getBindedVeScaKey = async (query, obliationId) => {
       value: obliationId
     }
   });
-  if (bindedIncentiveAcc.data?.content?.dataType !== "moveObject")
+  if (bindedIncentiveAcc?.data?.content?.dataType !== "moveObject")
     return null;
   const bindedIncentiveAccFields = bindedIncentiveAcc.data.content.fields;
   return bindedIncentiveAccFields.value.fields.binded_ve_sca_key?.fields.id ?? null;
@@ -3295,7 +3386,7 @@ var getPythPrice = async (query, assetCoinName, priceFeedObject) => {
   const pythFeedObjectId = query.address.get(
     `core.coins.${assetCoinName}.oracle.pyth.feedObject`
   );
-  priceFeedObject = priceFeedObject || (await query.cache.queryGetObject(pythFeedObjectId, { showContent: true })).data;
+  priceFeedObject = priceFeedObject || (await query.cache.queryGetObject(pythFeedObjectId, { showContent: true }))?.data;
   if (priceFeedObject) {
     const priceFeedPoolObject = priceFeedObject;
     if (priceFeedPoolObject.content && "fields" in priceFeedPoolObject.content) {
@@ -3583,7 +3674,7 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
   let totalBorrowedValue = (0, import_bignumber4.default)(0);
   let totalBorrowedValueWithWeight = (0, import_bignumber4.default)(0);
   for (const assetCoinName of collateralAssetCoinNames) {
-    const collateral = obligationQuery.collaterals.find((collateral2) => {
+    const collateral = obligationQuery?.collaterals.find((collateral2) => {
       const collateralCoinName = query.utils.parseCoinNameFromType(
         collateral2.type.name
       );
@@ -3643,7 +3734,7 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
     .../* @__PURE__ */ new Set([...Object.values(market.pools).map((pool) => pool.coinName)])
   ];
   for (const assetCoinName of borrowAssetCoinNames) {
-    const debt = obligationQuery.debts.find((debt2) => {
+    const debt = obligationQuery?.debts.find((debt2) => {
       const poolCoinName = query.utils.parseCoinNameFromType(
         debt2.type.name
       );
@@ -3903,8 +3994,10 @@ var getVescaKeys = async (query, ownerAddress) => {
       },
       cursor: nextCursor
     });
+    if (!paginatedKeyObjectsResponse)
+      continue;
     keyObjectsResponse.push(...paginatedKeyObjectsResponse.data);
-    if (paginatedKeyObjectsResponse.hasNextPage && paginatedKeyObjectsResponse.nextCursor) {
+    if (paginatedKeyObjectsResponse && paginatedKeyObjectsResponse.hasNextPage && paginatedKeyObjectsResponse.nextCursor) {
       hasNextPage = true;
       nextCursor = paginatedKeyObjectsResponse.nextCursor;
     } else {
@@ -3947,6 +4040,8 @@ var getVeSca = async (query, veScaKey, ownerAddress) => {
       value: typeof veScaKey === "string" ? veScaKey : veScaKey.objectId
     }
   });
+  if (!veScaDynamicFieldObjectResponse)
+    return void 0;
   const veScaDynamicFieldObject = veScaDynamicFieldObjectResponse.data;
   if (veScaDynamicFieldObject && veScaDynamicFieldObject.content && veScaDynamicFieldObject.content.dataType === "moveObject" && "fields" in veScaDynamicFieldObject.content) {
     const dynamicFields = veScaDynamicFieldObject.content.fields.value.fields;
@@ -3981,7 +4076,7 @@ var getTotalVeScaTreasuryAmount = async (query, veScaTreasury) => {
   const resolvedRefreshArgs = await Promise.all(
     refreshArgs.map(async (arg) => {
       if (typeof arg === "string") {
-        return (await query.cache.queryGetObject(arg, { showContent: true })).data;
+        return (await query.cache.queryGetObject(arg, { showContent: true }))?.data;
       }
       return arg;
     })
@@ -3989,7 +4084,7 @@ var getTotalVeScaTreasuryAmount = async (query, veScaTreasury) => {
   const resolvedVeScaAmountArgs = await Promise.all(
     veScaAmountArgs.map(async (arg) => {
       if (typeof arg === "string") {
-        return (await query.cache.queryGetObject(arg, { showContent: true })).data;
+        return (await query.cache.queryGetObject(arg, { showContent: true }))?.data;
       }
       return arg;
     })
@@ -4000,7 +4095,7 @@ var getTotalVeScaTreasuryAmount = async (query, veScaTreasury) => {
   const txBytes = await txb.txBlock.build({
     client: query.suiKit.client(),
     onlyTransactionKind: true,
-    protocolConfig: await query.cache.getProtocolConfig()
+    protocolConfig: await query.cache.getProtocolConfig() ?? void 0
   });
   const res = await query.cache.queryClient.fetchQuery({
     queryKey: [
@@ -4053,7 +4148,7 @@ var queryVeScaKeyIdFromReferralBindings = async (query, refereeAddress) => {
       value: refereeAddress
     }
   });
-  if (referralBindResponse.data?.content?.dataType !== "moveObject")
+  if (referralBindResponse?.data?.content?.dataType !== "moveObject")
     return null;
   const fields = referralBindResponse.data.content.fields;
   return fields.value;
@@ -4077,7 +4172,7 @@ var getLoyaltyProgramInformations = async (query, veScaKey) => {
   const rewardPoolObject = await query.cache.queryGetObject(rewardPool, {
     showContent: true
   });
-  if (rewardPoolObject.data?.content?.dataType !== "moveObject")
+  if (rewardPoolObject?.data?.content?.dataType !== "moveObject")
     return null;
   const rewardPoolFields = rewardPoolObject.data.content.fields;
   const { isClaimEnabled, totalPoolReward } = rewardPoolFieldsZod.parse(
@@ -4101,7 +4196,7 @@ var getLoyaltyProgramInformations = async (query, veScaKey) => {
       value: typeof veScaKey === "string" ? veScaKey : veScaKey.objectId
     }
   });
-  if (userRewardObject.data?.content?.dataType !== "moveObject")
+  if (userRewardObject?.data?.content?.dataType !== "moveObject")
     return result;
   const userRewardFields = userRewardObject.data.content.fields;
   result.pendingReward = userRewardFieldsZod.parse(
@@ -4295,7 +4390,7 @@ var getSCoinTotalSupply = async (query, sCoinName) => {
     args,
     typeArgs
   });
-  const results = queryResults.results;
+  const results = queryResults?.results;
   if (results && results[0].returnValues) {
     const value = Uint8Array.from(results[0].returnValues[0][0]);
     const type = results[0].returnValues[0][1];
@@ -4329,7 +4424,7 @@ var getSCoinAmount = async (query, sCoinName, ownerAddress) => {
 };
 
 // src/models/scallopQuery.ts
-var import_utils9 = require("@mysten/sui.js/utils");
+var import_utils10 = require("@mysten/sui.js/utils");
 var ScallopQuery = class {
   constructor(params, instance) {
     this.params = params;
@@ -4349,7 +4444,7 @@ var ScallopQuery = class {
       query: this
     });
     this.indexer = new ScallopIndexer(this.params, { cache: this.cache });
-    this.walletAddress = (0, import_utils9.normalizeSuiAddress)(
+    this.walletAddress = (0, import_utils10.normalizeSuiAddress)(
       params?.walletAddress || this.suiKit.currentAddress()
     );
   }
@@ -4877,7 +4972,7 @@ var ScallopUtils = class {
       throw Error(`Coin ${coinName} is not supported`);
     }
     if (coinName === "sui")
-      return (0, import_utils10.normalizeStructTag)(`${coinPackageId}::sui::SUI`);
+      return (0, import_utils11.normalizeStructTag)(`${coinPackageId}::sui::SUI`);
     const wormHolePckageIds = [
       this._address.get("core.coins.usdc.id") ?? wormholeCoinIds.usdc,
       this._address.get("core.coins.usdt.id") ?? wormholeCoinIds.usdt,
@@ -4952,7 +5047,7 @@ var ScallopUtils = class {
     return `${protocolObjectId}::reserve::MarketCoin<${coinType}>`;
   }
   parseCoinNameFromType(coinType) {
-    coinType = (0, import_utils10.normalizeStructTag)(coinType);
+    coinType = (0, import_utils11.normalizeStructTag)(coinType);
     const coinTypeRegex = new RegExp(`((0x[^:]+::[^:]+::[^<>]+))(?![^<>]*<)`);
     const coinTypeMatch = coinType.match(coinTypeRegex);
     const isMarketCoinType = coinType.includes("reserve::MarketCoin");
@@ -5016,7 +5111,7 @@ var ScallopUtils = class {
    * @param coinType - The coin type, default is 0x2::SUI::SUI.
    * @return The selected transaction coin arguments.
    */
-  async selectCoins(amount, coinType = import_utils10.SUI_TYPE_ARG, ownerAddress) {
+  async selectCoins(amount, coinType = import_utils11.SUI_TYPE_ARG, ownerAddress) {
     ownerAddress = ownerAddress || this._suiKit.currentAddress();
     const coins = await this._suiKit.suiInteractor.selectCoins(
       ownerAddress,
@@ -5025,6 +5120,26 @@ var ScallopUtils = class {
     );
     return coins;
   }
+  /**
+   * Merge coins with type `coinType` to dest
+   * @param txBlock
+   * @param dest
+   * @param coinType
+   * @param sender
+   */
+  async mergeSimilarCoins(txBlock, dest, coinType, sender) {
+    try {
+      const existingSCoin = await this.selectCoins(
+        Number.MAX_SAFE_INTEGER,
+        coinType,
+        sender
+      );
+      if (existingSCoin.length > 0) {
+        txBlock.mergeCoins(dest, existingSCoin);
+      }
+    } catch (e) {
+    }
+  }
   /**
    * Get all asset coin names in the obligation record by obligation id.
    *
@@ -5037,12 +5152,12 @@ var ScallopUtils = class {
    */
   async getObligationCoinNames(obligationId) {
     const obligation = await queryObligation(this._query, obligationId);
-    const collateralCoinTypes = obligation.collaterals.map((collateral) => {
+    const collateralCoinTypes = obligation?.collaterals.map((collateral) => {
       return `0x${collateral.type.name}`;
-    });
-    const debtCoinTypes = obligation.debts.map((debt) => {
+    }) ?? [];
+    const debtCoinTypes = obligation?.debts.map((debt) => {
       return `0x${debt.type.name}`;
-    });
+    }) ?? [];
     const obligationCoinTypes = [
       .../* @__PURE__ */ new Set([...collateralCoinTypes, ...debtCoinTypes])
     ];
@@ -5197,16 +5312,16 @@ var ScallopUtils = class {
 };
 
 // src/models/scallopBuilder.ts
-var import_utils23 = require("@mysten/sui.js/utils");
+var import_utils24 = require("@mysten/sui.js/utils");
 var import_sui_kit12 = require("@scallop-io/sui-kit");
 
 // src/builders/coreBuilder.ts
 var import_transactions = require("@mysten/sui.js/transactions");
-var import_utils13 = require("@mysten/sui.js/utils");
+var import_utils14 = require("@mysten/sui.js/utils");
 var import_sui_kit5 = require("@scallop-io/sui-kit");
 
 // src/builders/oracle.ts
-var import_utils12 = require("@mysten/sui.js/utils");
+var import_utils13 = require("@mysten/sui.js/utils");
 var import_pyth_sui_js2 = require("@pythnetwork/pyth-sui-js");
 var updateOracles = async (builder, txBlock, assetCoinNames) => {
   assetCoinNames = assetCoinNames ?? [
@@ -5320,27 +5435,27 @@ var priceUpdateRequest = (txBlock, packageId, xOracleId, coinType) => {
 var confirmPriceUpdateRequest = (txBlock, packageId, xOracleId, request, coinType) => {
   const target = `${packageId}::x_oracle::confirm_price_update_request`;
   const typeArgs = [coinType];
-  txBlock.moveCall(target, [xOracleId, request, import_utils12.SUI_CLOCK_OBJECT_ID], typeArgs);
+  txBlock.moveCall(target, [xOracleId, request, import_utils13.SUI_CLOCK_OBJECT_ID], typeArgs);
   return txBlock;
 };
 var updateSupraPrice = (txBlock, packageId, request, holderId, registryId, coinType) => {
   txBlock.moveCall(
     `${packageId}::rule::set_price`,
-    [request, holderId, registryId, import_utils12.SUI_CLOCK_OBJECT_ID],
+    [request, holderId, registryId, import_utils13.SUI_CLOCK_OBJECT_ID],
     [coinType]
   );
 };
 var updateSwitchboardPrice = (txBlock, packageId, request, aggregatorId, registryId, coinType) => {
   txBlock.moveCall(
     `${packageId}::rule::set_price`,
-    [request, aggregatorId, registryId, import_utils12.SUI_CLOCK_OBJECT_ID],
+    [request, aggregatorId, registryId, import_utils13.SUI_CLOCK_OBJECT_ID],
     [coinType]
   );
 };
 var updatePythPrice = (txBlock, packageId, request, stateId, feedObjectId, registryId, coinType) => {
   txBlock.moveCall(
     `${packageId}::rule::set_price`,
-    [request, stateId, feedObjectId, registryId, import_utils12.SUI_CLOCK_OBJECT_ID],
+    [request, stateId, feedObjectId, registryId, import_utils13.SUI_CLOCK_OBJECT_ID],
     [coinType]
   );
 };
@@ -5411,7 +5526,7 @@ var generateCoreNormalMethod = ({
           coreIds.coinDecimalsRegistry,
           amount,
           coreIds.xOracle,
-          import_utils13.SUI_CLOCK_OBJECT_ID
+          import_utils14.SUI_CLOCK_OBJECT_ID
         ],
         [coinType]
       );
@@ -5420,7 +5535,7 @@ var generateCoreNormalMethod = ({
       const coinType = builder.utils.parseCoinType(poolCoinName);
       return txBlock.moveCall(
         `${coreIds.protocolPkg}::mint::mint`,
-        [coreIds.version, coreIds.market, coin, import_utils13.SUI_CLOCK_OBJECT_ID],
+        [coreIds.version, coreIds.market, coin, import_utils14.SUI_CLOCK_OBJECT_ID],
         [coinType]
       );
     },
@@ -5428,7 +5543,7 @@ var generateCoreNormalMethod = ({
       const coinType = builder.utils.parseCoinType(poolCoinName);
       return txBlock.moveCall(
         `${coreIds.protocolPkg}::mint::mint_entry`,
-        [coreIds.version, coreIds.market, coin, import_utils13.SUI_CLOCK_OBJECT_ID],
+        [coreIds.version, coreIds.market, coin, import_utils14.SUI_CLOCK_OBJECT_ID],
         [coinType]
       );
     },
@@ -5436,7 +5551,7 @@ var generateCoreNormalMethod = ({
       const coinType = builder.utils.parseCoinType(poolCoinName);
       return txBlock.moveCall(
         `${coreIds.protocolPkg}::redeem::redeem`,
-        [coreIds.version, coreIds.market, marketCoin, import_utils13.SUI_CLOCK_OBJECT_ID],
+        [coreIds.version, coreIds.market, marketCoin, import_utils14.SUI_CLOCK_OBJECT_ID],
         [coinType]
       );
     },
@@ -5444,7 +5559,7 @@ var generateCoreNormalMethod = ({
       const coinType = builder.utils.parseCoinType(poolCoinName);
       return txBlock.moveCall(
         `${coreIds.protocolPkg}::redeem::redeem_entry`,
-        [coreIds.version, coreIds.market, marketCoin, import_utils13.SUI_CLOCK_OBJECT_ID],
+        [coreIds.version, coreIds.market, marketCoin, import_utils14.SUI_CLOCK_OBJECT_ID],
         [coinType]
       );
     },
@@ -5460,7 +5575,7 @@ var generateCoreNormalMethod = ({
           coreIds.coinDecimalsRegistry,
           amount,
           coreIds.xOracle,
-          import_utils13.SUI_CLOCK_OBJECT_ID
+          import_utils14.SUI_CLOCK_OBJECT_ID
         ],
         [coinType]
       );
@@ -5478,7 +5593,7 @@ var generateCoreNormalMethod = ({
           borrowReferral,
           amount,
           coreIds.xOracle,
-          import_utils13.SUI_CLOCK_OBJECT_ID
+          import_utils14.SUI_CLOCK_OBJECT_ID
         ],
         [coinType, referralWitnessType]
       );
@@ -5495,7 +5610,7 @@ var generateCoreNormalMethod = ({
           coreIds.coinDecimalsRegistry,
           amount,
           coreIds.xOracle,
-          import_utils13.SUI_CLOCK_OBJECT_ID
+          import_utils14.SUI_CLOCK_OBJECT_ID
         ],
         [coinType]
       );
@@ -5509,7 +5624,7 @@ var generateCoreNormalMethod = ({
           obligation,
           coreIds.market,
           coin,
-          import_utils13.SUI_CLOCK_OBJECT_ID
+          import_utils14.SUI_CLOCK_OBJECT_ID
         ],
         [coinType]
       );
@@ -5744,7 +5859,7 @@ var newCoreTxBlock = (builder, initTxBlock) => {
 
 // src/builders/spoolBuilder.ts
 var import_transactions2 = require("@mysten/sui.js/transactions");
-var import_utils15 = require("@mysten/sui.js/utils");
+var import_utils16 = require("@mysten/sui.js/utils");
 var import_sui_kit6 = require("@scallop-io/sui-kit");
 var requireStakeAccountIds = async (...params) => {
   const [builder, txBlock, stakeMarketCoinName, stakeAccountId] = params;
@@ -5799,7 +5914,7 @@ var generateSpoolNormalMethod = ({
       );
       return txBlock.moveCall(
         `${spoolIds.spoolPkg}::user::new_spool_account`,
-        [stakePoolId, import_utils15.SUI_CLOCK_OBJECT_ID],
+        [stakePoolId, import_utils16.SUI_CLOCK_OBJECT_ID],
         [marketCoinType]
       );
     },
@@ -5810,7 +5925,7 @@ var generateSpoolNormalMethod = ({
       );
       txBlock.moveCall(
         `${spoolIds.spoolPkg}::user::stake`,
-        [stakePoolId, stakeAccount, coin, import_utils15.SUI_CLOCK_OBJECT_ID],
+        [stakePoolId, stakeAccount, coin, import_utils16.SUI_CLOCK_OBJECT_ID],
         [marketCoinType]
       );
     },
@@ -5821,7 +5936,7 @@ var generateSpoolNormalMethod = ({
       );
       return txBlock.moveCall(
         `${spoolIds.spoolPkg}::user::unstake`,
-        [stakePoolId, stakeAccount, amount, import_utils15.SUI_CLOCK_OBJECT_ID],
+        [stakePoolId, stakeAccount, amount, import_utils16.SUI_CLOCK_OBJECT_ID],
         [marketCoinType]
       );
     },
@@ -5837,7 +5952,7 @@ var generateSpoolNormalMethod = ({
       const rewardCoinType = builder.utils.parseCoinType(rewardCoinName);
       return txBlock.moveCall(
         `${spoolIds.spoolPkg}::user::redeem_rewards`,
-        [stakePoolId, rewardPoolId, stakeAccount, import_utils15.SUI_CLOCK_OBJECT_ID],
+        [stakePoolId, rewardPoolId, stakeAccount, import_utils16.SUI_CLOCK_OBJECT_ID],
         [marketCoinType, rewardCoinType]
       );
     }
@@ -5909,7 +6024,7 @@ var generateSpoolQuickMethod = ({
           toTransfer.push(marketCoin);
         }
         amount -= amountToUnstake;
-        if (amount === 0)
+        if (amount <= 0)
           break;
       }
       if (toTransfer.length > 0) {
@@ -5917,31 +6032,6 @@ var generateSpoolQuickMethod = ({
         if (toTransfer.length > 1) {
           txBlock.mergeCoins(mergedCoin, toTransfer.slice(1));
         }
-        if (returnSCoin) {
-          try {
-            const existingCoins = await builder.utils.selectCoins(
-              Number.MAX_SAFE_INTEGER,
-              builder.utils.parseSCoinType(stakeMarketCoinName),
-              requireSender(txBlock)
-            );
-            if (existingCoins.length > 0) {
-              txBlock.mergeCoins(mergedCoin, existingCoins);
-            }
-          } catch (e) {
-          }
-        } else {
-          try {
-            const existingCoins = await builder.utils.selectCoins(
-              Number.MAX_SAFE_INTEGER,
-              builder.utils.parseMarketCoinType(stakeMarketCoinName),
-              requireSender(txBlock)
-            );
-            if (existingCoins.length > 0) {
-              txBlock.mergeCoins(mergedCoin, existingCoins);
-            }
-          } catch (e) {
-          }
-        }
         return mergedCoin;
       }
     },
@@ -5991,7 +6081,7 @@ var newSpoolTxBlock = (builder, initTxBlock) => {
 
 // src/builders/borrowIncentiveBuilder.ts
 var import_transactions3 = require("@mysten/sui.js/transactions");
-var import_utils18 = require("@mysten/sui.js/utils");
+var import_utils19 = require("@mysten/sui.js/utils");
 var import_sui_kit8 = require("@scallop-io/sui-kit");
 
 // src/builders/vescaBuilder.ts
@@ -6317,7 +6407,7 @@ var generateBorrowIncentiveNormalMethod = ({ builder, txBlock }) => {
           obligationKey,
           obligationId,
           borrowIncentiveIds.obligationAccessStore,
-          import_utils18.SUI_CLOCK_OBJECT_ID
+          import_utils19.SUI_CLOCK_OBJECT_ID
         ]
       );
     },
@@ -6335,7 +6425,7 @@ var generateBorrowIncentiveNormalMethod = ({ builder, txBlock }) => {
           veScaIds.treasury,
           veScaIds.table,
           veScaKey,
-          import_utils18.SUI_CLOCK_OBJECT_ID
+          import_utils19.SUI_CLOCK_OBJECT_ID
         ],
         []
       );
@@ -6349,7 +6439,7 @@ var generateBorrowIncentiveNormalMethod = ({ builder, txBlock }) => {
           borrowIncentiveIds.incentiveAccounts,
           obligationKey,
           obligationId,
-          import_utils18.SUI_CLOCK_OBJECT_ID
+          import_utils19.SUI_CLOCK_OBJECT_ID
         ]
       );
     },
@@ -6367,7 +6457,7 @@ var generateBorrowIncentiveNormalMethod = ({ builder, txBlock }) => {
           borrowIncentiveIds.incentiveAccounts,
           obligationKey,
           obligationId,
-          import_utils18.SUI_CLOCK_OBJECT_ID
+          import_utils19.SUI_CLOCK_OBJECT_ID
         ],
         [rewardType]
       );
@@ -6381,7 +6471,7 @@ var generateBorrowIncentiveNormalMethod = ({ builder, txBlock }) => {
           borrowIncentiveIds.incentiveAccounts,
           obligation,
           veScaKey,
-          import_utils18.SUI_CLOCK_OBJECT_ID
+          import_utils19.SUI_CLOCK_OBJECT_ID
         ]
       );
     }
@@ -6670,17 +6760,12 @@ var generateLoyaltyProgramQuickMethod = ({
         throw new Error(`No veScaKey found for user ${sender}`);
       const toTransferObject = [];
       const rewardCoin = txBlock.claimLoyaltyRevenue(veScaKey);
-      try {
-        const existingScaCoin = await builder.suiKit.suiInteractor.selectCoins(
-          sender,
-          Infinity,
-          coinIds.sca
-        );
-        txBlock.mergeCoins(rewardCoin, existingScaCoin);
-      } catch (e) {
-      } finally {
-        toTransferObject.push(rewardCoin);
-      }
+      await builder.utils.mergeSimilarCoins(
+        txBlock,
+        rewardCoin,
+        coinIds.sca,
+        requireSender(txBlock)
+      );
       if (toTransferObject.length > 0) {
         txBlock.transferObjects(toTransferObject, sender);
       }
@@ -6860,7 +6945,7 @@ var ScallopBuilder = class {
       query: this.query,
       cache: this.cache
     });
-    this.walletAddress = (0, import_utils23.normalizeSuiAddress)(
+    this.walletAddress = (0, import_utils24.normalizeSuiAddress)(
       params?.walletAddress || this.suiKit.currentAddress()
     );
     this.isTestnet = params.networkType ? params.networkType === "testnet" : false;
@@ -6995,7 +7080,7 @@ var ScallopClient = class {
       utils: this.utils,
       cache: this.cache
     });
-    this.walletAddress = (0, import_utils24.normalizeSuiAddress)(
+    this.walletAddress = (0, import_utils25.normalizeSuiAddress)(
       params?.walletAddress || this.suiKit.currentAddress()
     );
   }
@@ -7347,6 +7432,14 @@ var ScallopClient = class {
       stakeMarketCoinName,
       stakeAccountId
     );
+    if (sCoin) {
+      await this.utils.mergeSimilarCoins(
+        txBlock,
+        sCoin,
+        this.utils.parseSCoinType(stakeMarketCoinName),
+        requireSender(txBlock)
+      );
+    }
     txBlock.transferObjects([sCoin], sender);
     if (sign) {
       return await this.suiKit.signAndSendTxn(
@@ -7369,6 +7462,12 @@ var ScallopClient = class {
     const stakeCoinName = this.utils.parseCoinName(stakeMarketCoinName);
     if (stakeMarketCoin) {
       const coin = txBlock.withdraw(stakeMarketCoin, stakeCoinName);
+      await this.utils.mergeSimilarCoins(
+        txBlock,
+        coin,
+        this.utils.parseCoinType(this.utils.parseCoinName(stakeCoinName)),
+        requireSender(txBlock)
+      );
       txBlock.transferObjects([coin], sender);
     } else {
       throw new Error(`No stake found for ${stakeMarketCoinName}`);
@@ -7509,15 +7608,12 @@ var ScallopClient = class {
             sCoinName,
             toDestroyMarketCoin
           );
-          try {
-            const existSCoins = await this.utils.selectCoins(
-              Number.MAX_SAFE_INTEGER,
-              this.utils.parseSCoinType(sCoinName),
-              this.walletAddress
-            );
-            txBlock.mergeCoins(sCoin, existSCoins);
-          } catch (e) {
-          }
+          await this.utils.mergeSimilarCoins(
+            txBlock,
+            sCoin,
+            this.utils.parseSCoinType(sCoinName),
+            requireSender(txBlock)
+          );
           sCoins2.push(sCoin);
         }
         if (SUPPORT_SPOOLS.includes(sCoinName)) {
@@ -7576,12 +7672,13 @@ var ScallopClient = class {
 
 // src/models/scallop.ts
 var Scallop = class {
-  constructor(params, cacheOptions) {
+  constructor(params, cacheOptions, tokenBucket) {
     this.params = params;
     this.suiKit = new import_sui_kit14.SuiKit(params);
     this.cache = new ScallopCache(
       cacheOptions ?? DEFAULT_CACHE_OPTIONS,
-      this.suiKit
+      this.suiKit,
+      tokenBucket ?? new TokenBucket(DEFAULT_TOKENS_PER_INTERVAL, DEFAULT_INTERVAL_IN_MS)
     );
     this._address = new ScallopAddress(
       {