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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scallop-io/sui-scallop-sdk",
-  "version": "2.1.8",
+  "version": "2.2.0",
   "description": "Typescript sdk for interacting with Scallop contract on SUI",
   "keywords": [
     "sui",
@@ -40,7 +40,7 @@
   "dependencies": {
     "@mysten/sui": "1.28.2",
     "@pythnetwork/pyth-sui-js": "2.1.0",
-    "@scallop-io/sui-kit": "1.4.0",
+    "@scallop-io/sui-kit": "1.4.1",
     "@tanstack/query-core": "5.59.16",
     "axios": "^1.9.0",
     "bignumber.js": "^9.1.2",
@@ -50,6 +50,8 @@
     "@commitlint/cli": "^18.2.0",
     "@commitlint/config-conventional": "^18.1.0",
     "@commitlint/prompt-cli": "^18.2.0",
+    "@mysten/bcs": "^1.6.1",
+    "@mysten/utils": "^0.0.0",
     "@pythnetwork/price-service-client": "^1.9.0",
     "@pythnetwork/price-service-sdk": "^1.8.0",
     "@types/node": "^20.4.2",
@@ -71,11 +73,13 @@
     "tsup": "^7.2.0",
     "typedoc": "^0.26.3",
     "typescript": "5.5.4",
+    "valibot": "^1.1.0",
+    "vite": "^6.3.5",
     "vitest": "^3.1.1"
   },
   "peerDependencies": {
     "@mysten/sui": "1.28.2",
-    "@scallop-io/sui-kit": "1.4.0",
+    "@scallop-io/sui-kit": "1.4.1",
     "bn.js": "^5.2.1"
   },
   "lint-staged": {

package/src/builders/vescaBuilder.ts

@@ -47,7 +47,7 @@ export const requireVeSca = async (
   ...params: [
     builder: ScallopBuilder,
     SuiTxBlock: SuiTxBlock,
-    veScaKey?: SuiObjectData,
+    veScaKey?: SuiObjectData | string,
   ]
 ) => {
   const [builder, txBlock, veScaKey] = params;
@@ -259,12 +259,12 @@ const generateQuickVeScaMethod: GenerateVeScaQuickMethod = ({
   txBlock,
 }) => {
   return {
-    lockScaQuick: async (
+    lockScaQuick: async ({
       amountOrCoin,
       lockPeriodInDays,
+      autoCheck = true,
       veScaKey,
-      autoCheck = true
-    ) => {
+    }) => {
       const sender = requireSender(txBlock);
       const veSca = await requireVeSca(builder, txBlock, veScaKey);
 
@@ -334,11 +334,11 @@ const generateQuickVeScaMethod: GenerateVeScaQuickMethod = ({
         txBlock.transferObjects(transferObjects, sender);
       }
     },
-    extendLockPeriodQuick: async (
-      lockPeriodInDays: number,
-      veScaKey?: SuiObjectArg,
-      autoCheck = true
-    ) => {
+    extendLockPeriodQuick: async ({
+      lockPeriodInDays,
+      veScaKey,
+      autoCheck = true,
+    }) => {
       const veSca = await requireVeSca(builder, txBlock, veScaKey);
       const newUnlockAt = builder.utils.getUnlockAt(
         lockPeriodInDays,
@@ -352,11 +352,11 @@ const generateQuickVeScaMethod: GenerateVeScaQuickMethod = ({
         txBlock.extendLockPeriod(veSca.keyId, newUnlockAt);
       }
     },
-    extendLockAmountQuick: async (
-      scaAmount: number,
-      veScaKey?: SuiObjectArg,
-      autoCheck = true
-    ) => {
+    extendLockAmountQuick: async ({
+      scaAmount,
+      veScaKey,
+      autoCheck = true,
+    }) => {
       const sender = requireSender(txBlock);
       const veSca = await requireVeSca(builder, txBlock, veScaKey);
 
@@ -377,12 +377,12 @@ const generateQuickVeScaMethod: GenerateVeScaQuickMethod = ({
         txBlock.transferObjects([leftCoin], sender);
       }
     },
-    renewExpiredVeScaQuick: async (
-      scaAmount: number,
-      lockPeriodInDays: number,
-      veScaKey?: SuiObjectArg,
-      autoCheck = true
-    ) => {
+    renewExpiredVeScaQuick: async ({
+      scaAmount,
+      lockPeriodInDays,
+      veScaKey,
+      autoCheck = true,
+    }) => {
       const sender = requireSender(txBlock);
       const veSca = await requireVeSca(builder, txBlock, veScaKey);
 
@@ -414,10 +414,13 @@ const generateQuickVeScaMethod: GenerateVeScaQuickMethod = ({
         txBlock.transferObjects(transferObjects, sender);
       }
     },
-    redeemScaQuick: async <S extends boolean>(
-      veScaKey?: SuiObjectArg,
-      transferSca: S = true as S
-    ) => {
+    redeemScaQuick: async <T extends boolean>({
+      veScaKey,
+      transferSca,
+    }: {
+      veScaKey?: SuiObjectData | string;
+      transferSca?: T;
+    }) => {
       const sender = requireSender(txBlock);
       const veSca = await requireVeSca(builder, txBlock, veScaKey);
 
@@ -429,14 +432,18 @@ const generateQuickVeScaMethod: GenerateVeScaQuickMethod = ({
           txBlock.transferObjects([sca], sender);
           return;
         }
-        return sca as QuickMethodReturnType<S>;
+        return sca as QuickMethodReturnType<T>;
       }
     },
-    splitVeScaQuick: async <S extends boolean>(
-      splitAmount: string,
-      veScaKey: string,
-      transferVeScaKey: S = true as S
-    ) => {
+    splitVeScaQuick: async <S extends boolean>({
+      splitAmount,
+      veScaKey,
+      transferVeScaKey = true as S,
+    }: {
+      splitAmount: string;
+      veScaKey: string;
+      transferVeScaKey?: S;
+    }) => {
       const isKeyInSubTable = await isInSubsTable(
         builder,
         veScaKey,
@@ -465,12 +472,12 @@ const generateQuickVeScaMethod: GenerateVeScaQuickMethod = ({
         return newVeScaKey as QuickMethodReturnType<S>;
       }
     },
-    mergeVeScaQuick: async (targetKey: string, sourceKey: string) => {
+    mergeVeScaQuick: async ({ targetVeScaKey, sourceVeScaKey }) => {
       // check targetKey and sourceKey
       const table = builder.address.get('vesca.subsTableId');
       const [isTargetInSubTable, isSourceInSubTable] = await Promise.all([
-        isInSubsTable(builder, targetKey, table),
-        isInSubsTable(builder, sourceKey, table),
+        isInSubsTable(builder, targetVeScaKey, table),
+        isInSubsTable(builder, sourceVeScaKey, table),
       ]);
 
       const unstakeObligationBeforeStake =
@@ -491,8 +498,8 @@ const generateQuickVeScaMethod: GenerateVeScaQuickMethod = ({
       }
 
       const [sourceVesca, targetVesca] = await Promise.all([
-        getVeSca(builder.utils, sourceKey),
-        getVeSca(builder.utils, targetKey),
+        getVeSca(builder.utils, sourceVeScaKey),
+        getVeSca(builder.utils, targetVeScaKey),
       ]);
 
       if (!sourceVesca || !targetVesca) {
@@ -512,7 +519,7 @@ const generateQuickVeScaMethod: GenerateVeScaQuickMethod = ({
         );
       }
 
-      return txBlock.mergeVeSca(targetKey, sourceKey);
+      return txBlock.mergeVeSca(targetVeScaKey, sourceVeScaKey);
     },
   };
 };

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/scallopClient.ts

@@ -1085,9 +1085,12 @@ class ScallopClient implements ScallopClientInterface {
     tx.setSender(sender);
 
     await Promise.all(
-      veScaKeys.map(async (key) => {
+      veScaKeys.map(async (veScaKey) => {
         try {
-          const scaCoin = await tx.redeemScaQuick(key, false);
+          const scaCoin = await tx.redeemScaQuick({
+            veScaKey,
+            transferSca: false,
+          });
           if (!scaCoin) return;
           scaCoins.push(scaCoin);
         } catch (_e) {

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

@@ -1,6 +1,7 @@
 import { SuiTxBlock as SuiKitTxBlock, SuiObjectArg } from '@scallop-io/sui-kit';
 import type { TransactionResult } from '@mysten/sui/transactions';
 import { ScallopBuilder } from 'src/models';
+import { SuiObjectData } from '@mysten/sui/client';
 
 export type VeScaNormalMethods = {
   lockSca: (
@@ -31,7 +32,7 @@ export type VeScaNormalMethods = {
 
 export type QuickMethodReturnType<T extends boolean> = T extends true
   ? void
-  : TransactionResult | undefined;
+  : TransactionResult;
 
 export type VeScaQuickMethods = {
   /**
@@ -50,41 +51,41 @@ export type VeScaQuickMethods = {
    * @param lockPeriodInDays
    * @param autoCheck
    */
-  lockScaQuick(
-    amountOrCoin?: SuiObjectArg | number,
-    lockPeriodInDays?: number,
-    veScaKey?: SuiObjectArg,
-    autoCheck?: boolean
-  ): Promise<void>;
-  extendLockPeriodQuick: (
-    lockPeriodInDays: number,
-    veScaKey?: SuiObjectArg,
-    autoCheck?: boolean
-  ) => Promise<void>;
-  extendLockAmountQuick: (
-    scaAmount: number,
-    veScaKey?: SuiObjectArg,
-    autoCheck?: boolean
-  ) => Promise<void>;
-  renewExpiredVeScaQuick: (
-    scaAmount: number,
-    lockPeriodInDays: number,
-    veScaKey?: SuiObjectArg,
-    autoCheck?: boolean
-  ) => Promise<void>;
-  redeemScaQuick: <T extends boolean>(
-    veScaKey?: SuiObjectArg,
-    transferSca?: T
-  ) => Promise<QuickMethodReturnType<T>>;
-  splitVeScaQuick: <T extends boolean>(
-    splitAmount: string,
-    veScaKey: string,
-    transferVeScaKey?: T
-  ) => Promise<QuickMethodReturnType<T>>;
-  mergeVeScaQuick: (
-    targetVeScaKey: string,
-    sourceVeScaKey: string
-  ) => Promise<void>;
+  lockScaQuick(params: {
+    amountOrCoin?: SuiObjectArg | number;
+    lockPeriodInDays?: number;
+    autoCheck?: boolean;
+    veScaKey?: SuiObjectData | string;
+  }): Promise<void>;
+  extendLockPeriodQuick: (params: {
+    lockPeriodInDays: number;
+    autoCheck?: boolean;
+    veScaKey?: SuiObjectData | string;
+  }) => Promise<void>;
+  extendLockAmountQuick: (params: {
+    scaAmount: number;
+    autoCheck?: boolean;
+    veScaKey?: SuiObjectData | string;
+  }) => Promise<void>;
+  renewExpiredVeScaQuick: (params: {
+    scaAmount: number;
+    lockPeriodInDays: number;
+    autoCheck?: boolean;
+    veScaKey?: SuiObjectData | string;
+  }) => Promise<void>;
+  redeemScaQuick: <T extends boolean>(params: {
+    veScaKey?: SuiObjectData | string;
+    transferSca?: T;
+  }) => Promise<QuickMethodReturnType<T> | undefined>;
+  splitVeScaQuick: <T extends boolean>(params: {
+    splitAmount: string;
+    veScaKey: string;
+    transferVeScaKey?: T;
+  }) => Promise<QuickMethodReturnType<T> | undefined>;
+  mergeVeScaQuick: (params: {
+    targetVeScaKey: string;
+    sourceVeScaKey: string;
+  }) => Promise<void>;
 };
 
 export type SuiTxBlockWithVeScaNormalMethods = SuiKitTxBlock &

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;
+};