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

package/dist/models/scallop.d.ts

@@ -9,6 +9,7 @@ import { ScallopIndexer } from './scallopIndexer';
 import { ScallopCache } from './scallopCache';
 import { QueryClientConfig } from '@tanstack/query-core';
 import { TokenBucket } from 'src/utils';
+import type { QueryClient } from '@tanstack/query-core';
 /**
  * @argument params - The parameters for the Scallop instance.
  * @argument cacheOptions - The cache options for the QueryClient.
@@ -31,7 +32,7 @@ export declare class Scallop {
     suiKit: SuiKit;
     cache: ScallopCache;
     private address;
-    constructor(params: ScallopParams, cacheOptions?: QueryClientConfig, tokenBucket?: TokenBucket);
+    constructor(params: ScallopParams, cacheOptions?: QueryClientConfig, tokenBucket?: TokenBucket, queryClient?: QueryClient);
     /**
      * Get a scallop address instance that already has read addresses.
      *

package/dist/models/scallopCache.d.ts

@@ -1,5 +1,5 @@
 import { QueryClient, QueryClientConfig } from '@tanstack/query-core';
-import { SuiObjectArg, SuiTxBlock } from '@scallop-io/sui-kit';
+import { SuiObjectArg } from '@scallop-io/sui-kit';
 import { SuiKit } from '@scallop-io/sui-kit';
 import type { SuiObjectResponse, SuiObjectDataOptions, SuiObjectData, GetOwnedObjectsParams, DevInspectResults, GetDynamicFieldsParams, DynamicFieldPage, GetDynamicFieldObjectParams, GetBalanceParams } from '@mysten/sui/client';
 import { TokenBucket } from 'src/utils';
@@ -25,7 +25,7 @@ export declare class ScallopCache {
     readonly _suiKit: SuiKit;
     private tokenBucket;
     walletAddress: string;
-    constructor(suiKit: SuiKit, walletAddress?: string, cacheOptions?: QueryClientConfig, tokenBucket?: TokenBucket);
+    constructor(suiKit: SuiKit, walletAddress?: string, cacheOptions?: QueryClientConfig, tokenBucket?: TokenBucket, queryClient?: QueryClient);
     private get suiKit();
     private get client();
     /**
@@ -38,7 +38,6 @@ export declare class ScallopCache {
      * - `none`: No queries will be refetched. Queries that match the refetch predicate will only be marked as invalid.
      */
     invalidateAndRefetchAllCache(refetchType: 'all' | 'active' | 'inactive' | 'none'): Promise<void>;
-    resolveArgs(txb: SuiTxBlock, args: SuiObjectArg[]): Promise<SuiObjectArg[]>;
     /**
      * @description Provides cache for inspectTxn of the SuiKit.
      * @param QueryInspectTxnParams

package/dist/models/scallopQuery.d.ts

@@ -457,4 +457,12 @@ export declare class ScallopQuery {
      * Get supply limit of supply pool
      */
     getPoolSupplyLimit(poolName: SupportPoolCoins): Promise<string | null>;
+    /**
+     * Get list of isolated assets
+     */
+    getIsolatedAssets(): Promise<string[]>;
+    /**
+     * Check if asset is an isolated asset
+     */
+    isIsolatedAsset(assetCoinName: SupportAssetCoins): Promise<boolean>;
 }

package/dist/queries/isolatedAsset.d.ts

@@ -0,0 +1,14 @@
+import { ScallopAddress, ScallopUtils } from 'src/models';
+import { SupportPoolCoins } from 'src/types';
+/**
+ * Return list of isolated assets coin types
+ * @param utils ScallopUtils
+ * @returns list of isolated assets coin types
+ */
+export declare const getIsolatedAssets: (address: ScallopAddress) => Promise<string[]>;
+/**
+ * Check if the coin type is an isolated asset
+ * @param coinName coin name
+ * @returns true if the coin type is an isolated asset
+ */
+export declare const isIsolatedAsset: (utils: ScallopUtils, coinName: SupportPoolCoins) => Promise<boolean>;

package/dist/types/query/core.d.ts

@@ -123,6 +123,7 @@ export type MarketPool = {
     coinDecimal: number;
     coinPrice: number;
     maxSupplyCoin: number;
+    isIsolated: boolean;
 } & Required<Pick<ParsedMarketPoolData, 'highKink' | 'midKink' | 'reserveFactor' | 'borrowWeight' | 'borrowFee' | 'marketCoinSupplyAmount' | 'minBorrowAmount'>> & CalculatedMarketPoolData;
 export type MarketCollateral = {
     coinName: SupportCollateralCoins;

package/dist/types/query/portfolio.d.ts

@@ -6,7 +6,7 @@ type OptionalKeys<T> = {
 };
 export type Lendings = OptionalKeys<Record<SupportPoolCoins, Lending>>;
 export type ObligationAccounts = OptionalKeys<Record<string, ObligationAccount>>;
-export type Lending = Required<Pick<MarketPool, 'coinName' | 'symbol' | 'coinType' | 'marketCoinType' | 'coinDecimal' | 'coinPrice' | 'conversionRate'> & Pick<Spool, 'marketCoinPrice'>> & {
+export type Lending = Required<Pick<MarketPool, 'coinName' | 'symbol' | 'coinType' | 'marketCoinType' | 'coinDecimal' | 'coinPrice' | 'conversionRate' | 'isIsolated'> & Pick<Spool, 'marketCoinPrice'>> & {
     supplyApr: number;
     supplyApy: number;
     rewardApr: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scallop-io/sui-scallop-sdk",
-  "version": "1.3.0-alpha.3",
+  "version": "1.3.0-alpha.5",
   "description": "Typescript sdk for interacting with Scallop contract on SUI",
   "keywords": [
     "sui",
@@ -48,7 +48,7 @@
     "@pythnetwork/pyth-sui-js": "2.0.0",
     "@scallop-io/sui-kit": "1.3.1-alpha.1",
     "@scure/bip39": "^1.2.1",
-    "@tanstack/query-core": "^5.28.0",
+    "@tanstack/query-core": "5.51.15",
     "axios": "^1.6.0",
     "bech32": "^2.0.0",
     "bignumber.js": "^9.1.2",

package/src/constants/common.ts

@@ -32,7 +32,7 @@ export const OLD_BORROW_INCENTIVE_PROTOCOL_ID =
 
 export const SUPPORT_POOLS = [
   'usdc', // native USDC
-  'sbeth', // native ETH
+  'sbeth', // sui bridge ETH
   'weth',
   'wbtc',
   'wusdc',
@@ -49,7 +49,7 @@ export const SUPPORT_POOLS = [
 
 export const SUPPORT_COLLATERALS = [
   'usdc', // native USDC
-  'sbeth', // native ETH
+  'sbeth', // sui bridge ETH
   'weth',
   'wbtc',
   'wusdc',

package/src/constants/index.ts

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

package/src/constants/queryKeys.ts

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

package/src/models/scallop.ts

@@ -21,6 +21,7 @@ import {
   DEFAULT_INTERVAL_IN_MS,
   DEFAULT_TOKENS_PER_INTERVAL,
 } from 'src/constants/tokenBucket';
+import type { QueryClient } from '@tanstack/query-core';
 
 /**
  * @argument params - The parameters for the Scallop instance.
@@ -49,7 +50,8 @@ export class Scallop {
   public constructor(
     params: ScallopParams,
     cacheOptions?: QueryClientConfig,
-    tokenBucket?: TokenBucket
+    tokenBucket?: TokenBucket,
+    queryClient?: QueryClient
   ) {
     this.params = params;
     this.suiKit = new SuiKit(params);
@@ -58,7 +60,8 @@ export class Scallop {
       params.walletAddress,
       cacheOptions ?? DEFAULT_CACHE_OPTIONS,
       tokenBucket ??
-        new TokenBucket(DEFAULT_TOKENS_PER_INTERVAL, DEFAULT_INTERVAL_IN_MS)
+        new TokenBucket(DEFAULT_TOKENS_PER_INTERVAL, DEFAULT_INTERVAL_IN_MS),
+      queryClient
     );
     this.address = new ScallopAddress(
       {

package/src/models/scallopAddress.ts

@@ -10,6 +10,7 @@ import { ScallopCache } from './scallopCache';
 import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
 import axios, { AxiosInstance } from 'axios';
 import { TEST_ADDRESSES } from 'src/constants/testAddress';
+import { queryKeys } from 'src/constants';
 
 const EMPTY_ADDRESSES: AddressesInterface = {
   core: {
@@ -597,7 +598,7 @@ export class ScallopAddress {
     const addressesId = id || this._id || undefined;
     if (addressesId !== undefined) {
       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: {

package/src/models/scallopCache.ts

@@ -3,7 +3,6 @@ import {
   SuiObjectArg,
   SuiTxBlock,
   normalizeStructTag,
-  normalizeSuiAddress,
 } from '@scallop-io/sui-kit';
 import { SuiKit } from '@scallop-io/sui-kit';
 import type {
@@ -24,6 +23,7 @@ import {
   DEFAULT_INTERVAL_IN_MS,
   DEFAULT_TOKENS_PER_INTERVAL,
 } from 'src/constants/tokenBucket';
+import { queryKeys } from 'src/constants';
 
 type QueryInspectTxnParams = {
   queryTarget: string;
@@ -54,9 +54,18 @@ export class ScallopCache {
     suiKit: SuiKit,
     walletAddress?: string,
     cacheOptions?: QueryClientConfig,
-    tokenBucket?: TokenBucket
+    tokenBucket?: TokenBucket,
+    queryClient?: QueryClient
   ) {
-    this.queryClient = new QueryClient(cacheOptions ?? DEFAULT_CACHE_OPTIONS);
+    this.queryClient =
+      queryClient ?? new QueryClient(cacheOptions ?? DEFAULT_CACHE_OPTIONS);
+
+    // if(queryClient && cacheOptions){
+    //   if(cacheOptions.defaultOptions)this.queryClient.setDefaultOptions(cacheOptions.defaultOptions);
+    //   if (cacheOptions.queryCache)
+    //     this.queryClient.defaultQueryOptions(cacheOptions.queryCache);
+    //   if(cacheOptions.mutations)this.queryClient.setMutationDefaults(cacheOptions.mutations);
+    // }
     this._suiKit = suiKit;
     this.tokenBucket =
       tokenBucket ??
@@ -92,45 +101,6 @@ export class ScallopCache {
     });
   }
 
-  public async resolveArgs(
-    txb: SuiTxBlock,
-    args: SuiObjectArg[]
-  ): Promise<SuiObjectArg[]> {
-    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 as any;
-          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 as string,
-            digest: arg.digest,
-          });
-        } else {
-          return arg;
-        }
-      })
-    );
-  }
-
   /**
    * @description Provides cache for inspectTxn of the SuiKit.
    * @param QueryInspectTxnParams
@@ -144,19 +114,10 @@ export class ScallopCache {
   }: QueryInspectTxnParams): Promise<DevInspectResults | null> {
     const txBlock = new 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, () =>
           this.suiKit.inspectTxn(txBlock)
@@ -176,12 +137,8 @@ export class ScallopCache {
     objectId: string,
     options?: SuiObjectDataOptions
   ): Promise<SuiObjectResponse | null> {
-    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, () =>
           this.client.getObject({
@@ -205,16 +162,14 @@ export class ScallopCache {
     }
   ): Promise<SuiObjectData[]> {
     if (objectIds.length === 0) return [];
-    const queryKey = [
-      'getObjects',
-      JSON.stringify(objectIds),
-      this.walletAddress,
-    ];
-    if (options) {
-      queryKey.push(JSON.stringify(options));
-    }
+    // objectIds.sort();
+
     return this.queryClient.fetchQuery({
-      queryKey: queryKey,
+      queryKey: queryKeys.rpc.getObjects(
+        objectIds,
+        this.walletAddress,
+        options
+      ),
       queryFn: async () => {
         return await callWithRateLimit(this.tokenBucket, () =>
           this.suiKit.getObjects(objectIds, options)
@@ -229,22 +184,8 @@ export class ScallopCache {
    * @returns Promise<PaginatedObjectsResponse>
    */
   public async queryGetOwnedObjects(input: GetOwnedObjectsParams) {
-    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, () =>
           this.client.getOwnedObjects(input)
@@ -256,16 +197,8 @@ export class ScallopCache {
   public async queryGetDynamicFields(
     input: GetDynamicFieldsParams
   ): Promise<DynamicFieldPage | null> {
-    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, () =>
           this.client.getDynamicFields(input)
@@ -277,14 +210,8 @@ export class ScallopCache {
   public async queryGetDynamicFieldObject(
     input: GetDynamicFieldObjectParams
   ): Promise<SuiObjectResponse | null> {
-    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, () =>
           this.client.getDynamicFieldObject(input)
@@ -296,9 +223,8 @@ export class ScallopCache {
   public async queryGetAllCoinBalances(
     owner: string
   ): Promise<{ [k: string]: string }> {
-    const queryKey = ['getAllCoinBalances', owner];
     return this.queryClient.fetchQuery({
-      queryKey,
+      queryKey: queryKeys.rpc.getAllCoinBalances(owner),
       queryFn: async () => {
         const allBalances = await callWithRateLimit(this.tokenBucket, () =>
           this.client.getAllBalances({ owner })
@@ -315,19 +241,6 @@ export class ScallopCache {
           {} as { [k: string]: string }
         );
 
-        // Set query data for each coin balance
-        for (const coinType in balances) {
-          const coinBalanceQueryKey = [
-            'getCoinBalance',
-            normalizeSuiAddress(owner),
-            normalizeStructTag(coinType),
-          ];
-          this.queryClient.setQueryData(
-            coinBalanceQueryKey,
-            balances[coinType]
-          );
-        }
-
         return balances;
       },
     });
@@ -336,21 +249,10 @@ export class ScallopCache {
   public async queryGetCoinBalance(input: GetBalanceParams): Promise<string> {
     if (!input.coinType) return '0';
 
-    const queryKey = [
-      'getCoinBalance',
-      normalizeSuiAddress(input.owner),
-      normalizeStructTag(input.coinType),
-    ];
-    return this.queryClient.fetchQuery({
-      queryKey,
-      queryFn: async () => {
-        if (!input.coinType) return '0';
-        return (
-          (await this.queryGetAllCoinBalances(input.owner))[
-            normalizeStructTag(input.coinType)
-          ] ?? '0'
-        );
-      },
-    });
+    return (
+      ((await this.queryGetAllCoinBalances(input.owner)) || {})[
+        normalizeStructTag(input.coinType)
+      ] ?? '0'
+    );
   }
 }

package/src/models/scallopIndexer.ts

@@ -24,6 +24,7 @@ import type {
 import { ScallopCache } from './scallopCache';
 import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache';
 import { SuiKit } from '@scallop-io/sui-kit';
+import { queryKeys } from 'src/constants';
 
 /**
  * @description
@@ -67,7 +68,7 @@ export class ScallopIndexer {
    */
   public async getMarket(): Promise<Pick<Market, 'pools' | 'collaterals'>> {
     const response = await this.cache.queryClient.fetchQuery({
-      queryKey: ['market'],
+      queryKey: queryKeys.api.getMarket(),
       queryFn: async () => {
         return await this._requestClient.get<{
           pools: MarketPool[];
@@ -145,7 +146,7 @@ export class ScallopIndexer {
    */
   public async getSpools(): Promise<Required<Spools>> {
     const response = await this.cache.queryClient.fetchQuery({
-      queryKey: ['spools'],
+      queryKey: queryKeys.api.getSpools(),
       queryFn: async () => {
         return await this._requestClient.get<{
           spools: Spool[];
@@ -183,7 +184,7 @@ export class ScallopIndexer {
     Required<BorrowIncentivePools>
   > {
     const response = await this.cache.queryClient.fetchQuery({
-      queryKey: ['borrowIncentivePools'],
+      queryKey: queryKeys.api.getBorrowIncentivePool(),
       queryFn: async () => {
         return await this._requestClient.get<{
           borrowIncentivePools: BorrowIncentivePool[];
@@ -245,7 +246,7 @@ export class ScallopIndexer {
     }
   > {
     const response = await this.cache.queryClient.fetchQuery({
-      queryKey: ['totalValueLocked'],
+      queryKey: queryKeys.api.getTotalValueLocked(),
       queryFn: async () => {
         return await this._requestClient.get<
           TotalValueLocked & {

package/src/models/scallopQuery.ts

@@ -63,6 +63,7 @@ import {
 import { normalizeSuiAddress } from '@mysten/sui/utils';
 import { getSupplyLimit } from 'src/queries/supplyLimit';
 import { withIndexerFallback } from 'src/utils/indexer';
+import { getIsolatedAssets, isIsolatedAsset } from 'src/queries/isolatedAsset';
 
 /**
  * @description
@@ -739,4 +740,18 @@ export class ScallopQuery {
   public async getPoolSupplyLimit(poolName: SupportPoolCoins) {
     return await getSupplyLimit(this.utils, poolName);
   }
+
+  /**
+   * Get list of isolated assets
+   */
+  public async getIsolatedAssets() {
+    return await getIsolatedAssets(this.address);
+  }
+
+  /**
+   * Check if asset is an isolated asset
+   */
+  public async isIsolatedAsset(assetCoinName: SupportAssetCoins) {
+    return isIsolatedAsset(this.utils, assetCoinName);
+  }
 }

package/src/models/scallopUtils.ts

@@ -46,6 +46,7 @@ import type {
   SupportSuiBridgeCoins,
   SupportWormholeCoins,
 } from '../types';
+import { queryKeys } from 'src/constants';
 import type { SuiObjectArg, SuiTxArg, SuiTxBlock } from '@scallop-io/sui-kit';
 
 /**
@@ -558,7 +559,7 @@ export class ScallopUtils {
             const pythConnection = new 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]);
                 },

package/src/queries/coreQuery.ts

@@ -38,6 +38,7 @@ import {
 } from '../types';
 import BigNumber from 'bignumber.js';
 import { getSupplyLimit } from './supplyLimit';
+import { isIsolatedAsset } from './isolatedAsset';
 
 /**
  * Query market data.
@@ -155,6 +156,7 @@ export const queryMarket = async (
       borrowFee: parsedMarketPoolData.borrowFee,
       marketCoinSupplyAmount: parsedMarketPoolData.marketCoinSupplyAmount,
       minBorrowAmount: parsedMarketPoolData.minBorrowAmount,
+      isIsolated: await isIsolatedAsset(query.utils, poolCoinName),
       maxSupplyCoin,
       ...calculatedMarketPoolData,
     };
@@ -492,6 +494,7 @@ export const getMarketPool = async (
       marketCoinSupplyAmount: parsedMarketPoolData.marketCoinSupplyAmount,
       minBorrowAmount: parsedMarketPoolData.minBorrowAmount,
       maxSupplyCoin,
+      isIsolated: await isIsolatedAsset(query.utils, poolCoinName),
       ...calculatedMarketPoolData,
     };
   }