@scallop-io/sui-scallop-sdk 1.3.0-alpha.3 → 1.3.0-alpha.5

package/dist/constants/index.d.ts

@@ -1,4 +1,5 @@
 export * from './common';
 export * from './enum';
 export * from './flashloan';
+export * from './queryKeys';
 export * from './vesca';

package/dist/constants/queryKeys.d.ts

@@ -0,0 +1,61 @@
+import type { GetDynamicFieldObjectParams, GetDynamicFieldsParams, GetOwnedObjectsParams, SuiObjectData, SuiObjectDataOptions } from '@mysten/sui/client';
+import type { SuiObjectArg } from '@scallop-io/sui-kit';
+export declare const queryKeys: {
+    api: {
+        getAddresses: (addressesId?: string) => (string | {
+            addressesId: string | undefined;
+        })[];
+        getMarket: () => string[];
+        getSpools: () => string[];
+        getBorrowIncentivePool: () => string[];
+        getTotalValueLocked: () => string[];
+    };
+    rpc: {
+        getInspectTxn: (queryTarget?: string, args?: SuiObjectArg[], typeArgs?: any[]) => (string | {
+            queryTarget: string | undefined;
+            args: string;
+            typeArgs: string | undefined;
+        })[];
+        getObject: (objectId?: string, walletAddress?: string, options?: SuiObjectDataOptions) => (string | {
+            walletAddress: string | undefined;
+            options: SuiObjectDataOptions | undefined;
+            objectId: string | undefined;
+        })[];
+        getObjects: (objectIds?: string[], walletAddress?: string, options?: SuiObjectDataOptions) => (string | {
+            walletAddress: string | undefined;
+            options: SuiObjectDataOptions | undefined;
+            objectIds: string;
+        })[];
+        getOwnedObjects: (input: Partial<GetOwnedObjectsParams>) => (string | {
+            walletAddress: string | undefined;
+            cursor: string | undefined;
+            options: SuiObjectDataOptions | undefined;
+            filter: string;
+            limit: number | undefined;
+        })[];
+        getDynamicFields: (input: Partial<GetDynamicFieldsParams>) => (string | {
+            parentId: string | undefined;
+            cursor: string | undefined;
+            limit: number | undefined;
+        })[];
+        getDynamicFieldObject: (input: Partial<GetDynamicFieldObjectParams>) => (string | {
+            parentId: string | undefined;
+            name: {
+                type: string | undefined;
+                value: unknown;
+            };
+        })[];
+        getTotalVeScaTreasuryAmount: (refreshArgs?: any[], vescaAmountArgs?: (string | SuiObjectData)[]) => (string | {
+            refreshArgs: string;
+            vescaAmountArgs: string;
+        })[];
+        getAllCoinBalances: (owner?: string) => (string | {
+            owner: string | undefined;
+        })[];
+    };
+    pyth: {
+        getPythLatestPriceFeed: (pythPriceId?: string) => (string | {
+            pythPriceId: string | undefined;
+        })[];
+    };
+};

package/dist/index.js

@@ -69,6 +69,7 @@ __export(src_exports, {
   coinDecimals: () => coinDecimals,
   coinIds: () => coinIds,
   marketCoins: () => marketCoins,
+  queryKeys: () => queryKeys,
   sCoinIds: () => sCoinIds,
   sCoins: () => sCoins,
   spoolRewardCoins: () => spoolRewardCoins,
@@ -93,7 +94,7 @@ var SUPPORT_POOLS = [
   "usdc",
   // native USDC
   "sbeth",
-  // native ETH
+  // sui bridge ETH
   "weth",
   "wbtc",
   "wusdc",
@@ -111,7 +112,7 @@ var SUPPORT_COLLATERALS = [
   "usdc",
   // native USDC
   "sbeth",
-  // native ETH
+  // sui bridge ETH
   "weth",
   "wbtc",
   "wusdc",
@@ -364,6 +365,93 @@ var FlashLoanFeeObjectMap = {
   wsol: "0xe84bdb35b790fc7bdd1645122ac6ac0fc904531d6772c9e25904fece322c5f34"
 };
 
+// src/constants/queryKeys.ts
+var queryKeys = {
+  api: {
+    getAddresses: (addressesId) => [
+      "api",
+      "getAddresses",
+      { addressesId }
+    ],
+    getMarket: () => ["api", "getMarket"],
+    getSpools: () => ["api", "getSpools"],
+    getBorrowIncentivePool: () => ["api", "getBorrowIncentivePools"],
+    getTotalValueLocked: () => ["api", "getTotalValueLocked"]
+  },
+  rpc: {
+    getInspectTxn: (queryTarget, args, typeArgs) => [
+      "rpc",
+      "getInspectTxn",
+      {
+        queryTarget,
+        args: JSON.stringify(args),
+        typeArgs: !typeArgs ? void 0 : JSON.stringify(typeArgs)
+      }
+    ],
+    getObject: (objectId, walletAddress, options) => ["rpc", "getObject", { walletAddress, options, objectId }],
+    getObjects: (objectIds, walletAddress, options) => [
+      "rpc",
+      "getObjects",
+      {
+        walletAddress,
+        options,
+        objectIds: JSON.stringify(objectIds ?? [])
+      }
+    ],
+    getOwnedObjects: (input) => [
+      "rpc",
+      "getOwnedObjects",
+      {
+        walletAddress: input.owner,
+        cursor: input.cursor ?? void 0,
+        options: input.options ?? void 0,
+        filter: JSON.stringify(input.filter ?? void 0),
+        limit: input.limit ?? void 0
+      }
+    ],
+    getDynamicFields: (input) => [
+      "rpc",
+      "getDynamicFields",
+      {
+        parentId: input.parentId,
+        cursor: input.cursor ?? void 0,
+        limit: input.limit ?? void 0
+      }
+    ],
+    getDynamicFieldObject: (input) => [
+      "rpc",
+      "getDynamicFieldObject",
+      {
+        parentId: input.parentId,
+        name: {
+          type: input?.name?.type,
+          value: input?.name?.value
+        }
+      }
+    ],
+    getTotalVeScaTreasuryAmount: (refreshArgs, vescaAmountArgs) => [
+      "rpc",
+      "getTotalVeScaTreasuryAmount",
+      {
+        refreshArgs: JSON.stringify(refreshArgs),
+        vescaAmountArgs: JSON.stringify(vescaAmountArgs)
+      }
+    ],
+    getAllCoinBalances: (owner) => [
+      "rpc",
+      "getAllCoinBalances",
+      { owner }
+    ]
+  },
+  pyth: {
+    getPythLatestPriceFeed: (pythPriceId) => [
+      "pyth",
+      "getPythPriceId",
+      { pythPriceId }
+    ]
+  }
+};
+
 // src/constants/vesca.ts
 var UNLOCK_ROUND_DURATION = 60 * 60 * 24;
 var MAX_LOCK_ROUNDS = 1460;
@@ -996,7 +1084,7 @@ var callWithRateLimit = async (tokenBucket, fn, retryDelayInMs = DEFAULT_INTERVA
           await new Promise((resolve) => setTimeout(resolve, delay));
           return tryRequest();
         } else {
-          console.error("An error occurred:", error);
+          console.error("An error occurred:", error.message);
           return null;
         }
       }
@@ -1019,8 +1107,8 @@ async function callMethodWithIndexerFallback(method, context, ...args) {
   if (indexer) {
     try {
       return await method.apply(context, args);
-    } catch (_e) {
-      console.warn("Indexer requests failed. Retrying without indexer..");
+    } catch (e) {
+      console.warn(`Indexer requests failed: ${e}. Retrying without indexer..`);
       return await method.apply(context, [...args.slice(0, -1), false]);
     }
   }
@@ -1034,8 +1122,8 @@ function withIndexerFallback(method) {
 
 // src/models/scallopCache.ts
 var ScallopCache = class {
-  constructor(suiKit, walletAddress, cacheOptions, tokenBucket) {
-    this.queryClient = new import_query_core.QueryClient(cacheOptions ?? DEFAULT_CACHE_OPTIONS);
+  constructor(suiKit, walletAddress, cacheOptions, tokenBucket, queryClient) {
+    this.queryClient = 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);
     this.walletAddress = walletAddress ?? suiKit.currentAddress();
@@ -1063,41 +1151,6 @@ var ScallopCache = class {
       refetchType
     });
   }
-  async resolveArgs(txb, args) {
-    return await Promise.all(
-      args.map(async (arg) => {
-        if (typeof arg === "string") {
-          const objData = (await this.queryGetObject(arg, { showOwner: true }))?.data;
-          if (!objData)
-            return arg;
-          const owner = objData?.owner;
-          if (!owner)
-            return arg;
-          if ("Shared" in owner) {
-            return txb.sharedObjectRef({
-              objectId: objData.objectId,
-              initialSharedVersion: owner.Shared.initial_shared_version,
-              mutable: true
-            });
-          } else {
-            return txb.objectRef({
-              objectId: objData.objectId,
-              version: objData.version,
-              digest: objData.digest
-            });
-          }
-        } else if ("objectId" in arg && "version" in arg && "digest" in arg) {
-          return txb.objectRef({
-            objectId: arg.objectId,
-            version: arg.version,
-            digest: arg.digest
-          });
-        } else {
-          return arg;
-        }
-      })
-    );
-  }
   /**
    * @description Provides cache for inspectTxn of the SuiKit.
    * @param QueryInspectTxnParams
@@ -1110,15 +1163,9 @@ var ScallopCache = class {
     typeArgs
   }) {
     const txBlock = new import_sui_kit.SuiTxBlock();
-    const resolvedArgs = await this.resolveArgs(txBlock, args);
-    txBlock.moveCall(queryTarget, resolvedArgs, typeArgs);
+    txBlock.moveCall(queryTarget, args, typeArgs);
     const query = await this.queryClient.fetchQuery({
-      queryKey: typeArgs ? ["inspectTxn", queryTarget, JSON.stringify(args)] : [
-        "inspectTxn",
-        queryTarget,
-        JSON.stringify(args),
-        JSON.stringify(typeArgs)
-      ],
+      queryKey: queryKeys.rpc.getInspectTxn(queryTarget, args, typeArgs),
       queryFn: async () => {
         return await callWithRateLimit(
           this.tokenBucket,
@@ -1135,12 +1182,8 @@ var ScallopCache = class {
    * @returns Promise<SuiObjectResponse>
    */
   async queryGetObject(objectId, options) {
-    const queryKey = ["getObject", objectId, this.walletAddress];
-    if (options) {
-      queryKey.push(JSON.stringify(options));
-    }
     return this.queryClient.fetchQuery({
-      queryKey,
+      queryKey: queryKeys.rpc.getObject(objectId, this.walletAddress, options),
       queryFn: async () => {
         return await callWithRateLimit(
           this.tokenBucket,
@@ -1162,16 +1205,12 @@ var ScallopCache = class {
   }) {
     if (objectIds.length === 0)
       return [];
-    const queryKey = [
-      "getObjects",
-      JSON.stringify(objectIds),
-      this.walletAddress
-    ];
-    if (options) {
-      queryKey.push(JSON.stringify(options));
-    }
     return this.queryClient.fetchQuery({
-      queryKey,
+      queryKey: queryKeys.rpc.getObjects(
+        objectIds,
+        this.walletAddress,
+        options
+      ),
       queryFn: async () => {
         return await callWithRateLimit(
           this.tokenBucket,
@@ -1186,21 +1225,8 @@ var ScallopCache = class {
    * @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,
+      queryKey: queryKeys.rpc.getOwnedObjects(input),
       queryFn: async () => {
         return await callWithRateLimit(
           this.tokenBucket,
@@ -1210,15 +1236,8 @@ var ScallopCache = class {
     });
   }
   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,
+      queryKey: queryKeys.rpc.getDynamicFields(input),
       queryFn: async () => {
         return await callWithRateLimit(
           this.tokenBucket,
@@ -1228,14 +1247,8 @@ var ScallopCache = class {
     });
   }
   async queryGetDynamicFieldObject(input) {
-    const queryKey = [
-      "getDynamicFieldObject",
-      input.parentId,
-      input.name.type,
-      input.name.value
-    ];
     return this.queryClient.fetchQuery({
-      queryKey,
+      queryKey: queryKeys.rpc.getDynamicFieldObject(input),
       queryFn: async () => {
         return await callWithRateLimit(
           this.tokenBucket,
@@ -1245,9 +1258,8 @@ var ScallopCache = class {
     });
   }
   async queryGetAllCoinBalances(owner) {
-    const queryKey = ["getAllCoinBalances", owner];
     return this.queryClient.fetchQuery({
-      queryKey,
+      queryKey: queryKeys.rpc.getAllCoinBalances(owner),
       queryFn: async () => {
         const allBalances = await callWithRateLimit(
           this.tokenBucket,
@@ -1264,17 +1276,6 @@ var ScallopCache = class {
           },
           {}
         );
-        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;
       }
     });
@@ -1282,19 +1283,7 @@ var ScallopCache = class {
   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";
-      }
-    });
+    return (await this.queryGetAllCoinBalances(input.owner) || {})[(0, import_sui_kit.normalizeStructTag)(input.coinType)] ?? "0";
   }
 };
 
@@ -2228,7 +2217,7 @@ var ScallopAddress = class {
     const addressesId = id || this._id || void 0;
     if (addressesId !== void 0) {
       const response = await this.cache.queryClient.fetchQuery({
-        queryKey: ["api-getAddresses", addressesId],
+        queryKey: queryKeys.api.getAddresses(addressesId),
         queryFn: async () => {
           return await this._requestClient.get(`/addresses/${addressesId}`, {
             headers: {
@@ -2382,7 +2371,7 @@ var supplyLimitZod = import_zod.z.object({
     value: import_zod.z.string()
   })
 });
-var SUPPLY_LIMIT_TYPE = "0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::market_dynamic_keys::SupplyLimitKey";
+var SUPPLY_LIMIT_KEY = "0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::market_dynamic_keys::SupplyLimitKey";
 var getSupplyLimit = async (utils, poolName) => {
   const poolCoinType = utils.parseCoinType(poolName).slice(2);
   const marketObject = utils.address.get("core.market");
@@ -2391,7 +2380,7 @@ var getSupplyLimit = async (utils, poolName) => {
   const object = await utils.cache.queryGetDynamicFieldObject({
     parentId: marketObject,
     name: {
-      type: SUPPLY_LIMIT_TYPE,
+      type: SUPPLY_LIMIT_KEY,
       value: poolCoinType
     }
   });
@@ -2401,6 +2390,76 @@ var getSupplyLimit = async (utils, poolName) => {
   return parsedData.data.fields.value;
 };
 
+// src/queries/isolatedAsset.ts
+var import_zod2 = require("zod");
+var isolatedAssetZod = import_zod2.z.object({
+  dataType: import_zod2.z.string(),
+  type: import_zod2.z.string(),
+  hasPublicTransfer: import_zod2.z.boolean(),
+  fields: import_zod2.z.object({
+    id: import_zod2.z.object({
+      id: import_zod2.z.string()
+    }),
+    name: import_zod2.z.object({
+      type: import_zod2.z.string()
+    }),
+    value: import_zod2.z.boolean()
+  })
+});
+var ISOLATED_ASSET_KEY = "0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::market_dynamic_keys::IsolatedAssetKey";
+var getIsolatedAssets = async (address) => {
+  const marketObject = address.get("core.market");
+  const isolatedAssets = [];
+  if (!marketObject)
+    return isolatedAssets;
+  let hasNextPage = false;
+  let nextCursor = null;
+  const isIsolatedDynamicField = (dynamicField) => {
+    return dynamicField.name.type === ISOLATED_ASSET_KEY;
+  };
+  do {
+    const response = await address.cache.queryGetDynamicFields({
+      parentId: marketObject,
+      cursor: nextCursor,
+      limit: 10
+    });
+    if (!response)
+      break;
+    const isolatedAssetCoinTypes = response.data.filter(isIsolatedDynamicField).map(({ name }) => `0x${name.value.type.name}`);
+    isolatedAssets.push(...isolatedAssetCoinTypes);
+    if (response && response.hasNextPage && response.nextCursor) {
+      hasNextPage = true;
+      nextCursor = response.nextCursor;
+    } else {
+      hasNextPage = false;
+    }
+  } while (hasNextPage);
+  return isolatedAssets;
+};
+var isIsolatedAsset = async (utils, coinName) => {
+  const marketObject = utils.address.get("core.market");
+  const cachedData = utils.address.cache.queryClient.getQueryData([
+    "getDynamicFields",
+    marketObject
+  ]);
+  if (cachedData) {
+    const coinType2 = utils.parseCoinType(coinName);
+    return cachedData.includes(coinType2);
+  }
+  const coinType = utils.parseCoinType(coinName).slice(2);
+  const object = await utils.cache.queryGetDynamicFieldObject({
+    parentId: marketObject,
+    name: {
+      type: ISOLATED_ASSET_KEY,
+      value: coinType
+    }
+  });
+  const parsedData = isolatedAssetZod.safeParse(object?.data?.content);
+  if (!parsedData.success)
+    return false;
+  return parsedData.data.fields.value;
+};
+
 // src/queries/coreQuery.ts
 var queryMarket = async (query, indexer = false) => {
   const coinPrices = await query.utils.getCoinPrices();
@@ -2485,6 +2544,7 @@ var queryMarket = async (query, indexer = false) => {
       borrowFee: parsedMarketPoolData.borrowFee,
       marketCoinSupplyAmount: parsedMarketPoolData.marketCoinSupplyAmount,
       minBorrowAmount: parsedMarketPoolData.minBorrowAmount,
+      isIsolated: await isIsolatedAsset(query.utils, poolCoinName),
       maxSupplyCoin,
       ...calculatedMarketPoolData
     };
@@ -2712,6 +2772,7 @@ var getMarketPool = async (query, poolCoinName, indexer = false, marketObject, c
       marketCoinSupplyAmount: parsedMarketPoolData.marketCoinSupplyAmount,
       minBorrowAmount: parsedMarketPoolData.minBorrowAmount,
       maxSupplyCoin,
+      isIsolated: await isIsolatedAsset(query.utils, poolCoinName),
       ...calculatedMarketPoolData
     };
   }
@@ -3771,7 +3832,8 @@ var getLending = async (query, poolCoinName, ownerAddress, indexer = false, mark
     availableUnstakeAmount: availableUnstakeAmount.toNumber(),
     availableUnstakeCoin: availableUnstakeCoin.toNumber(),
     availableClaimAmount: availableClaimAmount.toNumber(),
-    availableClaimCoin: availableClaimCoin.toNumber()
+    availableClaimCoin: availableClaimCoin.toNumber(),
+    isIsolated: marketPool ? marketPool.isIsolated : false
   };
   return lending;
 };
@@ -4129,7 +4191,7 @@ var getTotalValueLocked = async (query, indexer = false) => {
 var import_bignumber5 = __toESM(require("bignumber.js"));
 var import_sui_kit3 = require("@scallop-io/sui-kit");
 var import_bcs = require("@mysten/sui/bcs");
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 var import_assert = __toESM(require("assert"));
 var getVescaKeys = async (utils, ownerAddress) => {
   const owner = ownerAddress || utils.suiKit.currentAddress();
@@ -4178,10 +4240,10 @@ var getVeScas = async ({
   }
   return result;
 };
-var SuiObjectRefZod = import_zod2.z.object({
-  objectId: import_zod2.z.string(),
-  digest: import_zod2.z.string(),
-  version: import_zod2.z.string()
+var SuiObjectRefZod = import_zod3.z.object({
+  objectId: import_zod3.z.string(),
+  digest: import_zod3.z.string(),
+  version: import_zod3.z.string()
 });
 var getVeSca = async (utils, veScaKey, ownerAddress) => {
   const tableId = utils.address.get(`vesca.tableId`);
@@ -4256,10 +4318,10 @@ var getTotalVeScaTreasuryAmount = async (utils, veScaTreasury) => {
     onlyTransactionKind: true
   });
   const res = await utils.cache.queryClient.fetchQuery({
-    queryKey: [
-      "getTotalVeScaTreasuryAmount",
-      JSON.stringify([...refreshArgs, ...veScaAmountArgs])
-    ],
+    queryKey: queryKeys.rpc.getTotalVeScaTreasuryAmount(
+      refreshArgs,
+      veScaAmountArgs
+    ),
     queryFn: async () => {
       return await utils.suiKit.inspectTxn(txBytes);
     }
@@ -4315,16 +4377,16 @@ var queryVeScaKeyIdFromReferralBindings = async (address, refereeAddress) => {
 
 // src/queries/loyaltyProgramQuery.ts
 var import_bignumber6 = __toESM(require("bignumber.js"));
-var import_zod3 = require("zod");
-var rewardPoolFieldsZod = import_zod3.z.object({
-  balance: import_zod3.z.string(),
-  enable_claim: import_zod3.z.boolean()
+var import_zod4 = require("zod");
+var rewardPoolFieldsZod = import_zod4.z.object({
+  balance: import_zod4.z.string(),
+  enable_claim: import_zod4.z.boolean()
 }).transform((value) => ({
   totalPoolReward: (0, import_bignumber6.default)(value.balance).shiftedBy(-9).toNumber(),
   isClaimEnabled: value.enable_claim
 }));
-var userRewardFieldsZod = import_zod3.z.object({
-  value: import_zod3.z.string()
+var userRewardFieldsZod = import_zod4.z.object({
+  value: import_zod4.z.string()
 }).transform((value) => (0, import_bignumber6.default)(value.value).shiftedBy(-9).toNumber());
 var getLoyaltyProgramInformations = async (query, veScaKey) => {
   const rewardPool = query.address.get("loyaltyProgram.rewardPool");
@@ -4743,7 +4805,7 @@ var ScallopUtils = class {
             const pythConnection = new import_pyth_sui_js.SuiPriceServiceConnection(endpoint);
             try {
               const feed = await this.address.cache.queryClient.fetchQuery({
-                queryKey: [priceId],
+                queryKey: queryKeys.pyth.getPythLatestPriceFeed(priceId),
                 queryFn: async () => {
                   return await pythConnection.getLatestPriceFeeds([priceId]);
                 }
@@ -6459,7 +6521,7 @@ var ScallopIndexer = class {
    */
   async getMarket() {
     const response = await this.cache.queryClient.fetchQuery({
-      queryKey: ["market"],
+      queryKey: queryKeys.api.getMarket(),
       queryFn: async () => {
         return await this._requestClient.get(`/api/market/migrate`);
       }
@@ -6522,7 +6584,7 @@ var ScallopIndexer = class {
    */
   async getSpools() {
     const response = await this.cache.queryClient.fetchQuery({
-      queryKey: ["spools"],
+      queryKey: queryKeys.api.getSpools(),
       queryFn: async () => {
         return await this._requestClient.get(`/api/spools/migrate`);
       }
@@ -6551,7 +6613,7 @@ var ScallopIndexer = class {
    */
   async getBorrowIncentivePools() {
     const response = await this.cache.queryClient.fetchQuery({
-      queryKey: ["borrowIncentivePools"],
+      queryKey: queryKeys.api.getBorrowIncentivePool(),
       queryFn: async () => {
         return await this._requestClient.get(`/api/borrowIncentivePools/migrate`);
       }
@@ -6592,7 +6654,7 @@ var ScallopIndexer = class {
    */
   async getTotalValueLocked() {
     const response = await this.cache.queryClient.fetchQuery({
-      queryKey: ["totalValueLocked"],
+      queryKey: queryKeys.api.getTotalValueLocked(),
       queryFn: async () => {
         return await this._requestClient.get(`/api/market/tvl`);
       }
@@ -7217,6 +7279,18 @@ var ScallopQuery = class {
   async getPoolSupplyLimit(poolName) {
     return await getSupplyLimit(this.utils, poolName);
   }
+  /**
+   * Get list of isolated assets
+   */
+  async getIsolatedAssets() {
+    return await getIsolatedAssets(this.address);
+  }
+  /**
+   * Check if asset is an isolated asset
+   */
+  async isIsolatedAsset(assetCoinName) {
+    return isIsolatedAsset(this.utils, assetCoinName);
+  }
 };
 
 // src/models/scallopBuilder.ts
@@ -8045,14 +8119,15 @@ var ScallopClient = class {
 
 // src/models/scallop.ts
 var Scallop = class {
-  constructor(params, cacheOptions, tokenBucket) {
+  constructor(params, cacheOptions, tokenBucket, queryClient) {
     this.params = params;
     this.suiKit = new import_sui_kit16.SuiKit(params);
     this.cache = new ScallopCache(
       this.suiKit,
       params.walletAddress,
       cacheOptions ?? DEFAULT_CACHE_OPTIONS,
-      tokenBucket ?? new TokenBucket(DEFAULT_TOKENS_PER_INTERVAL, DEFAULT_INTERVAL_IN_MS)
+      tokenBucket ?? new TokenBucket(DEFAULT_TOKENS_PER_INTERVAL, DEFAULT_INTERVAL_IN_MS),
+      queryClient
     );
     this.address = new ScallopAddress(
       {
@@ -8197,6 +8272,7 @@ var Scallop = class {
   coinDecimals,
   coinIds,
   marketCoins,
+  queryKeys,
   sCoinIds,
   sCoins,
   spoolRewardCoins,