@scallop-io/sui-scallop-sdk 1.4.1-alpha.1 → 1.4.2-rc.1

package/src/models/scallopCache.ts

@@ -3,6 +3,7 @@ import {
   SuiObjectArg,
   SuiTxBlock,
   normalizeStructTag,
+  parseStructTag,
 } from '@scallop-io/sui-kit';
 import { SuiKit } from '@scallop-io/sui-kit';
 import type {
@@ -106,6 +107,12 @@ export class ScallopCache {
     );
   }
 
+  private retryFn(errCount: number, e: any) {
+    if (errCount === 5) return false;
+    if (e.status === 429) return true;
+    return false;
+  }
+
   /**
    * @description Provides cache for inspectTxn of the SuiKit.
    * @param QueryInspectTxnParams
@@ -119,19 +126,75 @@ export class ScallopCache {
   }: QueryInspectTxnParams): Promise<DevInspectResults | null> {
     const txBlock = new SuiTxBlock();
 
-    txBlock.moveCall(queryTarget, args, typeArgs);
+    const resolvedQueryTarget =
+      await this.queryGetNormalizedMoveFunction(queryTarget);
+    if (!resolvedQueryTarget) throw new Error('Invalid query target');
+
+    const { parameters } = resolvedQueryTarget;
+
+    const resolvedArgs = await Promise.all(
+      (args ?? []).map(async (arg, idx) => {
+        if (typeof arg !== 'string') return arg;
+
+        const cachedData = (await this.queryGetObject(arg))?.data;
+        if (!cachedData) return arg;
+
+        const owner = cachedData.owner;
+        if (!owner || typeof owner !== 'object' || !('Shared' in owner))
+          return {
+            objectId: cachedData.objectId,
+            version: cachedData.version,
+            digest: cachedData.digest,
+          };
+
+        const parameter = parameters[idx];
+        if (
+          typeof parameter !== 'object' ||
+          !('MutableReference' in parameter || 'Reference' in parameter)
+        )
+          return arg;
+
+        return {
+          objectId: cachedData.objectId,
+          initialSharedVersion: owner.Shared.initial_shared_version,
+          mutable: 'MutableReference' in parameter,
+        };
+      })
+    );
+    txBlock.moveCall(queryTarget, resolvedArgs, typeArgs);
 
     const query = await this.queryClient.fetchQuery({
+      retry: this.retryFn,
+      retryDelay: 1000,
       queryKey: queryKeys.rpc.getInspectTxn(queryTarget, args, typeArgs),
       queryFn: async () => {
-        return await callWithRateLimit(this.tokenBucket, () =>
-          this.suiKit.inspectTxn(txBlock)
+        return await callWithRateLimit(
+          this.tokenBucket,
+          async () => await this.suiKit.inspectTxn(txBlock)
         );
       },
     });
     return query;
   }
 
+  public async queryGetNormalizedMoveFunction(target: string) {
+    const { address, module, name } = parseStructTag(target);
+    return this.queryClient.fetchQuery({
+      queryKey: queryKeys.rpc.getNormalizedMoveFunction(target),
+      queryFn: async () => {
+        return await callWithRateLimit(
+          this.tokenBucket,
+          async () =>
+            await this.suiKit.client().getNormalizedMoveFunction({
+              package: address,
+              module,
+              function: name,
+            })
+        );
+      },
+    });
+  }
+
   /**
    * @description Provides cache for getObject of the SuiKit.
    * @param objectId
@@ -141,15 +204,24 @@ export class ScallopCache {
   public async queryGetObject(
     objectId: string,
     options?: SuiObjectDataOptions
-  ): Promise<SuiObjectResponse | null> {
+  ) {
+    options = {
+      ...options,
+      showOwner: true,
+      showContent: true,
+    };
     return this.queryClient.fetchQuery({
-      queryKey: queryKeys.rpc.getObject(objectId, this.walletAddress, options),
+      retry: this.retryFn,
+      retryDelay: 1000,
+      queryKey: queryKeys.rpc.getObject(objectId, options),
       queryFn: async () => {
-        return await callWithRateLimit(this.tokenBucket, () =>
-          this.client.getObject({
-            id: objectId,
-            options,
-          })
+        return await callWithRateLimit(
+          this.tokenBucket,
+          async () =>
+            await this.client.getObject({
+              id: objectId,
+              options,
+            })
         );
       },
     });
@@ -170,15 +242,36 @@ export class ScallopCache {
     // objectIds.sort();
 
     return this.queryClient.fetchQuery({
+      retry: this.retryFn,
+      retryDelay: 1000,
       queryKey: queryKeys.rpc.getObjects(
         objectIds,
         this.walletAddress,
         options
       ),
       queryFn: async () => {
-        return await callWithRateLimit(this.tokenBucket, () =>
-          this.suiKit.getObjects(objectIds, options)
+        const results = await callWithRateLimit(
+          this.tokenBucket,
+          async () => await this.suiKit.getObjects(objectIds, options)
         );
+        if (results) {
+          results.forEach((result) => {
+            this.queryClient.setQueriesData(
+              {
+                exact: false,
+                queryKey: queryKeys.rpc.getObject(result.objectId, options),
+              },
+              {
+                data: result,
+                error: null,
+              },
+              {
+                updatedAt: Date.now(),
+              }
+            );
+          });
+        }
+        return results;
       },
     });
   }
@@ -189,12 +282,44 @@ export class ScallopCache {
    * @returns Promise<PaginatedObjectsResponse>
    */
   public async queryGetOwnedObjects(input: GetOwnedObjectsParams) {
+    // TODO: This query need its own separate rate limiter (as owned objects can theoretically be infinite), need a better way to handle this
     return this.queryClient.fetchQuery({
+      retry: this.retryFn,
+      retryDelay: 1000,
       queryKey: queryKeys.rpc.getOwnedObjects(input),
       queryFn: async () => {
-        return await callWithRateLimit(this.tokenBucket, () =>
-          this.client.getOwnedObjects(input)
+        const results = await callWithRateLimit(
+          this.tokenBucket,
+          async () => await this.client.getOwnedObjects(input)
         );
+        if (results && results.data.length > 0) {
+          results.data
+            .filter(
+              (
+                result
+              ): result is typeof result &
+                NonNullable<{ data: SuiObjectData }> => !!result.data
+            )
+            .forEach((result) => {
+              this.queryClient.setQueriesData(
+                {
+                  exact: false,
+                  queryKey: queryKeys.rpc.getObject(
+                    result.data.objectId,
+                    input.options ?? {}
+                  ),
+                },
+                {
+                  data: result.data,
+                  error: null,
+                },
+                {
+                  updatedAt: Date.now(),
+                }
+              );
+            });
+        }
+        return results;
       },
     });
   }
@@ -203,10 +328,13 @@ export class ScallopCache {
     input: GetDynamicFieldsParams
   ): Promise<DynamicFieldPage | null> {
     return this.queryClient.fetchQuery({
+      retry: this.retryFn,
+      retryDelay: 1000,
       queryKey: queryKeys.rpc.getDynamicFields(input),
       queryFn: async () => {
-        return await callWithRateLimit(this.tokenBucket, () =>
-          this.client.getDynamicFields(input)
+        return await callWithRateLimit(
+          this.tokenBucket,
+          async () => await this.client.getDynamicFields(input)
         );
       },
     });
@@ -216,11 +344,32 @@ export class ScallopCache {
     input: GetDynamicFieldObjectParams
   ): Promise<SuiObjectResponse | null> {
     return this.queryClient.fetchQuery({
+      retry: this.retryFn,
+      retryDelay: (attemptIndex) => Math.min(1000 * attemptIndex, 8000),
       queryKey: queryKeys.rpc.getDynamicFieldObject(input),
       queryFn: async () => {
-        return await callWithRateLimit(this.tokenBucket, () =>
+        const result = await callWithRateLimit(this.tokenBucket, () =>
           this.client.getDynamicFieldObject(input)
         );
+        if (result?.data) {
+          this.queryClient.setQueriesData(
+            {
+              exact: false,
+              queryKey: queryKeys.rpc.getObject(result?.data.objectId, {
+                showContent: true,
+                showOwner: true,
+              }),
+            },
+            {
+              data: result.data,
+              error: null,
+            },
+            {
+              updatedAt: Date.now(),
+            }
+          );
+        }
+        return result;
       },
     });
   }
@@ -229,10 +378,13 @@ export class ScallopCache {
     owner: string
   ): Promise<{ [k: string]: string }> {
     return this.queryClient.fetchQuery({
+      retry: this.retryFn,
+      retryDelay: 1000,
       queryKey: queryKeys.rpc.getAllCoinBalances(owner),
       queryFn: async () => {
-        const allBalances = await callWithRateLimit(this.tokenBucket, () =>
-          this.client.getAllBalances({ owner })
+        const allBalances = await callWithRateLimit(
+          this.tokenBucket,
+          async () => await this.client.getAllBalances({ owner })
         );
         if (!allBalances) return {};
         const balances = allBalances.reduce(

package/src/models/scallopClient.ts

@@ -232,7 +232,7 @@ export class ScallopClient {
     sign: S = true as S
   ): Promise<ScallopClientFnReturnType<S>> {
     const txBlock = this.builder.createTxBlock();
-    txBlock.openObligationEntry();
+    await txBlock.openObligationEntry();
     if (sign) {
       return (await this.suiKit.signAndSendTxn(
         txBlock
@@ -283,9 +283,10 @@ export class ScallopClient {
         specificObligationId
       );
     } else {
-      const [obligation, obligationKey, hotPotato] = txBlock.openObligation();
+      const [obligation, obligationKey, hotPotato] =
+        await txBlock.openObligation();
       await txBlock.addCollateralQuick(amount, collateralCoinName, obligation);
-      txBlock.returnObligation(obligation, hotPotato);
+      await txBlock.returnObligation(obligation, hotPotato);
       txBlock.transferObjects([obligationKey], sender);
     }
 
@@ -425,7 +426,7 @@ export class ScallopClient {
         targetStakeAccount
       );
     } else {
-      const account = txBlock.createStakeAccount(stakeMarketCoinName);
+      const account = await txBlock.createStakeAccount(stakeMarketCoinName);
       await txBlock.stakeQuick(marketCoin, stakeMarketCoinName, account);
       txBlock.transferObjects([account], sender);
     }
@@ -611,8 +612,12 @@ export class ScallopClient {
     const txBlock = this.builder.createTxBlock();
     const sender = walletAddress ?? this.walletAddress;
     txBlock.setSender(sender);
-    const [coin, loan] = txBlock.borrowFlashLoan(amount, poolCoinName);
-    txBlock.repayFlashLoan(await callback(txBlock, coin), loan, poolCoinName);
+    const [coin, loan] = await txBlock.borrowFlashLoan(amount, poolCoinName);
+    await txBlock.repayFlashLoan(
+      await callback(txBlock, coin),
+      loan,
+      poolCoinName
+    );
 
     if (sign) {
       return (await this.suiKit.signAndSendTxn(
@@ -649,7 +654,7 @@ export class ScallopClient {
     const sender = walletAddress ?? this.walletAddress;
     txBlock.setSender(sender);
 
-    const stakeAccount = txBlock.createStakeAccount(marketCoinName);
+    const stakeAccount = await txBlock.createStakeAccount(marketCoinName);
     txBlock.transferObjects([stakeAccount], sender);
 
     if (sign) {
@@ -699,7 +704,7 @@ export class ScallopClient {
     if (targetStakeAccount) {
       await txBlock.stakeQuick(amount, stakeMarketCoinName, targetStakeAccount);
     } else {
-      const account = txBlock.createStakeAccount(stakeMarketCoinName);
+      const account = await txBlock.createStakeAccount(stakeMarketCoinName);
       await txBlock.stakeQuick(amount, stakeMarketCoinName, account);
       txBlock.transferObjects([account], sender);
     }
@@ -814,7 +819,7 @@ export class ScallopClient {
       this.utils.parseCoinName<SupportStakeCoins>(stakeMarketCoinName);
 
     if (stakeMarketCoin) {
-      const coin = txBlock.withdraw(stakeMarketCoin, stakeCoinName);
+      const coin = await txBlock.withdraw(stakeMarketCoin, stakeCoinName);
       await this.utils.mergeSimilarCoins(
         txBlock,
         coin,
@@ -965,6 +970,7 @@ export class ScallopClient {
     const rewardCoinsCollection: Record<string, TransactionResult[]> = {};
     const obligationAccount =
       await this.query.getObligationAccount(obligationId);
+    if (!obligationAccount) throw new Error('Obligation not found');
     const rewardCoinNames = Object.values(obligationAccount.borrowIncentives)
       .flatMap(({ rewards }) =>
         rewards.filter(({ availableClaimAmount }) => availableClaimAmount > 0)
@@ -1047,7 +1053,7 @@ export class ScallopClient {
         // if market coin found, mint sCoin
         if (toDestroyMarketCoin) {
           // mint new sCoin
-          const sCoin = txBlock.mintSCoin(
+          const sCoin = await txBlock.mintSCoin(
             sCoinName as SupportSCoin,
             toDestroyMarketCoin
           );

package/src/models/scallopQuery.ts

@@ -14,11 +14,9 @@ import {
   getStakeRewardPool,
   getPythPrice,
   getMarketPools,
-  getMarketPool,
   getMarketCollaterals,
   getMarketCollateral,
   getSpools,
-  getSpool,
   queryBorrowIncentiveAccounts,
   getCoinAmounts,
   getCoinAmount,
@@ -27,7 +25,6 @@ import {
   getLendings,
   getLending,
   getObligationAccounts,
-  getObligationAccount,
   getTotalValueLocked,
   queryVeScaKeyIdFromReferralBindings,
   getBindedObligationId,
@@ -41,13 +38,15 @@ import {
   getBorrowIncentivePools,
   getBorrowLimit,
   getIsolatedAssets,
-  isIsolatedAsset,
+  // isIsolatedAsset,
   getSupplyLimit,
   getSCoinAmount,
   getSCoinAmounts,
   getSCoinSwapRate,
   getSCoinTotalSupply,
   getAllCoinPrices,
+  getAllAddresses,
+  isIsolatedAsset,
 } from '../queries';
 import {
   ScallopQueryParams,
@@ -188,6 +187,7 @@ export class ScallopQuery {
   /* ==================== Core Query Methods ==================== */
 
   /**
+   * @deprecated use getMarketPools
    * Query market data.
    * @param indexer - Whether to use indexer.
    * @return Market data.
@@ -211,7 +211,7 @@ export class ScallopQuery {
    * @return Market pools data.
    */
   public async getMarketPools(
-    poolCoinNames?: SupportPoolCoins[],
+    poolCoinNames: SupportPoolCoins[] = [...SUPPORT_POOLS],
     args?: {
       coinPrices?: CoinPrices;
       indexer?: boolean;
@@ -235,18 +235,19 @@ export class ScallopQuery {
   public async getMarketPool(
     poolCoinName: SupportPoolCoins,
     args?: {
-      marketObject?: SuiObjectData | null;
       coinPrice?: number;
       indexer?: boolean;
     }
   ) {
-    return await getMarketPool(
-      this,
-      poolCoinName,
-      args?.indexer,
-      args?.marketObject,
-      args?.coinPrice
-    );
+    const marketPools = await this.getMarketPools(undefined, args);
+    return marketPools.pools[poolCoinName];
+    // return await getMarketPool(
+    //   this,
+    //   poolCoinName,
+    //   args?.indexer,
+    //   args?.marketObject,
+    //   args?.coinPrice
+    // );
   }
 
   /**
@@ -418,13 +419,8 @@ export class ScallopQuery {
       indexer?: boolean;
     }
   ) {
-    return await getSpool(
-      this,
-      stakeMarketCoinName,
-      args?.indexer,
-      args?.marketPool,
-      args?.coinPrices
-    );
+    const spools = await this.getSpools(undefined, args);
+    return spools[stakeMarketCoinName];
   }
 
   /**
@@ -546,7 +542,7 @@ export class ScallopQuery {
   public async getBorrowIncentivePools(
     coinNames?: SupportBorrowIncentiveCoins[],
     args?: {
-      coinPrices: CoinPrices;
+      coinPrices?: CoinPrices;
       indexer?: boolean;
       marketPools?: MarketPools;
     }
@@ -618,7 +614,7 @@ export class ScallopQuery {
    */
   public async getObligationAccounts(
     ownerAddress: string = this.walletAddress,
-    args?: { indexer: boolean }
+    args?: { indexer?: boolean }
   ) {
     return await getObligationAccounts(this, ownerAddress, args?.indexer);
   }
@@ -639,12 +635,16 @@ export class ScallopQuery {
     ownerAddress: string = this.walletAddress,
     args?: { indexer?: boolean }
   ) {
-    return await getObligationAccount(
-      this,
-      obligationId,
-      ownerAddress,
-      args?.indexer
+    const results = await this.getObligationAccounts(ownerAddress, args);
+    return Object.values(results).find(
+      (obligation) => obligation?.obligationId === obligationId
     );
+    // return await getObligationAccount(
+    //   this,
+    //   obligationId,
+    //   ownerAddress,
+    //   args?.indexer
+    // );
   }
 
   /**
@@ -812,7 +812,7 @@ export class ScallopQuery {
    * Get list of isolated assets
    */
   public async getIsolatedAssets() {
-    return await getIsolatedAssets(this.address);
+    return await getIsolatedAssets(this);
   }
 
   /**
@@ -841,4 +841,12 @@ export class ScallopQuery {
   }) {
     return getAllCoinPrices(this, args?.marketPools, args?.coinPrices);
   }
+
+  /**
+   * Query all address (lending pool, collateral pool, borrow dynamics, interest models) of all pool
+   * @returns
+   */
+  public async getPoolAddresses() {
+    return getAllAddresses(this);
+  }
 }

package/src/models/scallopUtils.ts

@@ -232,13 +232,14 @@ export class ScallopUtils {
   }
 
   /**
-   * Convert sCoin name to coin name.
+   * Convert sCoin name to market coin name.
    * This function will parse new sCoin name `scallop_...` to its old market coin name which is shorter
    * e.g: `scallop_sui -> ssui
+   * if no `scallop_...` is encountered, return coinName
    * @return sCoin name
    */
-  public parseCoinNameFromSCoinName(coinName: string) {
-    return sCoinRawNameToName[coinName];
+  public parseSCoinTypeNameToMarketCoinName(coinName: string) {
+    return sCoinRawNameToName[coinName] ?? coinName;
   }
 
   /**
@@ -311,8 +312,14 @@ export class ScallopUtils {
   public parseCoinNameFromType<T extends SupportCoins>(
     coinType: string
   ): T extends SupportCoins ? T : SupportCoins;
+  public parseCoinNameFromType<T extends SupportSCoin>(
+    coinType: string
+  ): T extends SupportSCoin ? T : SupportSCoin;
   public parseCoinNameFromType(coinType: string) {
     coinType = normalizeStructTag(coinType);
+    if (sCoinTypeToName[coinType]) {
+      return sCoinTypeToName[coinType] as SupportSCoin;
+    }
 
     const coinTypeRegex = new RegExp(`((0x[^:]+::[^:]+::[^<>]+))(?![^<>]*<)`);
     const coinTypeMatch = coinType.match(coinTypeRegex);
@@ -553,7 +560,7 @@ export class ScallopUtils {
       const priceIds = priceIdPairs.map(([_, priceId]) => priceId);
 
       const pythConnection = new SuiPriceServiceConnection(endpoint, {
-        timeout: 2000,
+        timeout: 4000,
       });
 
       try {

package/src/queries/borrowIncentiveQuery.ts

@@ -1,6 +1,5 @@
 import { normalizeStructTag } from '@mysten/sui/utils';
 import {
-  sCoinRawNameToName,
   SUPPORT_BORROW_INCENTIVE_POOLS,
   SUPPORT_BORROW_INCENTIVE_REWARDS,
 } from '../constants';
@@ -66,7 +65,7 @@ export const getBorrowIncentivePools = async (
   const borrowIncentivePools: BorrowIncentivePools = {};
   marketPools =
     marketPools ??
-    (await query.getMarketPools(undefined, { indexer, coinPrices }));
+    (await query.getMarketPools(undefined, { coinPrices, indexer })).pools;
   coinPrices = coinPrices ?? (await query.getAllCoinPrices({ marketPools }));
 
   if (indexer) {
@@ -100,8 +99,10 @@ export const getBorrowIncentivePools = async (
     const borrowIncentivePoolPoints: OptionalKeys<
       Record<SupportBorrowIncentiveRewardCoins, BorrowIncentivePoolPoints>
     > = {};
-    const parsedBorrowIncentivePoolData =
-      parseOriginBorrowIncentivePoolData(pool);
+    const parsedBorrowIncentivePoolData = parseOriginBorrowIncentivePoolData(
+      query.utils,
+      pool
+    );
 
     const poolCoinType = normalizeStructTag(pool.pool_type.name);
     const poolCoinName =
@@ -121,13 +122,10 @@ export const getBorrowIncentivePools = async (
       parsedBorrowIncentivePoolData.poolPoints
     )) {
       const rewardCoinType = poolPoint.pointType;
-      let rewardCoinName = query.utils.parseCoinNameFromType(
+      const rewardCoinName = query.utils.parseCoinNameFromType(
         rewardCoinType
       ) as SupportBorrowIncentiveRewardCoins;
       // handle for scoin name
-      if (sCoinRawNameToName[rewardCoinName]) {
-        rewardCoinName = sCoinRawNameToName[rewardCoinName];
-      }
       const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
       const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
 

package/src/queries/borrowLimitQuery.ts

@@ -17,9 +17,9 @@ const borrowLimitZod = zod.object({
   }),
 });
 
-// TODO: enable for production
-// const borrowLimitKeyType = `0xe7dbb371a9595631f7964b7ece42255ad0e738cc85fe6da26c7221b220f01af6::market_dynamic_keys::BorrowLimitKey`; // prod
-const borrowLimitKeyType = `0xb784ea287d944e478a3ceaa071f8885072cce6b7224cf245914dc2f9963f460e::market_dynamic_keys::BorrowLimitKey`;
+const borrowLimitKeyType = `0xe7dbb371a9595631f7964b7ece42255ad0e738cc85fe6da26c7221b220f01af6::market_dynamic_keys::BorrowLimitKey`; // prod
+// const borrowLimitKeyType = `0xb784ea287d944e478a3ceaa071f8885072cce6b7224cf245914dc2f9963f460e::market_dynamic_keys::BorrowLimitKey`;
+
 /**
  * Return supply limit of a pool (including the decimals)
  * @param utils