@scallop-io/sui-scallop-sdk 2.1.6 → 2.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scallop-io/sui-scallop-sdk",
-  "version": "2.1.6",
+  "version": "2.1.8",
   "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

@@ -490,6 +490,28 @@ const generateQuickVeScaMethod: GenerateVeScaQuickMethod = ({
         );
       }
 
+      const [sourceVesca, targetVesca] = await Promise.all([
+        getVeSca(builder.utils, sourceKey),
+        getVeSca(builder.utils, targetKey),
+      ]);
+
+      if (!sourceVesca || !targetVesca) {
+        throw new Error('Source or target veSCA not found');
+      }
+
+      // Extend lock period to the max of both veSca
+      if (sourceVesca.unlockAt < targetVesca.unlockAt) {
+        txBlock.extendLockPeriod(
+          sourceVesca.keyId,
+          targetVesca.unlockAt / 1000
+        );
+      } else if (sourceVesca.unlockAt > targetVesca.unlockAt) {
+        txBlock.extendLockPeriod(
+          targetVesca.keyId,
+          sourceVesca.unlockAt / 1000
+        );
+      }
+
       return txBlock.mergeVeSca(targetKey, sourceKey);
     },
   };

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/types/address.ts

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