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

package/src/constants/testAddress.ts

@@ -236,6 +236,36 @@ export const TEST_ADDRESSES: AddressesInterface = {
           },
         },
       },
+      deep: {
+        id: '0xdeeb7a4662eec9f2f3def03fb937a663dddaa2e215b8078a284d026b7946c270',
+        metaData:
+          '0x6e60b051a08fa836f5a7acd7c464c8d9825bc29c44657fe170fe9b8e1e4770c0',
+        treasury: '',
+        oracle: {
+          supra: '',
+          switchboard: '',
+          pyth: {
+            feed: '29bdd5248234e33bd93d3b81100b5fa32eaa5997843847e2c2cb16d7c6d9f7ff',
+            feedObject:
+              '0x8c7f3a322b94cc69db2a2ac575cbd94bf5766113324c3a3eceac91e3e88a51ed',
+          },
+        },
+      },
+      fud: {
+        id: '0x76cb819b01abed502bee8a702b4c2d547532c12f25001c9dea795a5e631c26f1',
+        metaData:
+          '0x01087411ef48aaac1eb6e24803213e3a60a03b147dac930e5e341f17a85e524e',
+        treasury: '',
+        oracle: {
+          supra: '',
+          switchboard: '',
+          pyth: {
+            feed: '6a4090703da959247727f2b490eb21aea95c8684ecfac675f432008830890c75',
+            feedObject:
+              '0x4531c3ed0d22f21f5fce882905372006c9aafa30f01db03b789e95a6c50de7b2',
+          },
+        },
+      },
     },
     oracles: {
       xOracle:
@@ -513,6 +543,18 @@ export const TEST_ADDRESSES: AddressesInterface = {
         treasury:
           '0xfd0f02def6358a1f266acfa1493d4707ee8387460d434fb667d63d755ff907ed',
       },
+      sdeep: {
+        coinType:
+          '0xeb7a05a3224837c5e5503575aed0be73c091d1ce5e43aa3c3e716e0ae614608f::scallop_deep::SCALLOP_DEEP',
+        treasury:
+          '0xc63838fabe37b25ad897392d89876d920f5e0c6a406bf3abcb84753d2829bc88',
+      },
+      sfud: {
+        coinType:
+          '0xe56d5167f427cbe597da9e8150ef5c337839aaf46891d62468dcf80bdd8e10d1::scallop_fud::SCALLOP_FUD',
+        treasury:
+          '0xf25212f11d182decff7a86165699a73e3d5787aced203ca539f43cfbc10db867',
+      },
     },
   },
 };

package/src/constants/tokenBucket.ts

@@ -1,2 +1,2 @@
-export const DEFAULT_TOKENS_PER_INTERVAL = 50;
-export const DEFAULT_INTERVAL_IN_MS = 100;
+export const DEFAULT_TOKENS_PER_INTERVAL = 10;
+export const DEFAULT_INTERVAL_IN_MS = 250;

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from './constants';
 export * from './models';
 export type * from './types';
+export * from './utils/tokenBucket';

package/src/models/scallopBuilder.ts

@@ -7,7 +7,13 @@ import { ScallopQuery } from './scallopQuery';
 import { ScallopUtils } from './scallopUtils';
 import type { SuiTransactionBlockResponse } from '@mysten/sui/client';
 import type { Transaction } from '@mysten/sui/transactions';
-import type { SuiTxBlock as SuiKitTxBlock } from '@scallop-io/sui-kit';
+import type {
+  SuiAmountsArg,
+  SuiTxBlock as SuiKitTxBlock,
+  SuiObjectArg,
+  SuiTxArg,
+  SuiVecTxArg,
+} from '@scallop-io/sui-kit';
 import type {
   ScallopBuilderParams,
   ScallopTxBlock,
@@ -104,7 +110,7 @@ export class ScallopBuilder {
       await this.address.read();
     }
     await this.query.init(force, this.address);
-    await this.utils.init(force, this.address);
+    // await this.utils.init(force, this.address);
   }
 
   /**
@@ -215,4 +221,55 @@ export class ScallopBuilder {
       txBlock
     )) as SuiTransactionBlockResponse;
   }
+
+  public moveCall(
+    txb: ScallopTxBlock | SuiKitTxBlock,
+    target: string,
+    args?: (SuiTxArg | SuiVecTxArg | SuiObjectArg | SuiAmountsArg)[],
+    typeArgs?: string[]
+  ) {
+    // Disable for now
+    // const resolvedQueryTarget =
+    //   await this.cache.queryGetNormalizedMoveFunction(target);
+    // if (!resolvedQueryTarget) throw new Error('Invalid query target');
+
+    // const { parameters } = resolvedQueryTarget;
+    // try {
+    //   // we can try resolve the args first
+    //   const resolvedArgs = await Promise.all(
+    //     (args ?? []).map(async (arg, idx) => {
+    //       if (typeof arg !== 'string') return arg;
+
+    //       const cachedData = (await this.cache.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,
+    //       };
+    //     })
+    //   );
+    //   return txb.moveCall(target, resolvedArgs, typeArgs);
+    // } catch (e: any) {
+    //   console.error(e.message);
+    //   return txb.moveCall(target, args, typeArgs);
+    // }
+    return txb.moveCall(target, args, typeArgs);
+  }
 }

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