@scallop-io/sui-scallop-sdk 2.0.11 → 2.0.13-merge-split-ve-sca-alpha.1

package/src/queries/coreQuery.ts

@@ -5,14 +5,14 @@ import {
   parseOriginMarketCollateralData,
   calculateMarketCollateralData,
   parseObjectAs,
-} from '../utils';
+} from 'src/utils';
 import type {
   SuiObjectResponse,
   SuiObjectData,
   SuiParsedData,
 } from '@mysten/sui/client';
 import type { SuiObjectArg } from '@scallop-io/sui-kit';
-import type { ScallopAddress, ScallopCache, ScallopQuery } from '../models';
+import type { ScallopAddress, ScallopCache, ScallopQuery } from 'src/models';
 import {
   Market,
   MarketPools,
@@ -32,7 +32,7 @@ import {
   BorrowFee,
   BorrowDynamic,
   OriginMarketCollateralData,
-} from '../types';
+} from 'src/types';
 import BigNumber from 'bignumber.js';
 import { getSupplyLimit } from './supplyLimitQuery';
 import { isIsolatedAsset } from './isolatedAssetQuery';
@@ -219,158 +219,118 @@ const queryRequiredMarketObjects = async (
   query: ScallopQuery,
   poolCoinNames: string[]
 ) => {
-  // Prepare all tasks for querying each object type
-  const tasks = poolCoinNames.map((t) => ({
-    poolCoinName: t,
-    balanceSheet: query.constants.poolAddresses[t]?.lendingPoolAddress,
-    collateralStat: query.constants.poolAddresses[t]?.collateralPoolAddress,
-    borrowDynamic: query.constants.poolAddresses[t]?.borrowDynamic,
-    interestModel: query.constants.poolAddresses[t]?.interestModel,
-    riskModel: query.constants.poolAddresses[t]?.riskModel,
-    borrowFeeKey: query.constants.poolAddresses[t]?.borrowFeeKey,
-    supplyLimitKey: query.constants.poolAddresses[t]?.supplyLimitKey,
-    borrowLimitKey: query.constants.poolAddresses[t]?.borrowLimitKey,
-  }));
-
-  // Query all objects for each key in parallel
-  const [
-    balanceSheetObjects,
-    collateralStatObjects,
-    borrowDynamicObjects,
-    interestModelObjects,
-    riskModelObjects,
-    borrowFeeObjects,
-    supplyLimitObjects,
-    borrowLimitObjects,
-  ] = await Promise.all([
-    queryMultipleObjects(
-      query.cache,
-      tasks.map((task) => task.balanceSheet).filter((t): t is string => !!t)
-    ),
-    queryMultipleObjects(
-      query.cache,
-      tasks.map((task) => task.collateralStat).filter((t): t is string => !!t)
-    ),
-    queryMultipleObjects(
-      query.cache,
-      tasks.map((task) => task.borrowDynamic).filter((t): t is string => !!t)
-    ),
-    queryMultipleObjects(
-      query.cache,
-      tasks.map((task) => task.interestModel).filter((t): t is string => !!t)
-    ),
-    queryMultipleObjects(
-      query.cache,
-      tasks.map((task) => task.riskModel).filter((t): t is string => !!t)
-    ),
-    queryMultipleObjects(
-      query.cache,
-      tasks.map((task) => task.borrowFeeKey).filter((t): t is string => !!t)
-    ),
-    queryMultipleObjects(
-      query.cache,
-      tasks.map((task) => task.supplyLimitKey).filter((t): t is string => !!t)
-    ),
-    queryMultipleObjects(
-      query.cache,
-      tasks.map((task) => task.borrowLimitKey).filter((t): t is string => !!t)
-    ),
-  ]);
-
-  // Map the results back to poolCoinNames
-  const mapObjects = (
-    tasks: {
-      poolCoinName: string;
-      [key: string]: string | undefined;
-    }[],
-    fetchedObjects: SuiObjectData[],
-    keyValue: string
-  ) => {
-    const resultMap: Record<string, SuiObjectData> = {};
-    const fetchedObjectMap = fetchedObjects.reduce(
-      (acc, obj) => {
-        acc[obj.objectId] = obj;
-        return acc;
-      },
-      {} as Record<string, SuiObjectData>
-    );
+  // Phase 1: Single-pass data preparation with proper typing
+  type KeyType = {
+    balanceSheet?: string;
+    collateralStat?: string;
+    borrowDynamic?: string;
+    interestModel?: string;
+    riskModel?: string;
+    borrowFeeKey?: string;
+    supplyLimitKey?: string;
+    borrowLimitKey?: string;
+  };
 
-    for (const task of tasks) {
-      if (task[keyValue]) {
-        resultMap[task.poolCoinName] = fetchedObjectMap[task[keyValue]];
-      }
-    }
-    return resultMap;
+  const keyCollections: Record<keyof KeyType, string[]> = {
+    balanceSheet: [],
+    collateralStat: [],
+    borrowDynamic: [],
+    interestModel: [],
+    riskModel: [],
+    borrowFeeKey: [],
+    supplyLimitKey: [],
+    borrowLimitKey: [],
   };
 
-  const balanceSheetMap = mapObjects(
-    tasks,
-    balanceSheetObjects,
-    'balanceSheet'
-  );
-  const collateralStatMap = mapObjects(
-    tasks,
-    collateralStatObjects,
-    'collateralStat'
-  );
-  const borrowDynamicMap = mapObjects(
-    tasks,
-    borrowDynamicObjects,
-    'borrowDynamic'
-  );
-  const interestModelMap = mapObjects(
-    tasks,
-    interestModelObjects,
-    'interestModel'
-  );
-  const riskModelMap = mapObjects(tasks, riskModelObjects, 'riskModel');
-  const borrowFeeMap = mapObjects(tasks, borrowFeeObjects, 'borrowFeeKey');
-  const supplyLimitMap = mapObjects(
-    tasks,
-    supplyLimitObjects,
-    'supplyLimitKey'
-  );
-  const borrowLimitMap = mapObjects(
-    tasks,
-    borrowLimitObjects,
-    'borrowLimitKey'
-  );
-  // const isolatedAssetMap = mapObjects(
-  //   tasks,
-  //   isolatedAssetObjects,
-  //   'isolatedAssetKey'
-  // );
-  // Construct the final requiredObjects result
-  const result = poolCoinNames.reduce(
-    (acc, name) => {
-      acc[name] = {
-        balanceSheet: balanceSheetMap[name],
-        collateralStat: collateralStatMap[name],
-        borrowDynamic: borrowDynamicMap[name],
-        interestModel: interestModelMap[name],
-        riskModel: riskModelMap[name],
-        borrowFeeKey: borrowFeeMap[name],
-        supplyLimitKey: supplyLimitMap[name],
-        borrowLimitKey: borrowLimitMap[name],
-        isIsolated: query.constants.poolAddresses[name]?.isIsolated ?? false,
-      };
-      return acc;
-    },
-    {} as Record<
-      string,
-      {
-        balanceSheet: SuiObjectData;
-        collateralStat?: SuiObjectData;
-        riskModel?: SuiObjectData;
-        borrowDynamic: SuiObjectData;
-        interestModel: SuiObjectData;
-        borrowFeeKey: SuiObjectData;
-        supplyLimitKey: SuiObjectData;
-        borrowLimitKey: SuiObjectData;
-        isIsolated: boolean;
+  const taskMap = new Map<string, KeyType>();
+
+  // Single iteration to collect all keys and map tasks
+  for (const poolCoinName of poolCoinNames) {
+    const poolData = query.constants.poolAddresses[poolCoinName];
+    const task: KeyType = {
+      balanceSheet: poolData?.lendingPoolAddress,
+      collateralStat: poolData?.collateralPoolAddress,
+      borrowDynamic: poolData?.borrowDynamic,
+      interestModel: poolData?.interestModel,
+      riskModel: poolData?.riskModel,
+      borrowFeeKey: poolData?.borrowFeeKey,
+      supplyLimitKey: poolData?.supplyLimitKey,
+      borrowLimitKey: poolData?.borrowLimitKey,
+    };
+
+    // Add to key collections
+    (Object.entries(task) as [keyof KeyType, string | undefined][]).forEach(
+      ([key, value]) => {
+        if (value) keyCollections[key].push(value);
       }
-    >
-  );
+    );
+
+    taskMap.set(poolCoinName, task);
+  }
+
+  // Phase 2: Parallel queries with pre-collected keys
+  const queryResults = await Promise.all([
+    queryMultipleObjects(query.cache, keyCollections.balanceSheet),
+    queryMultipleObjects(query.cache, keyCollections.collateralStat),
+    queryMultipleObjects(query.cache, keyCollections.borrowDynamic),
+    queryMultipleObjects(query.cache, keyCollections.interestModel),
+    queryMultipleObjects(query.cache, keyCollections.riskModel),
+    queryMultipleObjects(query.cache, keyCollections.borrowFeeKey),
+    queryMultipleObjects(query.cache, keyCollections.supplyLimitKey),
+    queryMultipleObjects(query.cache, keyCollections.borrowLimitKey),
+  ]);
+
+  // Phase 3: Single-pass result mapping
+  const resultMaps = {
+    balanceSheet: new Map<string, SuiObjectData>(),
+    collateralStat: new Map<string, SuiObjectData>(),
+    borrowDynamic: new Map<string, SuiObjectData>(),
+    interestModel: new Map<string, SuiObjectData>(),
+    riskModel: new Map<string, SuiObjectData>(),
+    borrowFeeKey: new Map<string, SuiObjectData>(),
+    supplyLimitKey: new Map<string, SuiObjectData>(),
+    borrowLimitKey: new Map<string, SuiObjectData>(),
+    isIsolated: new Map<string, boolean>(),
+  } as Record<keyof KeyType, Map<string, SuiObjectData>>;
+
+  queryResults.forEach((objects, index) => {
+    const keyType = Object.keys(resultMaps)[index] as keyof KeyType;
+    objects.forEach((obj) => {
+      resultMaps[keyType].set(obj.objectId, obj);
+    });
+  });
+
+  // Phase 4: Efficient result construction
+  const result: Record<string, any> = {};
+  for (const [poolCoinName, task] of taskMap) {
+    result[poolCoinName] = {
+      balanceSheet: task.balanceSheet
+        ? resultMaps.balanceSheet.get(task.balanceSheet)
+        : undefined,
+      collateralStat: task.collateralStat
+        ? resultMaps.collateralStat.get(task.collateralStat)
+        : undefined,
+      borrowDynamic: task.borrowDynamic
+        ? resultMaps.borrowDynamic.get(task.borrowDynamic)
+        : undefined,
+      interestModel: task.interestModel
+        ? resultMaps.interestModel.get(task.interestModel)
+        : undefined,
+      riskModel: task.riskModel
+        ? resultMaps.riskModel.get(task.riskModel)
+        : undefined,
+      borrowFeeKey: task.borrowFeeKey
+        ? resultMaps.borrowFeeKey.get(task.borrowFeeKey)
+        : undefined,
+      supplyLimitKey: task.supplyLimitKey
+        ? resultMaps.supplyLimitKey.get(task.supplyLimitKey)
+        : undefined,
+      borrowLimitKey: task.borrowLimitKey
+        ? resultMaps.borrowLimitKey.get(task.borrowLimitKey)
+        : undefined,
+      isolatedAssetKey: query.constants.poolAddresses[poolCoinName]?.isIsolated,
+    };
+  }
 
   return result;
 };
@@ -473,10 +433,10 @@ const parseMarketPoolObjects = ({
   borrowLimitKey,
   isIsolated,
 }: {
-  balanceSheet: SuiObjectData;
-  borrowDynamic: SuiObjectData;
+  balanceSheet?: SuiObjectData;
+  borrowDynamic?: SuiObjectData;
   collateralStat?: SuiObjectData;
-  interestModel: SuiObjectData;
+  interestModel?: SuiObjectData;
   riskModel?: SuiObjectData;
   borrowFeeKey?: SuiObjectData;
   supplyLimitKey?: SuiObjectData;
@@ -485,6 +445,9 @@ const parseMarketPoolObjects = ({
 }): OriginMarketPoolData & {
   parsedOriginMarketCollateral?: OriginMarketCollateralData;
 } => {
+  if (!balanceSheet || !borrowDynamic || !interestModel) {
+    throw new Error('Missing required market objects');
+  }
   const _balanceSheet = parseObjectAs<BalanceSheet>(balanceSheet);
   const _interestModel = parseObjectAs<InterestModel>(interestModel);
   const _borrowDynamic = parseObjectAs<BorrowDynamic>(borrowDynamic);
@@ -608,6 +571,10 @@ export const getMarketPool = async (
     poolCoinName
   ];
 
+  if (!requiredObjects)
+    throw new Error(
+      `Failed to fetch required market objects for ${poolCoinName}`
+    );
   const parsedMarketPoolObjects = parseMarketPoolObjects(requiredObjects);
   const parsedMarketPoolData = parseOriginMarketPoolData(
     parsedMarketPoolObjects

package/src/queries/portfolioQuery.ts

@@ -1,6 +1,6 @@
 import BigNumber from 'bignumber.js';
 import { minBigNumber, estimatedFactor } from 'src/utils';
-import type { ScallopQuery } from '../models';
+import type { ScallopQuery } from 'src/models';
 import type {
   Market,
   MarketPool,
@@ -16,7 +16,7 @@ import type {
   ObligationBorrowIncentiveReward,
   MarketPools,
   MarketCollaterals,
-} from '../types';
+} from 'src/types';
 import { SuiObjectRef } from '@mysten/sui/client';
 import { queryMultipleObjects } from './objectsQuery';
 import { normalizeStructTag, SUI_TYPE_ARG } from '@scallop-io/sui-kit';

package/src/queries/spoolQuery.ts

@@ -5,9 +5,9 @@ import {
   parseOriginSpoolRewardPoolData,
   calculateSpoolRewardPoolData,
   parseObjectAs,
-} from '../utils';
+} from 'src/utils';
 import type { SuiObjectData, SuiObjectResponse } from '@mysten/sui/client';
-import type { ScallopQuery, ScallopUtils } from '../models';
+import type { ScallopQuery, ScallopUtils } from 'src/models';
 import type {
   Spools,
   Spool,
@@ -19,97 +19,99 @@ import type {
   OriginSpoolRewardPoolData,
   SpoolData,
   OriginSpoolData,
-} from '../types';
+} from 'src/types';
 import { queryMultipleObjects } from './objectsQuery';
 
 const queryRequiredSpoolObjects = async (
   query: ScallopQuery,
   stakePoolCoinNames: string[]
 ) => {
-  // Prepare all tasks for querying each object type
-  const tasks = stakePoolCoinNames.map((t, idx) => ({
-    poolCoinName: stakePoolCoinNames[idx],
-    spool: query.constants.poolAddresses[t]?.spool,
-    spoolReward: query.constants.poolAddresses[t]?.spoolReward,
-    sCoinTreasury: query.constants.poolAddresses[t]?.sCoinTreasury,
-  }));
-
-  // Query all objects for each key in parallel
+  // Phase 1: Single-pass data preparation
+  type KeyType = {
+    spool?: string;
+    spoolReward?: string;
+    sCoinTreasury?: string;
+  };
+
+  const keyCollections: Record<keyof KeyType, string[]> = {
+    spool: [],
+    spoolReward: [],
+    sCoinTreasury: [],
+  };
+
+  const taskMap = new Map<string, KeyType>();
+
+  // 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);
+      }
+    );
+
+    taskMap.set(poolCoinName, task);
+  }
+
+  // Phase 2: Parallel queries with pre-collected keys
   const [spoolObjects, spoolRewardObjects, sCoinTreasuryObjects] =
     await Promise.all([
-      queryMultipleObjects(
-        query.cache,
-        tasks.map((task) => task.spool).filter((t): t is string => !!t)
-      ),
-      queryMultipleObjects(
-        query.cache,
-        tasks.map((task) => task.spoolReward).filter((t): t is string => !!t)
-      ),
-      queryMultipleObjects(
-        query.cache,
-        tasks.map((task) => task.sCoinTreasury).filter((t): t is string => !!t)
-      ),
+      queryMultipleObjects(query.cache, keyCollections.spool),
+      queryMultipleObjects(query.cache, keyCollections.spoolReward),
+      queryMultipleObjects(query.cache, keyCollections.sCoinTreasury),
     ]);
 
-  // Map the results back to poolCoinNames
-  const mapObjects = (
-    tasks: { poolCoinName: string; [key: string]: string | undefined }[],
-    fetchedObjects: SuiObjectData[],
-    keyValue: string
-  ) => {
-    const resultMap: Record<string, SuiObjectData> = {};
-    const fetchedObjectMap = fetchedObjects.reduce(
-      (acc, obj) => {
-        acc[obj.objectId] = obj;
-        return acc;
-      },
-      {} as Record<string, SuiObjectData>
-    );
+  // Phase 3: Create lookup maps
+  const createObjectMap = (objects: SuiObjectData[]) =>
+    new Map(objects.map((obj) => [obj.objectId, obj]));
 
-    for (const task of tasks) {
-      if (task[keyValue]) {
-        resultMap[task.poolCoinName] = fetchedObjectMap[task[keyValue]];
-      }
-    }
-    return resultMap;
+  const objectMaps = {
+    spool: createObjectMap(spoolObjects),
+    spoolReward: createObjectMap(spoolRewardObjects),
+    sCoinTreasury: createObjectMap(sCoinTreasuryObjects),
   };
 
-  const spoolMap = mapObjects(tasks, spoolObjects, 'spool');
-  const spoolRewardMap = mapObjects(tasks, spoolRewardObjects, 'spoolReward');
-  const sCoinTreasuryMap = mapObjects(
-    tasks,
-    sCoinTreasuryObjects,
-    'sCoinTreasury'
-  );
+  // 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,
+    };
+  }
 
-  // Construct the final requiredObjects result
-  return stakePoolCoinNames.reduce(
-    (acc, name) => {
-      acc[name] = {
-        spool: spoolMap[name],
-        spoolReward: spoolRewardMap[name],
-        sCoinTreasury: sCoinTreasuryMap[name],
-      };
-      return acc;
-    },
-    {} as Record<
-      string,
-      {
-        spool: SuiObjectData;
-        spoolReward: SuiObjectData;
-        sCoinTreasury: SuiObjectData;
-      }
-    >
-  );
+  return result as Record<
+    string,
+    {
+      spool?: SuiObjectData;
+      spoolReward?: SuiObjectData;
+      sCoinTreasury?: SuiObjectData;
+    }
+  >;
 };
 
 const parseSpoolObjects = ({
   spool,
   spoolReward,
 }: {
-  spool: SuiObjectData;
-  spoolReward: SuiObjectData;
+  spool?: SuiObjectData;
+  spoolReward?: SuiObjectData;
 }): OriginSpoolData & OriginSpoolRewardPoolData => {
+  if (!spool || !spoolReward) {
+    throw new Error('spool or spoolReward is undefined');
+  }
   const _spool = parseObjectAs<SpoolData>(spool);
   const _spoolReward = parseObjectAs<OriginSpoolRewardPoolData>(spoolReward);
   return {
@@ -222,8 +224,8 @@ export const getSpool = async (
   indexer: boolean = false,
   coinPrices?: CoinPrices,
   requiredObjects?: {
-    spool: SuiObjectData;
-    spoolReward: SuiObjectData;
+    spool?: SuiObjectData;
+    spoolReward?: SuiObjectData;
   }
 ) => {
   const coinName = query.utils.parseCoinName<string>(marketCoinName);

package/src/queries/vescaQuery.ts

@@ -1,11 +1,11 @@
 import BigNumber from 'bignumber.js';
-import { VeScaTreasuryFields, VeScaTreasuryInfo, Vesca } from '../types';
+import { VeScaTreasuryFields, VeScaTreasuryInfo, Vesca } from 'src/types';
 import {
   type SuiObjectResponse,
   type SuiObjectData,
   DevInspectResults,
 } from '@mysten/sui/client';
-import type { ScallopUtils } from '../models';
+import type { ScallopUtils } from 'src/models';
 import { MAX_LOCK_DURATION } from 'src/constants';
 import { SUI_CLOCK_OBJECT_ID, SuiTxBlock } from '@scallop-io/sui-kit';
 import { bcs } from '@mysten/sui/bcs';

package/src/types/address.ts

@@ -108,6 +108,9 @@ export interface AddressesInterface {
     table: string;
     treasury: string;
     config: string;
+    subsTable: string;
+    subsTableId: string;
+    subsWhitelist: string;
   };
   referral: {
     id: string;

package/src/types/builder/vesca.ts

@@ -2,13 +2,6 @@ import { SuiTxBlock as SuiKitTxBlock, SuiObjectArg } from '@scallop-io/sui-kit';
 import type { TransactionResult } from '@mysten/sui/transactions';
 import { ScallopBuilder } from 'src/models';
 
-export type VescaIds = {
-  pkgId: string;
-  table: string;
-  treasury: string;
-  config: string;
-};
-
 export type VeScaNormalMethods = {
   lockSca: (
     scaCoin: SuiObjectArg,
@@ -26,9 +19,17 @@ export type VeScaNormalMethods = {
   ) => void;
   redeemSca: (veScaKey: SuiObjectArg) => TransactionResult;
   mintEmptyVeSca: () => TransactionResult;
+  splitVeSca: (
+    veScaKey: SuiObjectArg,
+    splitAmount: string
+  ) => TransactionResult;
+  mergeVeSca: (
+    targetVeScaKey: SuiObjectArg,
+    sourceVeScaKey: SuiObjectArg
+  ) => void;
 };
 
-export type RedeemScaQuickReturnType<T extends boolean> = T extends true
+export type QuickMethodReturnType<T extends boolean> = T extends true
   ? void
   : TransactionResult | undefined;
 
@@ -71,9 +72,18 @@ export type VeScaQuickMethods = {
     autoCheck?: boolean
   ) => Promise<void>;
   redeemScaQuick: <T extends boolean>(
-    veSCaKey?: SuiObjectArg,
+    veScaKey?: SuiObjectArg,
     transferSca?: T
-  ) => Promise<RedeemScaQuickReturnType<T>>;
+  ) => Promise<QuickMethodReturnType<T>>;
+  splitVeScaQuick: <T extends boolean>(
+    splitAmount: string,
+    veScaKey: string,
+    transferVeScaKey?: T
+  ) => Promise<QuickMethodReturnType<T>>;
+  mergeVeScaQuick: (
+    targetVeScaKey: string,
+    sourceVeScaKey: string
+  ) => Promise<void>;
 };
 
 export type SuiTxBlockWithVeScaNormalMethods = SuiKitTxBlock &

package/src/types/model.ts

@@ -7,7 +7,7 @@ import type {
   ScallopUtils,
   ScallopBuilder,
   ScallopIndexer,
-} from '../models';
+} from 'src/models';
 import { ScallopCache } from 'src/models/scallopCache';
 import { AddressesInterface } from './address';
 import { QueryClient, QueryClientConfig } from '@tanstack/query-core';
@@ -74,6 +74,7 @@ export type ScallopCacheParams = {
   walletAddress?: string;
   cacheOptions?: QueryClientConfig;
   config?: ScallopCacheConfig;
+  tokensPerSecond?: number; // for rate limit
 } & Partial<SuiKitParams>;
 
 export type ScallopIndexerParams = ScallopCacheParams & {

package/src/utils/builder.ts

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