@scallop-io/sui-scallop-sdk 2.3.7 → 2.3.9

package/package.json

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

package/src/builders/coreBuilder.ts

@@ -267,6 +267,27 @@ const generateCoreNormalMethod: GenerateCoreNormalMethod = ({
         [coinType]
       );
     },
+    liquidate: (obligation, coin, debtCoinName, collateralCoinName) => {
+      const debtCoinType = builder.utils.parseCoinType(debtCoinName);
+      const collateralCoinType =
+        builder.utils.parseCoinType(collateralCoinName);
+      const [debtCoin, collateralCoin] = builder.moveCall(
+        txBlock,
+        `${coreIds.protocolPkg}::liquidate::liquidate`,
+        [
+          coreIds.version,
+          obligation,
+          coreIds.market,
+          coin,
+          coreIds.coinDecimalsRegistry,
+          coreIds.xOracle,
+          clockObjectRef,
+        ],
+        [debtCoinType, collateralCoinType]
+      );
+
+      return [debtCoin, collateralCoin] as [NestedResult, NestedResult];
+    },
   };
 };
 
@@ -489,6 +510,53 @@ const generateCoreQuickMethod: GenerateCoreQuickMethod = ({
         updateOracleOptions
       );
     },
+    liquidateQuick: async (
+      amount,
+      debtCoinName,
+      collateralCoinName,
+      obligationId,
+      updateOracleOptions
+    ) => {
+      const sender = requireSender(txBlock);
+
+      // Update oracle prices for debt and collateral coins
+      const updateCoinNames =
+        await builder.utils.getObligationCoinNames(obligationId);
+
+      await updateOracles(
+        builder,
+        txBlock,
+        updateCoinNames,
+        updateOracleOptions
+      );
+
+      // Select coins for liquidation
+      const { takeCoin, leftCoin } = await builder.selectCoin(
+        txBlock,
+        debtCoinName,
+        amount,
+        sender,
+        updateOracleOptions?.isSponsoredTx ?? false
+      );
+
+      if (leftCoin) {
+        txBlock.transferObjects([leftCoin], sender);
+      }
+
+      // Convert obligation to SharedObjectRef format
+      const obligationSharedObject =
+        typeof obligationId === 'string'
+          ? txBlock.object(obligationId)
+          : obligationId;
+
+      // Execute liquidation
+      return txBlock.liquidate(
+        obligationSharedObject,
+        takeCoin,
+        debtCoinName,
+        collateralCoinName
+      );
+    },
   };
 };
 

package/src/models/scallopSuiKit.ts

@@ -32,6 +32,8 @@ type QueryInspectTxnParams = {
   queryTarget: string;
   args: SuiObjectArg[];
   typeArgs?: any[];
+  txBlock?: SuiTxBlock;
+  keys?: QueryKey;
 };
 
 export type ScallopSuiKitParams = {
@@ -352,9 +354,9 @@ class ScallopSuiKit extends ScallopQueryClient {
     queryTarget,
     args,
     typeArgs,
+    txBlock = new SuiTxBlock(),
+    keys,
   }: QueryInspectTxnParams): Promise<DevInspectResults | null> {
-    const txBlock = new SuiTxBlock();
-
     const resolvedQueryTarget =
       await this.queryGetNormalizedMoveFunction(queryTarget);
     if (!resolvedQueryTarget) throw new Error('Invalid query target');
@@ -372,12 +374,15 @@ class ScallopSuiKit extends ScallopQueryClient {
     txBlock.moveCall(queryTarget, resolvedArgs, typeArgs);
 
     return await this.callWithRateLimiter(
-      queryKeys.rpc.getInspectTxn({
-        queryTarget,
-        args,
-        typeArgs,
-        node: this.currentFullNode,
-      }),
+      keys ??
+        queryKeys.rpc.getInspectTxn({
+          queryTarget,
+          args: args.map((arg) =>
+            typeof arg === 'object' && 'objectId' in arg ? arg.objectId : arg
+          ),
+          typeArgs,
+          node: this.currentFullNode,
+        }),
       () => this.suiKit.inspectTxn(txBlock)
     );
   }

package/src/queries/borrowIncentiveQuery.ts

@@ -3,6 +3,7 @@ import {
   parseOriginBorrowIncentivePoolData,
   parseOriginBorrowIncentiveAccountData,
   calculateBorrowIncentivePoolPointData,
+  getSharedObjectData,
 } from 'src/utils';
 import type {
   ScallopAddress,
@@ -22,6 +23,8 @@ import type {
 } from 'src/types';
 import BigNumber from 'bignumber.js';
 import { SuiObjectRef } from '@mysten/sui/client';
+import { SuiTxBlock } from '@scallop-io/sui-kit';
+import { queryKeys } from 'src/constants';
 
 /**
  * Query borrow incentive pools data using moveCall
@@ -38,11 +41,24 @@ export const queryBorrowIncentivePools = async ({
   const queryPkgId = address.get('borrowIncentive.query');
   const incentivePoolsId = address.get('borrowIncentive.incentivePools');
 
+  const txBlock = new SuiTxBlock();
   const queryTarget = `${queryPkgId}::incentive_pools_query::incentive_pools_data`;
-  const args = [incentivePoolsId];
+  const args = [
+    txBlock.sharedObjectRef({
+      objectId: incentivePoolsId,
+      initialSharedVersion: '81234462',
+      mutable: true,
+    }),
+  ];
   const queryResult = await scallopSuiKit.queryInspectTxn({
     queryTarget,
     args,
+    txBlock,
+    keys: queryKeys.rpc.getInspectTxn({
+      queryTarget,
+      args: [incentivePoolsId],
+      node: scallopSuiKit.currentFullNode,
+    }),
   });
   const borrowIncentivePoolsQueryData = queryResult?.events[0].parsedJson as
     | BorrowIncentivePoolsQueryInterface
@@ -165,16 +181,33 @@ export const queryBorrowIncentiveAccounts = async (
   obligationId: string | SuiObjectRef,
   borrowIncentiveCoinNames: string[] = [...utils.constants.whitelist.lending]
 ) => {
+  const txBlock = new SuiTxBlock();
   const queryPkgId = utils.address.get('borrowIncentive.query');
   const incentiveAccountsId = utils.address.get(
     'borrowIncentive.incentiveAccounts'
   );
   const queryTarget = `${queryPkgId}::incentive_account_query::incentive_account_data`;
-  const args = [incentiveAccountsId, obligationId];
+  const args = [
+    txBlock.sharedObjectRef({
+      objectId: incentiveAccountsId,
+      initialSharedVersion: '81234462',
+      mutable: true,
+    }),
+    txBlock.sharedObjectRef({
+      ...(await getSharedObjectData(obligationId, utils.scallopSuiKit.client)),
+      mutable: true,
+    }),
+  ];
 
   const queryResult = await utils.scallopSuiKit.queryInspectTxn({
     queryTarget,
     args,
+    txBlock,
+    keys: queryKeys.rpc.getInspectTxn({
+      queryTarget,
+      args: [incentiveAccountsId, obligationId],
+      node: utils.scallopSuiKit.currentFullNode,
+    }),
   });
   const borrowIncentiveAccountsQueryData = queryResult?.events[0]
     ?.parsedJson as BorrowIncentiveAccountsQueryInterface | undefined;

package/src/queries/coreQuery.ts

@@ -12,7 +12,7 @@ import type {
   SuiObjectData,
   SuiParsedData,
 } from '@mysten/sui/client';
-import type { SuiObjectArg } from '@scallop-io/sui-kit';
+import { SuiTxBlock, type SuiObjectArg } from '@scallop-io/sui-kit';
 // import type { ScallopAddress, ScallopCache, ScallopQuery } from '../models';
 import {
   Market,
@@ -46,6 +46,8 @@ import {
   ScallopIndexer,
   ScallopAddress,
 } from 'src/models';
+import { getSharedObjectData } from 'src/utils/object';
+import { queryKeys } from 'src/constants';
 
 /**
  * Query market data.
@@ -103,14 +105,27 @@ export const queryMarket = async (
     };
   }
 
+  const txBlock = new SuiTxBlock();
   const packageId = utils.address.get('core.packages.query.id');
   const marketId = utils.address.get('core.market');
   const queryTarget = `${packageId}::market_query::market_data`;
-  const args = [marketId];
+  const args = [
+    txBlock.sharedObjectRef({
+      objectId: marketId,
+      initialSharedVersion: '7765848',
+      mutable: true,
+    }),
+  ];
 
   const queryResult = await utils.scallopSuiKit.queryInspectTxn({
     queryTarget,
     args,
+    txBlock,
+    keys: queryKeys.rpc.getInspectTxn({
+      queryTarget,
+      args: [marketId],
+      node: utils.scallopSuiKit.currentFullNode,
+    }),
   });
   const marketData = queryResult?.events[0]?.parsedJson as
     | MarketQueryInterface
@@ -936,15 +951,27 @@ export const queryObligation = async (
   },
   obligationId: SuiObjectArg
 ) => {
+  const txBlock = new SuiTxBlock();
   const packageId = address.get('core.packages.query.id');
   const version = address.get('core.version');
   const market = address.get('core.market');
   const queryTarget = `${packageId}::obligation_query::obligation_data`;
 
   const args = [
-    version,
-    market,
-    obligationId,
+    txBlock.sharedObjectRef({
+      objectId: version,
+      initialSharedVersion: '7765848',
+      mutable: false,
+    }),
+    txBlock.sharedObjectRef({
+      objectId: market,
+      initialSharedVersion: '7765848',
+      mutable: true,
+    }),
+    txBlock.sharedObjectRef({
+      ...(await getSharedObjectData(obligationId, scallopSuiKit.client)),
+      mutable: true,
+    }),
     {
       objectId: SUI_CLOCK_OBJECT_ID,
       mutable: false,
@@ -953,7 +980,16 @@ export const queryObligation = async (
   ];
 
   const queryResult = await scallopSuiKit.queryInspectTxn(
-    { queryTarget, args }
+    {
+      queryTarget,
+      args,
+      txBlock,
+      keys: queryKeys.rpc.getInspectTxn({
+        queryTarget,
+        args: [version, market, obligationId],
+        node: scallopSuiKit.currentFullNode,
+      }),
+    }
     // txBlock
   );
   return queryResult?.events[0]?.parsedJson as

package/src/queries/sCoinQuery.ts

@@ -1,8 +1,11 @@
 import { bcs } from '@mysten/sui/bcs';
+import { SuiTxBlock } from '@scallop-io/sui-kit';
 import assert from 'assert';
 import BigNumber from 'bignumber.js';
+import { queryKeys } from 'src/constants';
 import { ScallopQuery, ScallopUtils } from 'src/models';
 import { OptionalKeys, sCoinBalance } from 'src/types';
+import { getSharedObjectData } from 'src/utils';
 
 /**
  * Get total supply of sCoin
@@ -18,9 +21,16 @@ export const getSCoinTotalSupply = async (
   },
   sCoinName: string
 ): Promise<sCoinBalance> => {
+  const txBlock = new SuiTxBlock();
   const sCoinPkgId = utils.address.get('scoin.id');
   // get treasury
-  const args = [utils.getSCoinTreasury(sCoinName)];
+  const treasury = utils.getSCoinTreasury(sCoinName);
+  const args = [
+    txBlock.sharedObjectRef({
+      ...(await getSharedObjectData(treasury, utils.scallopSuiKit.client)),
+      mutable: false,
+    }),
+  ];
   const typeArgs = [
     utils.parseSCoinType(sCoinName),
     utils.parseUnderlyingSCoinType(sCoinName),
@@ -30,6 +40,12 @@ export const getSCoinTotalSupply = async (
     queryTarget,
     args,
     typeArgs,
+    txBlock,
+    keys: queryKeys.rpc.getInspectTxn({
+      queryTarget,
+      args: [treasury],
+      node: utils.scallopSuiKit.currentFullNode,
+    }),
   });
   const results = queryResults?.results;
   if (results && results[0]?.returnValues) {

package/src/queries/vescaQuery.ts

@@ -191,13 +191,34 @@ const getTotalVeScaTreasuryAmount = async (
     initialSharedVersion: '1',
   });
 
+  const treasuryRef =
+    typeof veScaTreasury === 'string'
+      ? txb.sharedObjectRef({
+          objectId: veScaTreasury,
+          initialSharedVersion: '75353922',
+          mutable: true,
+        })
+      : txb.sharedObjectRef({
+          objectId: veScaTreasury.objectId,
+          initialSharedVersion: '75353922',
+          mutable: true,
+        });
+
   // refresh query
   const refreshQueryTarget = `${veScaPkgId}::treasury::refresh`;
-  const refreshArgs = [veScaConfig, veScaTreasury, clockObjectRef];
+  const refreshArgs = [
+    txb.sharedObjectRef({
+      objectId: veScaConfig,
+      initialSharedVersion: '75353922',
+      mutable: false,
+    }),
+    treasuryRef,
+    clockObjectRef,
+  ];
 
   // query total veSca amount
   const veScaAmountQueryTarget = `${veScaPkgId}::treasury::total_ve_sca_amount`;
-  const vescaAmountArgs = [veScaTreasury, clockObjectRef];
+  const vescaAmountArgs = [treasuryRef, clockObjectRef];
 
   // resolve each args
   const resolvedRefreshArgs = await Promise.all(

package/src/types/builder/core.ts

@@ -81,6 +81,12 @@ export type CoreNormalMethods = {
     loan: SuiObjectArg,
     poolCoinName: string
   ) => void;
+  liquidate: (
+    obligation: SuiObjectArg,
+    coin: SuiObjectArg,
+    debtCoinName: string,
+    collateralCoinName: string
+  ) => [NestedResult, NestedResult];
 };
 
 export type CoreQuickMethods = {
@@ -152,6 +158,18 @@ export type CoreQuickMethods = {
       isSponsoredTx?: boolean;
     }
   ) => Promise<void>;
+  liquidateQuick: (
+    amount: number,
+    debtCoinName: string,
+    collateralCoinName: string,
+    obligationId: SuiObjectArg,
+    updateOracleOptions?: {
+      usePythPullModel?: boolean;
+      useOnChainXOracleList?: boolean;
+      sponsoredFeeds?: string[];
+      isSponsoredTx?: boolean;
+    }
+  ) => Promise<[NestedResult, NestedResult]>;
 };
 
 export type SuiTxBlockWithCoreNormalMethods = SuiKitTxBlock &

package/src/utils/index.ts

@@ -3,3 +3,4 @@ export * from './query';
 export * from './util';
 export * from './indexer';
 export * from './core';
+export * from './object';

package/src/utils/object.ts

@@ -0,0 +1,40 @@
+import { getFullnodeUrl, SuiClient, SuiObjectData } from '@mysten/sui/client';
+
+const parseObjectData = (data: SuiObjectData) => {
+  if (
+    typeof data === 'object' &&
+    'objectId' in data &&
+    'owner' in data &&
+    data.owner &&
+    typeof data.owner === 'object' &&
+    'Shared' in data.owner &&
+    'initial_shared_version' in data.owner.Shared
+  ) {
+    return {
+      objectId: data.objectId,
+      initialSharedVersion: data.owner.Shared.initial_shared_version.toString(),
+    };
+  }
+
+  throw new Error('Invalid shared object data');
+};
+
+export const getSharedObjectData = async (
+  object: any,
+  client: SuiClient = new SuiClient({
+    url: getFullnodeUrl('mainnet'),
+  })
+) => {
+  if (typeof object === 'string') {
+    const objectData = await client.getObject({
+      id: object,
+      options: {
+        showOwner: true,
+        showContent: false,
+      },
+    });
+    return parseObjectData(objectData.data!);
+  } else {
+    return parseObjectData(object);
+  }
+};