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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scallop-io/sui-scallop-sdk",
-  "version": "2.1.7",
+  "version": "2.1.9",
   "description": "Typescript sdk for interacting with Scallop contract on SUI",
   "keywords": [
     "sui",

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

@@ -3,10 +3,14 @@ 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';
+import { AxiosRequestConfig } from 'axios';
+import { parseUrl } from 'src/utils';
 
 export type ScallopAddressParams = {
   addressId?: string;
-  addressApiUrl?: string;
+  urls?: {
+    addresses?: string[];
+  };
   auth?: string;
   network?: NetworkType;
   forceAddressesInterface?: Partial<Record<NetworkType, AddressesInterface>>;
@@ -445,7 +449,6 @@ class ScallopAddress {
   constructor(public readonly params: ScallopAddressParams = {}) {
     this.scallopAxios = new ScallopAxios({
       ...this.defaultParamValues,
-      baseUrl: params.addressApiUrl || API_BASE_URL,
       ...params,
     });
 
@@ -662,11 +665,13 @@ class ScallopAddress {
   protected async readApi<T>({
     url,
     queryKey,
+    config,
   }: {
     url: string;
     queryKey: QueryKey;
+    config?: AxiosRequestConfig;
   }) {
-    const resp = await this.axiosClient.get<T>(url, queryKey);
+    const resp = await this.axiosClient.get<T>(url, queryKey, config);
     if (resp.status === 200) {
       return resp.data as T;
     } else {
@@ -686,20 +691,26 @@ class ScallopAddress {
     const addressId = id || this.addressId || undefined;
     if (addressId !== undefined) {
       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,
-          };
+        const urls = (this.params.urls?.addresses ?? [API_BASE_URL]).map(
+          (url) => `${parseUrl(url)}/addresses/${addressId}`
+        );
+        for (const url of urls) {
+          try {
+            return await this.readApi<
+              Record<NetworkType, AddressesInterface> & { id?: string }
+            >({
+              url,
+              queryKey: queryKeys.api.getAddresses({ addressId }) as string[],
+            });
+          } catch (e) {
+            console.error(`${e}`); // Trying next url in the list
+          }
         }
+
+        return {
+          id: '',
+          mainnet: this.defaultValues?.addresses?.mainnet ?? EMPTY_ADDRESSES,
+        };
       })();
 
       const isNetworkValid = (network: string): network is NetworkType =>

package/src/models/scallopConstants.ts

@@ -2,6 +2,7 @@ import { PoolAddress, Whitelist } from 'src/types';
 import ScallopAddress, { ScallopAddressParams } from './scallopAddress';
 import { NetworkType, parseStructTag } from '@scallop-io/sui-kit';
 import { queryKeys } from 'src/constants';
+import { parseUrl } from 'src/utils';
 
 const isEmptyObject = (obj: object) => {
   return Object.keys(obj).length === 0;
@@ -23,8 +24,10 @@ type SCoinRawName = string;
 type SCoinName = string;
 
 export type ScallopConstantsParams = {
-  poolAddressesApiUrl?: string;
-  whitelistApiUrl?: string;
+  urls?: {
+    poolAddresses?: string[];
+    whitelist?: string[];
+  };
   forcePoolAddressInterface?: Record<string, PoolAddress>;
   forceWhitelistInterface?: Whitelist | Record<string, any>;
   defaultValues?: {
@@ -325,17 +328,22 @@ class ScallopConstants extends ScallopAddress {
 
   async readWhiteList() {
     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;
+      const urls = (
+        this.params.urls?.whitelist ?? [
+          `https://sui.apis.scallop.io/pool/whitelist`,
+        ]
+      ).map(parseUrl);
+      for (const url of urls) {
+        try {
+          return await this.readApi<Record<keyof Whitelist, string[]>>({
+            url,
+            queryKey: queryKeys.api.getWhiteList(),
+          });
+        } catch (e) {
+          console.error(`${e}`); // Trying next url in the list
+        }
       }
+      return this.defaultValues?.whitelist ?? DEFAULT_WHITELIST;
     })();
 
     return Object.fromEntries(
@@ -349,17 +357,22 @@ class ScallopConstants extends ScallopAddress {
   }
 
   async readPoolAddresses() {
-    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 ?? {};
+    const urls = (
+      this.params.urls?.poolAddresses ?? [
+        `https://sui.apis.scallop.io/pool/addresses`,
+      ]
+    ).map(parseUrl);
+    for (const url of urls) {
+      try {
+        return await this.readApi<Record<string, PoolAddress>>({
+          url,
+          queryKey: queryKeys.api.getPoolAddresses(),
+        });
+      } catch (e) {
+        console.error(`${e}`); // Trying next url in the list
+      }
     }
+    return this.defaultValues?.poolAddresses ?? {};
   }
 }
 

package/src/models/scallopSuiKit.ts

@@ -163,7 +163,13 @@ class ScallopSuiKit extends ScallopQueryClient {
   }
 
   get currentFullNode() {
-    return this.suiKit.suiInteractor.currentFullNode;
+    try {
+      // return current fullnode from SuiKit
+      return this.suiKit.suiInteractor.currentFullNode;
+    } catch (_) {
+      // SuiKit is initialized with custom sui clients, so no fullnodes can be read
+      return '';
+    }
   }
 
   signAndSendTxn(

package/src/utils/util.ts

@@ -33,3 +33,10 @@ export const partitionArray = <T>(array: T[], chunkSize: number) => {
   }
   return result;
 };
+
+export const parseUrl = (url: string) => {
+  if (url.endsWith('/')) {
+    url = url.slice(0, -1);
+  }
+  return url;
+};