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

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,54 +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];
-
-export type OracleLstConfig<T extends SupportedOracleSuiLst> = T extends 'afsui'
-  ? Record<
-      T,
-      {
-        stakedSuiVaultId: string;
-        safeId: string;
-        configId: string;
-      }
-    >
-  : never;
-
-export type OracleLst<
-  T extends SupportOracleLst,
-  U extends SupportedOracleSuiLst = SupportedOracleSuiLst,
-> = T extends 'pyth' ? OracleLstConfig<U> : undefined;
-
-type MaybeWithOracleLst<T, U> = T extends SupportOracleLst
-  ? U & {
-      lst: OracleLst<T>;
-    }
-  : U;
 export interface AddressesInterface {
   id?: string;
   core: {
@@ -70,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;
@@ -85,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;
@@ -124,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;
@@ -205,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>];
+
+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 = Paths<AddressesInterface>;
+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 &

package/src/types/builder/index.ts

@@ -1,7 +1,23 @@
+import type { CoreTxBlock } from './core';
+import type { SpoolTxBlock } from './spool';
+import type { BorrowIncentiveTxBlock } from './borrowIncentive';
+import type { VeScaTxBlock } from './vesca';
+import type { ReferralTxBlock } from './referral';
+import { LoyaltyProgramTxBlock } from './loyaltyProgram';
+import { SCoinTxBlock } from './sCoin';
+
 export type * from './core';
 export type * from './spool';
 export type * from './borrowIncentive';
 export type * from './vesca';
 export type * from './loyaltyProgram';
 export type * from './sCoin';
-export type * from './type';
+
+export type BaseScallopTxBlock = ReferralTxBlock &
+  LoyaltyProgramTxBlock &
+  BorrowIncentiveTxBlock &
+  VeScaTxBlock;
+
+export type SuiTxBlockWithSCoin = BaseScallopTxBlock & SCoinTxBlock;
+export type SuiTxBlockWithSpool = SuiTxBlockWithSCoin & SpoolTxBlock;
+export type ScallopTxBlock = SuiTxBlockWithSpool & CoreTxBlock;

package/src/types/constant/enum.ts

@@ -0,0 +1,64 @@
+export type Coins = {
+  [K in string]: K;
+};
+
+export type AssetCoins = {
+  [K in string]: K;
+};
+
+export type MarketCoins = {
+  [K in string]: K;
+};
+
+export type SCoins = {
+  [K in string]: K;
+};
+
+export type StakeMarketCoins = {
+  [K in string]: K;
+};
+
+export type StakeRewardCoins = {
+  [key in string]: string;
+};
+
+export type SuiBridgeCoins = {
+  [K in string]: K;
+};
+
+export type BorrowIncentiveRewardCoins = {
+  [key in string]: string[];
+};
+
+export type AssetCoinIds = {
+  [key in string]: string;
+};
+
+export type SCoinIds = {
+  [key in string]: string;
+};
+
+export type SCoinTreasuryCaps = {
+  [key in string]: string;
+};
+
+export type SCoinConverterTreasury = {
+  [key in string]: string;
+};
+
+type PickFromUnion<T, K extends string> = K extends T ? K : never;
+
+export type WormholeCoinIds = {
+  [key in PickFromUnion<
+    string,
+    'weth' | 'wbtc' | 'wusdc' | 'wusdt' | 'wapt' | 'wsol'
+  >]: string;
+};
+
+export type VoloCoinIds = {
+  [key in PickFromUnion<string, 'vsui'>]: string;
+};
+
+export type SuiBridgedCoinPackageIds = {
+  [key in string]: string;
+};

package/src/types/constant/index.ts

@@ -1,4 +1,3 @@
 export type * from './common';
-export type * from './queryKeys';
+export type * from './enum';
 export type * from './xOracle';
-export type * from './package';

package/src/types/constant/xOracle.ts

@@ -1,15 +1,12 @@
-import {
-  SUPPORT_ORACLES,
-  X_ORACLE_RULES,
-  SUPPORT_SUI_LST,
-} from 'src/constants/xoracle';
+export const _SUPPORT_ORACLES = ['supra', 'switchboard', 'pyth'] as const;
+export type SupportOracleType = (typeof _SUPPORT_ORACLES)[number];
 
-export type SupportOracleType = (typeof SUPPORT_ORACLES)[number];
-export type xOracleRuleType = (typeof X_ORACLE_RULES)[number];
-
-export type xOracleRules = Record<xOracleRuleType, SupportOracleType[]>;
+export type xOracleRules = {
+  primary: SupportOracleType[];
+  secondary: SupportOracleType[];
+};
+export type xOracleRuleType = keyof xOracleRules;
 
 export type xOracleListType = {
   [key in string]: xOracleRules;
 };
-export type SupportedOracleSuiLst = (typeof SUPPORT_SUI_LST)[number];

package/src/types/index.ts

@@ -2,4 +2,4 @@ export type * from './builder';
 export type * from './constant';
 export type * from './query';
 export type * from './address';
-export type * from './util';
+export type * from './utils';

package/src/types/query/core.ts

@@ -293,6 +293,9 @@ export interface MarketQueryInterface {
     liquidationFactor: {
       value: string;
     };
+    // liquidationPenalty: {
+    //   value: string;
+    // };
     liquidationPanelty: {
       value: string;
     };

package/src/types/query/index.ts

@@ -2,5 +2,6 @@ export type * from './borrowIncentive';
 export type * from './core';
 export type * from './loyaltyProgram';
 export type * from './portfolio';
+export type * from './sCoin';
 export type * from './spool';
 export type * from './vesca';

package/src/types/query/sCoin.ts

@@ -0,0 +1 @@
+export type sCoinBalance = number;

package/src/{builders/utils.ts → utils/builder.ts}

@@ -5,7 +5,7 @@ import {
   MAX_LOCK_ROUNDS,
   MIN_INITIAL_LOCK_AMOUNT,
   MIN_TOP_UP_AMOUNT,
-} from 'src/constants/vesca';
+} from 'src/constants';
 import type { SuiObjectArg } from '@scallop-io/sui-kit';
 
 /**

package/src/utils/core.ts

@@ -0,0 +1,18 @@
+import { SuiObjectData } from '@mysten/sui/client';
+
+export const parseObjectAs = <T>(object: SuiObjectData): T => {
+  if (!(object && object.content && 'fields' in object.content))
+    throw new Error(`Failed to parse object ${object}`);
+
+  const fields = object.content.fields as any;
+
+  if (typeof fields === 'object' && 'value' in fields) {
+    const value = fields.value;
+    if (typeof value === 'object' && 'fields' in value)
+      return value.fields as T;
+    return value as T;
+  } else if (typeof fields === 'object') {
+    return fields as T;
+  }
+  return fields as T;
+};