@scallop-io/sui-scallop-sdk 2.3.0-lst-x-oracle-alpha.9 → 2.3.0

package/src/queries/portfolioQuery.ts

@@ -1,24 +1,24 @@
 import BigNumber from 'bignumber.js';
-import { minBigNumber, estimatedFactor } from './utils';
+import { minBigNumber, estimatedFactor } from 'src/utils';
 import type { ScallopQuery } from 'src/models';
-import { SuiObjectRef } from '@mysten/sui/client';
-import { normalizeStructTag, SUI_TYPE_ARG } from '@scallop-io/sui-kit';
-import {
-  CoinAmounts,
-  Lending,
-  Lendings,
+import type {
   Market,
-  MarketCollaterals,
   MarketPool,
-  MarketPools,
-  ObligationAccount,
-  ObligationAccounts,
-  ObligationBorrowIncentiveReward,
   Spool,
   StakeAccount,
+  Lendings,
+  Lending,
+  ObligationAccounts,
+  ObligationAccount,
+  CoinAmounts,
+  CoinPrices,
   TotalValueLocked,
-} from 'src/types/query';
-import { CoinPrices } from 'src/types/util';
+  ObligationBorrowIncentiveReward,
+  MarketPools,
+  MarketCollaterals,
+} from 'src/types';
+import { SuiObjectRef } from '@mysten/sui/client';
+import { normalizeStructTag, SUI_TYPE_ARG } from '@scallop-io/sui-kit';
 
 /**
  * Get user lending infomation for specific pools.
@@ -293,6 +293,8 @@ export const getLending = async (
  *
  * @param query - The Scallop query instance.
  * @param ownerAddress - The owner address.
+ * @param market - The market data.
+ * @param coinPrices - The coin prices data.
  * @param indexer - Whether to use indexer.
  * @return All obligation accounts data.
  */
@@ -338,12 +340,62 @@ export const getObligationAccounts = async (
   return obligationAccounts;
 };
 
+/**
+ * Get all obligation accounts data by ids.
+ *
+ * @param query - The Scallop query instance.
+ * @param obligationIds - Obligation account ids.
+ * @param market - The market data.
+ * @param coinPrices - The coin prices data.
+ * @param indexer - Whether to use indexer.
+ * @return All obligation accounts data.
+ */
+export const getObligationAccountsByIds = async (
+  query: ScallopQuery,
+  obligationIds: string[],
+  market?: {
+    pools: MarketPools;
+    collaterals: MarketCollaterals;
+  },
+  coinPrices?: CoinPrices,
+  indexer: boolean = false
+) => {
+  market = market ?? (await query.getMarketPools(undefined, { indexer }));
+  coinPrices =
+    coinPrices ??
+    (await query.getAllCoinPrices({
+      marketPools: market.pools,
+    }));
+
+  const obligationAccounts: ObligationAccount[] = [];
+  await Promise.allSettled(
+    obligationIds.map(async (obligationId) => {
+      const obligationAccount = await getObligationAccount(
+        query,
+        obligationId,
+        '',
+        indexer,
+        market,
+        coinPrices,
+        {}
+      );
+      if (obligationAccount) obligationAccounts.push(obligationAccount);
+    })
+  );
+
+  return obligationAccounts;
+};
+
 /**
  * Get obligation account data.
  *
  * @param query - The Scallop query instance.
  * @param obligation - The obligation id.
+ * @param ownerAddress - The owner address of the obligation.
  * @param indexer - Whether to use indexer.
+ * @param market - The market data.
+ * @param coinPrices - The coin prices data.
+ * @param coinAmounts - The coin amounts data.
  * @return Obligation account data.
  */
 export const getObligationAccount = async (
@@ -787,8 +839,6 @@ export const getTotalValueLocked = async (
   query: ScallopQuery,
   indexer: boolean = false
 ) => {
-  const market = await query.getMarketPools(undefined, { indexer });
-
   let supplyLendingValue = BigNumber(0);
   let supplyCollateralValue = BigNumber(0);
   let borrowValue = BigNumber(0);
@@ -811,6 +861,8 @@ export const getTotalValueLocked = async (
     return tvl;
   }
 
+  const market = await query.getMarketPools(undefined, { indexer });
+
   for (const pool of Object.values(market.pools)) {
     if (!pool) continue;
     supplyLendingValue = supplyLendingValue.plus(

package/src/queries/priceQuery.ts

@@ -1,7 +1,6 @@
 import { SuiObjectData } from '@mysten/sui/client';
 import type { ScallopAddress, ScallopQuery, ScallopSuiKit } from 'src/models';
-import type { MarketPools } from 'src/types/query';
-import type { CoinPrices } from 'src/types/util';
+import type { CoinPrices, MarketPools, OptionalKeys } from '../types';
 import BigNumber from 'bignumber.js';
 
 /**
@@ -151,7 +150,7 @@ export const getAllCoinPrices = async (
     throw new Error(`Failed to fetch market pool for getAllCoinPrices`);
   }
 
-  const sCoinPrices: CoinPrices = {};
+  const sCoinPrices: OptionalKeys<Record<string, number>> = {};
   query.constants.whitelist.scoin.forEach((sCoinName) => {
     const coinName = query.utils.parseCoinName(sCoinName);
     sCoinPrices[sCoinName] = BigNumber(coinPrices[coinName] ?? 0)

package/src/queries/sCoinQuery.ts

@@ -2,7 +2,7 @@ import { bcs } from '@mysten/sui/bcs';
 import assert from 'assert';
 import BigNumber from 'bignumber.js';
 import { ScallopQuery, ScallopUtils } from 'src/models';
-import { OptionalKeys } from 'src/types/util';
+import { OptionalKeys, sCoinBalance } from 'src/types';
 
 /**
  * Get total supply of sCoin
@@ -17,7 +17,7 @@ export const getSCoinTotalSupply = async (
     utils: ScallopUtils;
   },
   sCoinName: string
-): Promise<number> => {
+): Promise<sCoinBalance> => {
   const sCoinPkgId = utils.address.get('scoin.id');
   // get treasury
   const args = [utils.getSCoinTreasury(sCoinName)];

package/src/queries/spoolQuery.ts

@@ -5,100 +5,83 @@ import {
   parseOriginSpoolRewardPoolData,
   calculateSpoolRewardPoolData,
   parseObjectAs,
-} from './utils';
+  partitionArray,
+} from 'src/utils';
 import type { SuiObjectData, SuiObjectResponse } from '@mysten/sui/client';
 import type { ScallopQuery, ScallopUtils } from 'src/models';
-import {
-  OriginSpoolData,
-  OriginSpoolRewardPoolData,
-  SpoolData,
-  MarketPools,
+import type {
   Spools,
   Spool,
-  StakeAccounts,
   StakePool,
   StakeRewardPool,
-} from 'src/types/query';
-import { CoinPrices } from 'src/types/util';
+  StakeAccounts,
+  CoinPrices,
+  MarketPools,
+  OriginSpoolRewardPoolData,
+  SpoolData,
+  OriginSpoolData,
+} from '../types';
 
 const queryRequiredSpoolObjects = async (
   query: ScallopQuery,
   stakePoolCoinNames: string[]
 ) => {
-  // Phase 1: Single-pass data preparation
-  type KeyType = {
-    spool?: string;
-    spoolReward?: string;
-    sCoinTreasury?: string;
-  };
+  const keyTypes = ['spool', 'spoolReward', 'sCoinTreasury'] as const;
 
-  const keyCollections: Record<keyof KeyType, string[]> = {
-    spool: [],
-    spoolReward: [],
-    sCoinTreasury: [],
-  };
-
-  const taskMap = new Map<string, KeyType>();
+  const allObjectIds: string[] = [];
 
-  // Single iteration to collect all keys
   for (const poolCoinName of stakePoolCoinNames) {
     const poolData = query.constants.poolAddresses[poolCoinName];
-    const task: KeyType = {
-      spool: poolData?.spool,
-      spoolReward: poolData?.spoolReward,
-      sCoinTreasury: poolData?.sCoinTreasury,
-    };
-
-    // Add to key collections
-    (Object.entries(task) as [keyof KeyType, string | undefined][]).forEach(
-      ([key, value]) => {
-        if (value) keyCollections[key].push(value);
+    for (const keyType of keyTypes) {
+      if (poolData?.[keyType] && poolData[keyType] !== '') {
+        allObjectIds.push(poolData[keyType]);
       }
-    );
-
-    taskMap.set(poolCoinName, task);
+    }
   }
 
-  // Phase 2: Parallel queries with pre-collected keys
-  const [spoolObjects, spoolRewardObjects, sCoinTreasuryObjects] =
-    await Promise.all([
-      query.scallopSuiKit.queryGetObjects(keyCollections.spool),
-      query.scallopSuiKit.queryGetObjects(keyCollections.spoolReward),
-      query.scallopSuiKit.queryGetObjects(keyCollections.sCoinTreasury),
-    ]);
-
-  // Phase 3: Create lookup maps
-  const createObjectMap = (objects: SuiObjectData[]) =>
-    new Map(objects.map((obj) => [obj.objectId, obj]));
-
-  const objectMaps = {
-    spool: createObjectMap(spoolObjects),
-    spoolReward: createObjectMap(spoolRewardObjects),
-    sCoinTreasury: createObjectMap(sCoinTreasuryObjects),
-  };
+  const objectDatas: SuiObjectData[] = [];
+  const batches = partitionArray(allObjectIds, 50);
 
-  // Phase 4: Build result in single pass
-  const result: Record<string, any> = {};
-  for (const [poolCoinName, task] of taskMap) {
-    result[poolCoinName] = {
-      spool: task.spool ? objectMaps.spool.get(task.spool) : undefined,
-      spoolReward: task.spoolReward
-        ? objectMaps.spoolReward.get(task.spoolReward)
-        : undefined,
-      sCoinTreasury: task.sCoinTreasury
-        ? objectMaps.sCoinTreasury.get(task.sCoinTreasury)
-        : undefined,
-    };
+  console.log('Fetching spool objects in batches:', batches.length);
+
+  for (const batch of batches) {
+    const responses = await query.scallopSuiKit.queryGetObjects(batch);
+    if (responses.length > 0) {
+      objectDatas.push(...responses);
+    }
   }
 
-  return result as Record<
+  // Transform into map
+  const objectDataMap = objectDatas.reduce(
+    (acc, obj) => {
+      acc[obj.objectId] = obj;
+      return acc;
+    },
+    {} as Record<string, SuiObjectData>
+  );
+
+  const results: Record<
     string,
-    {
-      spool?: SuiObjectData;
-      spoolReward?: SuiObjectData;
-      sCoinTreasury?: SuiObjectData;
+    Record<(typeof keyTypes)[number], SuiObjectData>
+  > = {};
+
+  for (const poolCoinName of stakePoolCoinNames) {
+    const poolData = query.constants.poolAddresses[poolCoinName];
+    for (const keyType of keyTypes) {
+      const objectId = poolData?.[keyType];
+      if (objectId && objectId !== '') {
+        if (!results[poolCoinName]) {
+          results[poolCoinName] = {} as Record<
+            (typeof keyTypes)[number],
+            SuiObjectData
+          >;
+        }
+        results[poolCoinName][keyType] = objectDataMap[objectId];
+      }
     }
-  >;
+  }
+
+  return results;
 };
 
 const parseSpoolObjects = ({
@@ -164,11 +147,11 @@ export const getSpools = async (
       if (!stakeMarketCoinNames.includes(spool.marketCoinName)) return;
       const coinName = query.utils.parseCoinName(spool.marketCoinName);
       const rewardCoinName = query.utils.getSpoolRewardCoinName();
-      spool.coinPrice = coinPrices?.[coinName] ?? spool.coinPrice;
+      spool.coinPrice = coinPrices[coinName] ?? spool.coinPrice;
       spool.marketCoinPrice =
-        coinPrices?.[spool.marketCoinName] ?? spool.marketCoinPrice;
+        coinPrices[spool.marketCoinName] ?? spool.marketCoinPrice;
       spool.rewardCoinPrice =
-        coinPrices?.[rewardCoinName] ?? spool.rewardCoinPrice;
+        coinPrices[rewardCoinName] ?? spool.rewardCoinPrice;
       spools[spool.marketCoinName] = spool;
     };
     Object.values(spoolsIndexer)

package/src/queries/vescaQuery.ts

@@ -1,16 +1,16 @@
 import BigNumber from 'bignumber.js';
-import { VeScaTreasuryFields, VeScaTreasuryInfo, Vesca } from 'src/types/query';
+import { VeScaTreasuryFields, VeScaTreasuryInfo, Vesca } from 'src/types';
 import {
   type SuiObjectResponse,
   type SuiObjectData,
   DevInspectResults,
 } from '@mysten/sui/client';
 import type { ScallopUtils } from 'src/models';
-import { MAX_LOCK_DURATION } from 'src/constants/vesca';
+import { MAX_LOCK_DURATION } from 'src/constants';
 import { SUI_CLOCK_OBJECT_ID, SuiTxBlock } from '@scallop-io/sui-kit';
 import { bcs } from '@mysten/sui/bcs';
 import { z as zod } from 'zod';
-import { queryKeys } from 'src/constants/queryKeys';
+import { queryKeys } from 'src/constants';
 import assert from 'assert';
 /**
  * Query all owned veSca key.

package/src/queries/xOracleQuery.ts

@@ -1,6 +1,6 @@
 import { SuiObjectResponse } from '@mysten/sui/client';
 import { ScallopAddress, ScallopSuiKit, ScallopUtils } from 'src/models';
-import { SupportOracleType, xOracleRuleType } from 'src/types/constant';
+import { SupportOracleType, xOracleRuleType } from 'src/types';
 
 /**
  * Query the price update policy table ids. Usually the value for these table will be constant.
@@ -61,28 +61,11 @@ export const getAssetOracles = async (
     return null;
   }
 
-  const createRuleType = (objectId: string): string => {
-    return `${objectId}::rule::Rule`;
-  };
-
-  const pythLstRuleTypeNameToOracleType: Record<string, SupportOracleType> =
-    Object.values<{
-      object: string;
-    }>(utils.address.get('core.packages.pyth.lst') ?? {}).reduce(
-      (acc, curr) => {
-        acc[createRuleType(curr.object)] = 'pyth';
-        return acc;
-      },
-      {} as Record<string, SupportOracleType>
-    );
-
   const ruleTypeNameToOracleType: Record<string, SupportOracleType> = {
-    [createRuleType(utils.address.get('core.packages.pyth.object'))]: 'pyth',
-    // include the pyth lst type
-    [createRuleType(utils.address.get('core.packages.supra.object'))]: 'supra',
-    [createRuleType(utils.address.get('core.packages.switchboard.object'))]:
+    [`${utils.address.get('core.packages.pyth.object')}::rule::Rule`]: 'pyth',
+    [`${utils.address.get('core.packages.supra.object')}::rule::Rule`]: 'supra',
+    [`${utils.address.get('core.packages.switchboard.object')}::rule::Rule`]:
       'switchboard',
-    ...pythLstRuleTypeNameToOracleType,
   };
 
   const assetOracles = {} as Record<string, SupportOracleType[]>;

package/src/types/address.ts

@@ -1,67 +1,5 @@
-import { SUPPORT_ORACLE_LST, SUPPORT_ORACLES } from 'src/constants/xoracle';
-import { SupportOracleType, SupportedOracleSuiLst } from './constant/xOracle';
-import { PackageName } from './constant/package';
+import { _SUPPORT_ORACLES, SupportOracleType } from './constant/xOracle';
 
-export type BasePackage = {
-  id: string;
-  object?: string;
-  upgradeCap?: string;
-};
-
-export type OracleLstPackage = {
-  [K in SupportedOracleSuiLst]: BasePackage;
-};
-
-type OraclePackage<T> = BasePackage & T extends SupportOracleLst
-  ? BasePackage & {
-      lst: OracleLstPackage;
-    }
-  : BasePackage;
-
-type Packages<
-  T extends SupportOracleType | PackageName = SupportOracleType | PackageName,
-> = T extends SupportOracleType
-  ? Record<T, OraclePackage<T>>
-  : T extends PackageName
-    ? Record<T, BasePackage>
-    : never;
-
-export type SupportOracleLst = (typeof SUPPORT_ORACLE_LST)[number];
-
-type PythOracleLstConfigItem<T extends SupportedOracleSuiLst, U> = Record<
-  T,
-  { configId: string } & U
->;
-
-export type PythOracleLstConfig<
-  T extends SupportedOracleSuiLst = SupportedOracleSuiLst,
-> = T extends 'afsui'
-  ? PythOracleLstConfigItem<
-      'afsui',
-      {
-        stakedSuiVaultId: string;
-        safeId: string;
-        configId: string;
-      }
-    >
-  : T extends 'hasui'
-    ? PythOracleLstConfigItem<
-        'hasui',
-        {
-          staking: string;
-        }
-      >
-    : never;
-
-export type OracleLst<T extends SupportOracleLst> = T extends 'pyth'
-  ? PythOracleLstConfig
-  : never;
-
-type MaybeWithOracleLst<T, U> = T extends SupportOracleLst
-  ? U & {
-      lst: OracleLst<T>;
-    }
-  : U;
 export interface AddressesInterface {
   id?: string;
   core: {
@@ -83,11 +21,11 @@ export interface AddressesInterface {
           symbol: string;
           decimals: number;
           oracle: {
-            [K in SupportOracleType]: K extends (typeof SUPPORT_ORACLES)[0]
+            [K in SupportOracleType]: K extends (typeof _SUPPORT_ORACLES)[0]
               ? string
-              : K extends (typeof SUPPORT_ORACLES)[1]
+              : K extends (typeof _SUPPORT_ORACLES)[1]
                 ? string
-                : K extends (typeof SUPPORT_ORACLES)[2]
+                : K extends (typeof _SUPPORT_ORACLES)[2]
                   ? {
                       feed: string;
                       feedObject: string;
@@ -98,36 +36,27 @@ export interface AddressesInterface {
       >
     >;
     oracles: {
-      [K in SupportOracleType]: K extends (typeof SUPPORT_ORACLES)[0]
-        ? MaybeWithOracleLst<
-            K,
-            {
+      [K in SupportOracleType]: K extends (typeof _SUPPORT_ORACLES)[0]
+        ? {
+            registry: string;
+            registryCap: string;
+            holder: string;
+          }
+        : K extends (typeof _SUPPORT_ORACLES)[1]
+          ? {
               registry: string;
               registryCap: string;
-              holder: string;
+              registryTableId: string;
+              state: string;
             }
-          >
-        : K extends (typeof SUPPORT_ORACLES)[1]
-          ? MaybeWithOracleLst<
-              K,
-              {
+          : K extends (typeof _SUPPORT_ORACLES)[2]
+            ? {
                 registry: string;
                 registryCap: string;
-                registryTableId: string;
                 state: string;
+                wormhole: string;
+                wormholeState: string;
               }
-            >
-          : K extends (typeof SUPPORT_ORACLES)[2]
-            ? MaybeWithOracleLst<
-                K,
-                {
-                  registry: string;
-                  registryCap: string;
-                  state: string;
-                  wormhole: string;
-                  wormholeState: string;
-                }
-              >
             : never;
     } & {
       xOracle: string;
@@ -137,7 +66,16 @@ export interface AddressesInterface {
       primaryPriceUpdatePolicyVecsetId: string;
       secondaryPriceUpdatePolicyVecsetId: string;
     };
-    packages: Packages;
+    packages: Partial<
+      Record<
+        string,
+        {
+          id: string;
+          object?: string;
+          upgradeCap: string;
+        }
+      >
+    >;
   };
   spool: {
     id: string;
@@ -218,12 +156,23 @@ export interface AddressesInterface {
   };
 }
 
-type Paths<T> = T extends object
-  ? {
-      [K in Extract<keyof T, string>]: T[K] extends object // if T[K] is itself an object, emit K *and* K.<deep>
-        ? K | `${K}.${Paths<T[K]>}`
-        : K;
-    }[Extract<keyof T, string>]
-  : never;
+type AddressPathsProps<T> = T extends string
+  ? []
+  : {
+      [K in Extract<keyof T, string>]: [K, ...AddressPathsProps<T[K]>];
+    }[Extract<keyof T, string>];
 
-export type AddressStringPath = Paths<AddressesInterface>;
+type Join<T extends string[], D extends string> = T extends []
+  ? never
+  : T extends [infer F]
+    ? F
+    : T extends [infer F, ...infer R]
+      ? F extends string
+        ? `${F}${D}${Join<Extract<R, string[]>, D>}`
+        : never
+      : string;
+
+export type AddressStringPath = Join<
+  AddressPathsProps<AddressesInterface>,
+  '.'
+>;

package/src/types/builder/core.ts

@@ -16,16 +16,12 @@ export type CoreIds = {
 };
 
 export type NestedResult = Extract<Argument, { $kind: 'NestedResult' }>;
-type ResultAsObligation = NestedResult;
-type ResultAsObligationKey = NestedResult;
-type ResultAsObligationHotPotato = NestedResult;
+type Obligation = NestedResult;
+type ObligationKey = NestedResult;
+type ObligationHotPotato = NestedResult;
 
 export type CoreNormalMethods = {
-  openObligation: () => [
-    ResultAsObligation,
-    ResultAsObligationKey,
-    ResultAsObligationHotPotato,
-  ];
+  openObligation: () => [Obligation, ObligationKey, ObligationHotPotato];
   returnObligation: (
     obligation: SuiObjectArg,
     obligationHotPotato: SuiObjectArg
@@ -91,31 +87,51 @@ export type CoreQuickMethods = {
   addCollateralQuick: (
     amount: number,
     collateralCoinName: string,
-    obligationId?: SuiObjectArg
+    obligationId?: SuiObjectArg,
+    isSponsoredTx?: boolean
   ) => Promise<void>;
   takeCollateralQuick: (
     amount: number,
     collateralCoinName: string,
     obligationId?: SuiObjectArg,
-    obligationKey?: SuiObjectArg
+    obligationKey?: SuiObjectArg,
+    updateOracleOptions?: {
+      usePythPullModel?: boolean;
+      useOnChainXOracleList?: boolean;
+      sponsoredFeeds?: string[];
+      isSponsoredTx?: boolean;
+    }
   ) => Promise<TransactionResult>;
   borrowQuick: (
     amount: number,
     poolCoinName: string,
     obligationId?: SuiObjectArg,
-    obligationKey?: SuiObjectArg
+    obligationKey?: SuiObjectArg,
+    updateOracleOptions?: {
+      usePythPullModel?: boolean;
+      useOnChainXOracleList?: boolean;
+      sponsoredFeeds?: string[];
+      isSponsoredTx?: boolean;
+    }
   ) => Promise<TransactionResult>;
   borrowWithReferralQuick: (
     amount: number,
     poolCoinName: string,
     borrowReferral: SuiObjectArg,
     obligationId?: SuiObjectArg,
-    obligationKey?: SuiObjectArg
+    obligationKey?: SuiObjectArg,
+    updateOracleOptions?: {
+      usePythPullModel?: boolean;
+      useOnChainXOracleList?: boolean;
+      sponsoredFeeds?: string[];
+      isSponsoredTx?: boolean;
+    }
   ) => Promise<TransactionResult>;
   depositQuick: (
     amount: number,
     poolCoinName: string,
-    returnSCoin?: boolean
+    returnSCoin?: boolean,
+    isSponsoredTx?: boolean
   ) => Promise<TransactionResult>;
   withdrawQuick: (
     amount: number,
@@ -124,9 +140,18 @@ export type CoreQuickMethods = {
   repayQuick: (
     amount: number,
     poolCoinName: string,
-    obligationId?: SuiObjectArg
+    obligationId?: SuiObjectArg,
+    isSponsoredTx?: boolean
+  ) => Promise<void>;
+  updateAssetPricesQuick: (
+    assetCoinNames?: string[],
+    updateOracleOptions?: {
+      usePythPullModel?: boolean;
+      useOnChainXOracleList?: boolean;
+      sponsoredFeeds?: string[];
+      isSponsoredTx?: boolean;
+    }
   ) => Promise<void>;
-  updateAssetPricesQuick: (assetCoinNames?: string[]) => Promise<void>;
 };
 
 export type SuiTxBlockWithCoreNormalMethods = SuiKitTxBlock &