@scallop-io/sui-scallop-sdk 2.1.5 → 2.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scallop-io/sui-scallop-sdk",
-  "version": "2.1.5",
+  "version": "2.1.7",
   "description": "Typescript sdk for interacting with Scallop contract on SUI",
   "keywords": [
     "sui",
@@ -41,7 +41,7 @@
     "@mysten/sui": "1.28.2",
     "@pythnetwork/pyth-sui-js": "2.1.0",
     "@scallop-io/sui-kit": "1.4.0",
-    "@tanstack/query-core": "5.51.15",
+    "@tanstack/query-core": "5.59.16",
     "axios": "^1.9.0",
     "bignumber.js": "^9.1.2",
     "zod": "^3.23.8"

package/src/builders/vescaBuilder.ts

@@ -473,13 +473,6 @@ const generateQuickVeScaMethod: GenerateVeScaQuickMethod = ({
         isInSubsTable(builder, sourceKey, table),
       ]);
 
-      console.log({
-        targetKey,
-        sourceKey,
-        isTargetInSubTable,
-        isSourceInSubTable,
-      });
-
       const unstakeObligationBeforeStake =
         !!txBlock.txBlock.blockData.transactions.find(
           (txn) =>

package/src/models/scallopAddress.ts

@@ -2,6 +2,7 @@ import { NetworkType } from '@scallop-io/sui-kit';
 import { API_BASE_URL, queryKeys } from 'src/constants';
 import { AddressesInterface, AddressStringPath } from 'src/types';
 import ScallopAxios, { ScallopAxiosParams } from './scallopAxios';
+import { QueryKey } from '@tanstack/query-core';
 
 export type ScallopAddressParams = {
   addressId?: string;
@@ -9,6 +10,9 @@ export type ScallopAddressParams = {
   auth?: string;
   network?: NetworkType;
   forceAddressesInterface?: Partial<Record<NetworkType, AddressesInterface>>;
+  defaultValues?: {
+    addresses?: Partial<Record<NetworkType, AddressesInterface>>;
+  };
 } & ScallopAxiosParams;
 
 const EMPTY_ADDRESSES: AddressesInterface = {
@@ -438,7 +442,7 @@ class ScallopAddress {
     network: 'mainnet' as NetworkType,
   } as const;
 
-  constructor(params: ScallopAddressParams = {}) {
+  constructor(public readonly params: ScallopAddressParams = {}) {
     this.scallopAxios = new ScallopAxios({
       ...this.defaultParamValues,
       baseUrl: params.addressApiUrl || API_BASE_URL,
@@ -484,6 +488,10 @@ class ScallopAddress {
     return this.axiosClient.queryClient;
   }
 
+  get defaultValues() {
+    return this.params.defaultValues;
+  }
+
   getId() {
     return this.addressId;
   }
@@ -651,6 +659,23 @@ class ScallopAddress {
     }
   }
 
+  protected async readApi<T>({
+    url,
+    queryKey,
+  }: {
+    url: string;
+    queryKey: QueryKey;
+  }) {
+    const resp = await this.axiosClient.get<T>(url, queryKey);
+    if (resp.status === 200) {
+      return resp.data as T;
+    } else {
+      throw Error(
+        `Error: ${resp.status}; Failed to read ${url} ${resp.statusText}`
+      );
+    }
+  }
+
   /**
    * Read and synchronizes all addresses from the API into instance.
    *
@@ -660,25 +685,35 @@ class ScallopAddress {
   async read(id?: string) {
     const addressId = id || this.addressId || undefined;
     if (addressId !== undefined) {
-      const response = await this.axiosClient.get(
-        `/addresses/${addressId}`,
-        queryKeys.api.getAddresses({ addressId }) as string[]
-      );
+      const response = await (async () => {
+        try {
+          return await this.readApi<
+            Record<NetworkType, AddressesInterface> & { id?: string }
+          >({
+            url: `/addresses/${addressId}`,
+            queryKey: queryKeys.api.getAddresses({ addressId }) as string[],
+          });
+        } catch (e) {
+          console.error(e);
+          return {
+            id: '',
+            mainnet: this.defaultValues?.addresses?.mainnet ?? EMPTY_ADDRESSES,
+          };
+        }
+      })();
 
-      if (response.status === 200) {
-        for (const [network, addresses] of Object.entries<AddressesInterface>(
-          response.data
-        )) {
-          if (['localnet', 'devnet', 'testnet', 'mainnet'].includes(network)) {
-            if (network === this.network) this.currentAddresses = addresses;
-            this.addressMap.set(network as NetworkType, addresses);
-          }
+      const isNetworkValid = (network: string): network is NetworkType =>
+        ['localnet', 'devnet', 'testnet', 'mainnet'].includes(network);
+
+      for (const [network, addresses] of Object.entries(response)) {
+        if (isNetworkValid(network) && typeof addresses === 'object') {
+          if (network === this.network) this.currentAddresses = addresses;
+
+          this.addressMap.set(network, addresses);
         }
-        this.addressId = response.data.id;
-        return this.getAllAddresses();
-      } else {
-        throw Error('Failed to create addresses.');
       }
+      this.addressId = response.id;
+      return this.getAllAddresses();
     } else {
       throw Error('Please provide API addresses id.');
     }

package/src/models/scallopConstants.ts

@@ -1,9 +1,7 @@
 import { PoolAddress, Whitelist } from 'src/types';
 import ScallopAddress, { ScallopAddressParams } from './scallopAddress';
 import { NetworkType, parseStructTag } from '@scallop-io/sui-kit';
-import ScallopAxios from './scallopAxios';
 import { queryKeys } from 'src/constants';
-import { QueryKey } from '@tanstack/query-core';
 
 const isEmptyObject = (obj: object) => {
   return Object.keys(obj).length === 0;
@@ -29,6 +27,10 @@ export type ScallopConstantsParams = {
   whitelistApiUrl?: string;
   forcePoolAddressInterface?: Record<string, PoolAddress>;
   forceWhitelistInterface?: Whitelist | Record<string, any>;
+  defaultValues?: {
+    poolAddresses?: Record<string, PoolAddress>;
+    whitelist?: Whitelist | Record<string, any>;
+  };
 } & ScallopAddressParams;
 
 const DEFAULT_WHITELIST = {
@@ -101,11 +103,8 @@ class ScallopConstants extends ScallopAddress {
    */
   public supportedBorrowIncentiveRewards: Set<CoinName> = new Set();
 
-  private scallopConstantAxios: ScallopAxios;
-
   constructor(public readonly params: ScallopConstantsParams = {}) {
     super(params);
-    this.scallopConstantAxios = new ScallopAxios();
   }
 
   get protocolObjectId() {
@@ -150,6 +149,10 @@ class ScallopConstants extends ScallopAddress {
     });
   }
 
+  get defaultValues() {
+    return this.params.defaultValues;
+  }
+
   private isAddressInitialized({
     networkType = 'mainnet',
   }: {
@@ -320,45 +323,43 @@ class ScallopConstants extends ScallopAddress {
     ]);
   }
 
-  private async readApi<T>({
-    url,
-    queryKey,
-  }: {
-    url: string;
-    queryKey: QueryKey;
-  }) {
-    const resp = await this.scallopConstantAxios.get<T>(url, queryKey);
-    if (resp.status === 200) {
-      return resp.data as T;
-    } else {
-      throw Error(
-        `Error: ${resp.status}; Failed to read ${url} ${resp.statusText}`
-      );
-    }
-  }
-
   async readWhiteList() {
-    const response = await this.readApi<Record<keyof Whitelist, string[]>>({
-      url:
-        this.params.whitelistApiUrl ??
-        `https://sui.apis.scallop.io/pool/whitelist`,
-      queryKey: queryKeys.api.getWhiteList(),
-    });
+    const response = await (async () => {
+      try {
+        return await this.readApi<Record<keyof Whitelist, string[]>>({
+          url:
+            this.params.whitelistApiUrl ??
+            `https://sui.apis.scallop.io/pool/whitelist`,
+          queryKey: queryKeys.api.getWhiteList(),
+        });
+      } catch (e) {
+        console.error(e);
+        return this.defaultValues?.whitelist ?? DEFAULT_WHITELIST;
+      }
+    })();
 
     return Object.fromEntries(
       Object.entries(response)
-        .filter(([_, value]) => Array.isArray(value))
-        .map(([key, value]) => [key, new Set(value)])
+        .filter(([_, value]) => Array.isArray(value) || value instanceof Set)
+        .map(([key, value]) => [
+          key,
+          value instanceof Set ? value : new Set(value),
+        ])
     ) as Whitelist;
   }
 
   async readPoolAddresses() {
-    return await this.readApi<Record<string, PoolAddress>>({
-      url:
-        this.params.poolAddressesApiUrl ??
-        `https://sui.apis.scallop.io/pool/addresses`,
-      queryKey: queryKeys.api.getPoolAddresses(),
-    });
+    try {
+      return await this.readApi<Record<string, PoolAddress>>({
+        url:
+          this.params.poolAddressesApiUrl ??
+          `https://sui.apis.scallop.io/pool/addresses`,
+        queryKey: queryKeys.api.getPoolAddresses(),
+      });
+    } catch (e) {
+      console.error(e);
+      return this.defaultValues?.poolAddresses ?? {};
+    }
   }
 }
 

package/src/models/scallopQuery.ts

@@ -776,8 +776,8 @@ class ScallopQuery implements ScallopQueryInterface {
   /**
    * Get list of isolated assets
    */
-  async getIsolatedAssets() {
-    return await getIsolatedAssets(this);
+  async getIsolatedAssets(useOnChainQuery: boolean = false) {
+    return await getIsolatedAssets(this, useOnChainQuery);
   }
 
   /**

package/src/queries/coreQuery.ts

@@ -247,6 +247,7 @@ const queryRequiredMarketObjects = async (
     borrowFeeKey?: string;
     supplyLimitKey?: string;
     borrowLimitKey?: string;
+    isolatedAssetKey?: string;
   };
 
   const keyCollections: Record<keyof KeyType, string[]> = {
@@ -258,6 +259,7 @@ const queryRequiredMarketObjects = async (
     borrowFeeKey: [],
     supplyLimitKey: [],
     borrowLimitKey: [],
+    isolatedAssetKey: [],
   };
 
   const taskMap = new Map<string, KeyType>();
@@ -274,6 +276,7 @@ const queryRequiredMarketObjects = async (
       borrowFeeKey: poolData?.borrowFeeKey,
       supplyLimitKey: poolData?.supplyLimitKey,
       borrowLimitKey: poolData?.borrowLimitKey,
+      isolatedAssetKey: poolData?.isolatedAssetKey,
     };
 
     // Add to key collections
@@ -311,6 +314,7 @@ const queryRequiredMarketObjects = async (
     borrowFeeKey: new Map<string, SuiObjectData>(),
     supplyLimitKey: new Map<string, SuiObjectData>(),
     borrowLimitKey: new Map<string, SuiObjectData>(),
+    isolatedAssetKey: new Map<string, SuiObjectData>(),
     isIsolated: new Map<string, boolean>(),
   } as Record<keyof KeyType, Map<string, SuiObjectData>>;
 
@@ -349,7 +353,10 @@ const queryRequiredMarketObjects = async (
       borrowLimitKey: task.borrowLimitKey
         ? resultMaps.borrowLimitKey.get(task.borrowLimitKey)
         : undefined,
-      isolatedAssetKey: utils.constants.poolAddresses[poolCoinName]?.isIsolated,
+      isolatedAssetKey: task.isolatedAssetKey
+        ? resultMaps.isolatedAssetKey.get(task.isolatedAssetKey)
+        : undefined,
+      isIsolated: utils.constants.poolAddresses[poolCoinName]?.isIsolated,
     };
   }
 
@@ -553,6 +560,7 @@ export const getMarketPool = async (
     borrowFeeKey: SuiObjectData;
     supplyLimitKey: SuiObjectData;
     borrowLimitKey: SuiObjectData;
+    isolatedAssetKey?: SuiObjectData;
     isIsolated: boolean;
   }
 ): Promise<

package/src/types/address.ts

@@ -1,6 +1,7 @@
 import { _SUPPORT_ORACLES, SupportOracleType } from './constant/xOracle';
 
 export interface AddressesInterface {
+  id?: string;
   core: {
     version: string;
     versionCap: string;