@scallop-io/sui-scallop-sdk 1.5.3 → 2.0.0-alpha.1

package/src/types/builder/core.ts

@@ -5,11 +5,6 @@ import type {
 } from '@scallop-io/sui-kit';
 import type { Argument, TransactionResult } from '@mysten/sui/transactions';
 import type { ScallopBuilder } from '../../models';
-import type {
-  SupportCollateralCoins,
-  SupportPoolCoins,
-  SupportAssetCoins,
-} from '../constant';
 import { SuiTxBlockWithSpool } from '.';
 
 export type CoreIds = {
@@ -38,41 +33,41 @@ export type CoreNormalMethods = {
   addCollateral: (
     obligation: SuiObjectArg,
     coin: SuiObjectArg,
-    collateralCoinName: SupportCollateralCoins
+    collateralCoinName: string
     // ) => Promise<void>;
   ) => void;
   takeCollateral: (
     obligation: SuiObjectArg,
     obligationKey: SuiObjectArg,
     amount: number,
-    collateralCoinName: SupportCollateralCoins
+    collateralCoinName: string
     // ) => Promise<TransactionResult>;
   ) => TransactionResult;
   deposit: (
     coin: SuiObjectArg,
-    poolCoinName: SupportPoolCoins
+    poolCoinName: string
     // ) => Promise<TransactionResult>;
   ) => TransactionResult;
   depositEntry: (
     coin: SuiObjectArg,
-    poolCoinName: SupportPoolCoins
+    poolCoinName: string
     // ) => Promise<TransactionResult>;
   ) => TransactionResult;
   withdraw: (
     marketCoin: SuiObjectArg,
-    poolCoinName: SupportPoolCoins
+    poolCoinName: string
     // ) => Promise<TransactionResult>;
   ) => TransactionResult;
   withdrawEntry: (
     marketCoin: SuiObjectArg,
-    poolCoinName: SupportPoolCoins
+    poolCoinName: string
     // ) => Promise<TransactionResult>;
   ) => TransactionResult;
   borrow: (
     obligation: SuiObjectArg,
     obligationKey: SuiObjectArg,
     amount: number,
-    poolCoinName: SupportPoolCoins
+    poolCoinName: string
     // ) => Promise<TransactionResult>;
   ) => TransactionResult;
   borrowWithReferral: (
@@ -80,31 +75,31 @@ export type CoreNormalMethods = {
     obligationKey: SuiObjectArg,
     borrowReferral: SuiObjectArg,
     amount: number | SuiTxArg,
-    poolCoinName: SupportPoolCoins
+    poolCoinName: string
     // ) => Promise<TransactionResult>;
   ) => TransactionResult;
   borrowEntry: (
     obligation: SuiObjectArg,
     obligationKey: SuiObjectArg,
     amount: number,
-    poolCoinName: SupportPoolCoins
+    poolCoinName: string
     // ) => Promise<TransactionResult>;
   ) => TransactionResult;
   repay: (
     obligation: SuiObjectArg,
     coin: SuiObjectArg,
-    poolCoinName: SupportPoolCoins
+    poolCoinName: string
     // ) => Promise<void>;
   ) => void;
   borrowFlashLoan: (
     amount: number | SuiTxArg,
-    poolCoinName: SupportPoolCoins
+    poolCoinName: string
     // ) => Promise<TransactionResult>;
   ) => TransactionResult;
   repayFlashLoan: (
     coin: SuiObjectArg,
     loan: SuiObjectArg,
-    poolCoinName: SupportPoolCoins
+    poolCoinName: string
     // ) => Promise<void>;
   ) => void;
 };
@@ -112,45 +107,43 @@ export type CoreNormalMethods = {
 export type CoreQuickMethods = {
   addCollateralQuick: (
     amount: number,
-    collateralCoinName: SupportCollateralCoins,
+    collateralCoinName: string,
     obligationId?: SuiObjectArg
   ) => Promise<void>;
   takeCollateralQuick: (
     amount: number,
-    collateralCoinName: SupportCollateralCoins,
+    collateralCoinName: string,
     obligationId?: SuiObjectArg,
     obligationKey?: SuiObjectArg
   ) => Promise<TransactionResult>;
   borrowQuick: (
     amount: number,
-    poolCoinName: SupportPoolCoins,
+    poolCoinName: string,
     obligationId?: SuiObjectArg,
     obligationKey?: SuiObjectArg
   ) => Promise<TransactionResult>;
   borrowWithReferralQuick: (
     amount: number,
-    poolCoinName: SupportPoolCoins,
+    poolCoinName: string,
     borrowReferral: SuiObjectArg,
     obligationId?: SuiObjectArg,
     obligationKey?: SuiObjectArg
   ) => Promise<TransactionResult>;
   depositQuick: (
     amount: number,
-    poolCoinName: SupportPoolCoins,
+    poolCoinName: string,
     returnSCoin?: boolean
   ) => Promise<TransactionResult>;
   withdrawQuick: (
     amount: number,
-    poolCoinName: SupportPoolCoins
+    poolCoinName: string
   ) => Promise<TransactionResult>;
   repayQuick: (
     amount: number,
-    poolCoinName: SupportPoolCoins,
+    poolCoinName: string,
     obligationId?: SuiObjectArg
   ) => Promise<void>;
-  updateAssetPricesQuick: (
-    assetCoinNames?: SupportAssetCoins[]
-  ) => Promise<void>;
+  updateAssetPricesQuick: (assetCoinNames?: string[]) => Promise<void>;
 };
 
 export type SuiTxBlockWithCoreNormalMethods = SuiKitTxBlock &

package/src/types/builder/index.ts

@@ -5,7 +5,6 @@ import type { VeScaTxBlock } from './vesca';
 import type { ReferralTxBlock } from './referral';
 import { LoyaltyProgramTxBlock } from './loyaltyProgram';
 import { SCoinTxBlock } from './sCoin';
-import { SupportAssetCoins } from '../constant';
 
 export type * from './core';
 export type * from './spool';
@@ -23,7 +22,7 @@ export type SuiTxBlockWithSCoin = BaseScallopTxBlock & SCoinTxBlock;
 export type SuiTxBlockWithSpool = SuiTxBlockWithSCoin & SpoolTxBlock;
 export type ScallopTxBlock = SuiTxBlockWithSpool & CoreTxBlock;
 
-export type SelectCoinReturnType<T extends SupportAssetCoins> = T extends 'sui'
+export type SelectCoinReturnType<T extends string> = T extends 'sui'
   ? {
       takeCoin: NestedResult;
     }

package/src/types/builder/referral.ts

@@ -4,7 +4,6 @@ import {
   SuiTxBlock as SuiKitTxBlock,
 } from '@scallop-io/sui-kit';
 import { ScallopBuilder } from 'src/models';
-import { SupportPoolCoins } from '../constant';
 
 export type ReferralIds = {
   referralPgkId: string;
@@ -17,21 +16,18 @@ export type ReferralIds = {
 
 export type ReferralNormalMethods = {
   bindToReferral: (veScaKeyId: string) => void;
-  claimReferralTicket: (poolCoinName: SupportPoolCoins) => TransactionResult;
-  burnReferralTicket: (
-    ticket: SuiObjectArg,
-    poolCoinName: SupportPoolCoins
-  ) => void;
+  claimReferralTicket: (poolCoinName: string) => TransactionResult;
+  burnReferralTicket: (ticket: SuiObjectArg, poolCoinName: string) => void;
   claimReferralRevenue: (
     veScaKey: SuiObjectArg,
-    poolCoinName: SupportPoolCoins
+    poolCoinName: string
   ) => TransactionResult;
 };
 
 export type ReferralQuickMethods = {
   claimReferralRevenueQuick: (
     veScaKey: SuiObjectArg,
-    coinNames: SupportPoolCoins[]
+    coinNames: string[]
   ) => Promise<void>;
 };
 

package/src/types/builder/sCoin.ts

@@ -3,7 +3,6 @@ import {
   SuiTxBlock as SuiKitTxBlock,
   TransactionResult,
 } from '@scallop-io/sui-kit';
-import { SupportSCoin } from '../constant';
 import { ScallopBuilder } from 'src/models';
 import { BaseScallopTxBlock } from '.';
 
@@ -19,7 +18,7 @@ export type sCoinNormalMethods = {
    * @returns
    */
   mintSCoin: (
-    marketCoinName: SupportSCoin,
+    marketCoinName: string,
     marketCoin: SuiObjectArg
   ) => TransactionResult;
   /**
@@ -28,19 +27,16 @@ export type sCoinNormalMethods = {
    * @param sCoin
    * @returns
    */
-  burnSCoin: (
-    sCoinName: SupportSCoin,
-    sCoin: SuiObjectArg
-  ) => TransactionResult; // returns marketCoin
+  burnSCoin: (sCoinName: string, sCoin: SuiObjectArg) => TransactionResult; // returns marketCoin
 };
 
 export type sCoinQuickMethods = {
   mintSCoinQuick: (
-    marketCoinName: SupportSCoin,
+    marketCoinName: string,
     amount: number
   ) => Promise<TransactionResult>;
   burnSCoinQuick: (
-    sCoinName: SupportSCoin,
+    sCoinName: string,
     amount: number
   ) => Promise<TransactionResult>;
 };

package/src/types/builder/spool.ts

@@ -5,7 +5,6 @@ import type {
 } from '@scallop-io/sui-kit';
 import type { TransactionResult } from '@mysten/sui/transactions';
 import type { ScallopBuilder } from '../../models';
-import type { SupportStakeMarketCoins } from '../constant';
 import { SuiTxBlockWithSCoin } from '.';
 
 export type SpoolIds = {
@@ -13,39 +12,37 @@ export type SpoolIds = {
 };
 
 export type SpoolNormalMethods = {
-  createStakeAccount: (
-    stakeMarketCoinName: SupportStakeMarketCoins
-  ) => TransactionResult;
+  createStakeAccount: (stakeMarketCoinName: string) => TransactionResult;
   stake: (
     stakeAccount: SuiAddressArg,
     coin: SuiObjectArg,
-    stakeMarketCoinName: SupportStakeMarketCoins
+    stakeMarketCoinName: string
   ) => void;
   unstake: (
     stakeAccount: SuiAddressArg,
     amount: number,
-    stakeMarketCoinName: SupportStakeMarketCoins
+    stakeMarketCoinName: string
   ) => TransactionResult;
   claim: (
     stakeAccount: SuiAddressArg,
-    stakeMarketCoinName: SupportStakeMarketCoins
+    stakeMarketCoinName: string
   ) => TransactionResult;
 };
 
 export type SpoolQuickMethods = {
   stakeQuick(
     amountOrMarketCoin: SuiObjectArg | number,
-    stakeMarketCoinName: SupportStakeMarketCoins,
+    stakeMarketCoinName: string,
     stakeAccountId?: SuiAddressArg
   ): Promise<void>;
   unstakeQuick(
     amount: number,
-    stakeMarketCoinName: SupportStakeMarketCoins,
+    stakeMarketCoinName: string,
     stakeAccountId?: SuiAddressArg,
     returnSCoin?: boolean
   ): Promise<TransactionResult | undefined>;
   claimQuick(
-    stakeMarketCoinName: SupportStakeMarketCoins,
+    stakeMarketCoinName: string,
     stakeAccountId?: SuiAddressArg
   ): Promise<TransactionResult[]>;
 };

package/src/types/constant/common.ts

@@ -1,53 +1,47 @@
-import {
-  SUPPORT_POOLS,
-  SUPPORT_COLLATERALS,
-  SUPPORT_ORACLES,
-  SUPPORT_PACKAGES,
-  SUPPORT_SPOOLS,
-  SUPPORT_SPOOLS_REWARDS,
-  SUPPORT_BORROW_INCENTIVE_POOLS,
-  SUPPORT_BORROW_INCENTIVE_REWARDS,
-  SUPPORT_SCOIN,
-  SUPPORT_SUI_BRIDGE,
-  SUPPORT_WORMHOLE,
-} from '../../constants';
+export type PoolAddress = {
+  coinName: string;
+  symbol: string;
+  coinType: string;
+  coinMetadataId: string;
+  decimals: number;
+  // optional keys
+  pythFeed?: string;
+  pythFeedObjectId?: string;
+  lendingPoolAddress?: string;
+  borrowDynamic?: string;
+  interestModel?: string;
+  borrowFeeKey?: string;
+  flashloanFeeObject?: string;
+  coinGeckoId?: string;
+  collateralPoolAddress?: string; // not all pool has collateral
+  riskModel?: string;
+  supplyLimitKey?: string;
+  borrowLimitKey?: string;
+  sCoinType?: string;
+  sCoinName?: string;
+  sCoinSymbol?: string;
+  sCoinMetadataId?: string;
+  sCoinTreasury?: string;
+  isolatedAssetKey?: string;
+  spool?: string;
+  spoolReward?: string;
+  spoolName?: string;
+};
 
-type ParseMarketCoins<T extends string> = `s${T}`;
-type ParseCoins<T extends string> = T extends `s${infer R}` ? R : never;
-
-export type SupportCoins =
-  | SupportAssetCoins
-  | SupportMarketCoins
-  | SupportStakeMarketCoins
-  | SupportSCoin;
-export type SupportAssetCoins =
-  | SupportPoolCoins
-  | SupportCollateralCoins
-  | SupportStakeRewardCoins;
-export type SupportPoolCoins = (typeof SUPPORT_POOLS)[number];
-export type SupportCollateralCoins = (typeof SUPPORT_COLLATERALS)[number];
-export type SupportMarketCoins =
-  | ParseMarketCoins<SupportPoolCoins>
-  | SupportStakeMarketCoins;
-export type SupportStakeMarketCoins = (typeof SUPPORT_SPOOLS)[number];
-export type SupportSuiBridgeCoins = (typeof SUPPORT_SUI_BRIDGE)[number];
-export type SupportWormholeCoins = (typeof SUPPORT_WORMHOLE)[number];
-export type SupportStakeCoins = Extract<
-  SupportPoolCoins,
-  ParseCoins<SupportStakeMarketCoins>
->;
-export type SupportStakeRewardCoins = (typeof SUPPORT_SPOOLS_REWARDS)[number];
-export type SupportBorrowIncentiveCoins =
-  (typeof SUPPORT_BORROW_INCENTIVE_POOLS)[number];
-export type SupportBorrowIncentiveRewardCoins =
-  (typeof SUPPORT_BORROW_INCENTIVE_REWARDS)[number];
-export type SupportSCoin = (typeof SUPPORT_SCOIN)[number];
-
-export type SupportOracleType = (typeof SUPPORT_ORACLES)[number];
-
-export type SupportPackageType = (typeof SUPPORT_PACKAGES)[number];
-
-export type SupportCoinDecimals = Record<SupportCoins, number>;
+export type Whitelist = {
+  lending: Set<string>;
+  borrowing: Set<string>;
+  collateral: Set<string>;
+  packages: Set<string>;
+  spool: Set<string>;
+  scoin: Set<string>;
+  suiBridge: Set<string>;
+  wormhole: Set<string>;
+  oracles: Set<string>;
+  borrowIncentiveRewards: Set<string>;
+  pythEndpoints: Set<string>;
+  deprecated: Set<string>;
+};
 
 export type CoinWrappedType =
   | {

package/src/types/constant/enum.ts

@@ -1,76 +1,64 @@
-import {
-  SupportCoins,
-  SupportAssetCoins,
-  SupportMarketCoins,
-  SupportStakeMarketCoins,
-  SupportStakeRewardCoins,
-  SupportBorrowIncentiveCoins,
-  SupportBorrowIncentiveRewardCoins,
-  SupportSCoin,
-  SupportSuiBridgeCoins,
-} from './common';
-
 export type Coins = {
-  [K in SupportCoins]: K;
+  [K in string]: K;
 };
 
 export type AssetCoins = {
-  [K in SupportAssetCoins]: K;
+  [K in string]: K;
 };
 
 export type MarketCoins = {
-  [K in SupportMarketCoins]: K;
+  [K in string]: K;
 };
 
 export type SCoins = {
-  [K in SupportSCoin]: K;
+  [K in string]: K;
 };
 
 export type StakeMarketCoins = {
-  [K in SupportStakeMarketCoins]: K;
+  [K in string]: K;
 };
 
 export type StakeRewardCoins = {
-  [key in SupportStakeMarketCoins]: SupportStakeRewardCoins;
+  [key in string]: string;
 };
 
 export type SuiBridgeCoins = {
-  [K in SupportSuiBridgeCoins]: K;
+  [K in string]: K;
 };
 
 export type BorrowIncentiveRewardCoins = {
-  [key in SupportBorrowIncentiveCoins]: SupportBorrowIncentiveRewardCoins[];
+  [key in string]: string[];
 };
 
 export type AssetCoinIds = {
-  [key in SupportAssetCoins]: string;
+  [key in string]: string;
 };
 
 export type SCoinIds = {
-  [key in SupportSCoin]: string;
+  [key in string]: string;
 };
 
 export type SCoinTreasuryCaps = {
-  [key in SupportSCoin]: string;
+  [key in string]: string;
 };
 
 export type SCoinConverterTreasury = {
-  [key in SupportSCoin]: string;
+  [key in string]: string;
 };
 
 type PickFromUnion<T, K extends string> = K extends T ? K : never;
 
 export type WormholeCoinIds = {
   [key in PickFromUnion<
-    SupportAssetCoins,
+    string,
     'weth' | 'wbtc' | 'wusdc' | 'wusdt' | 'wapt' | 'wsol'
   >]: string;
 };
 
 export type VoloCoinIds = {
-  [key in PickFromUnion<SupportAssetCoins, 'vsui'>]: string;
+  [key in PickFromUnion<string, 'vsui'>]: string;
 };
 
 export type SuiBridgedCoinPackageIds = {
-  [key in SupportSuiBridgeCoins]: string;
+  [key in string]: string;
 };

package/src/types/constant/xOracle.ts

@@ -1,11 +1,9 @@
-import { SupportAssetCoins, SupportOracleType } from './common';
-
 export type xOracleRules = {
-  primary: SupportOracleType[];
-  secondary: SupportOracleType[];
+  primary: string[];
+  secondary: string[];
 };
 export type xOracleRuleType = keyof xOracleRules;
 
 export type xOracleListType = {
-  [key in SupportAssetCoins]: xOracleRules;
+  [key in string]: xOracleRules;
 };

package/src/types/model.ts

@@ -11,6 +11,9 @@ import type {
 import { ScallopCache } from 'src/models/scallopCache';
 import { AddressesInterface } from './address';
 import { QueryClient, QueryClientConfig } from '@tanstack/query-core';
+import { AxiosInstance } from 'axios';
+import { PoolAddress, Whitelist } from './constant';
+import { ScallopConstants } from 'src/models/scallopConstants';
 
 export type ScallopClientFnReturnType<T extends boolean> = T extends true
   ? SuiTransactionBlockResponse
@@ -35,12 +38,16 @@ export type ScallopAddressInstanceParams = ScallopBaseInstanceParams & {
   cache?: ScallopCache;
 };
 
+export type ScallopConstantsInstanceParams = {
+  address?: ScallopAddress;
+};
+
 export type ScallopIndexerInstanceParams = {
   cache?: ScallopCache;
 };
 
 export type ScallopUtilsInstanceParams = ScallopBaseInstanceParams & {
-  address?: ScallopAddress;
+  constants?: ScallopConstants;
 };
 
 export type ScallopQueryInstanceParams = ScallopBaseInstanceParams & {
@@ -56,40 +63,52 @@ export type ScallopClientInstanceParams = ScallopBaseInstanceParams & {
   builder?: ScallopBuilder;
 };
 
-export type ScallopAddressParams = {
-  id: string;
-  auth?: string;
-  network?: NetworkType;
-  forceInterface?: Partial<Record<NetworkType, AddressesInterface>>;
+export type ScallopCacheConfig = {
+  tokensPerInterval?: number; // How many requests per interval
+  interval?: number; // Interval in milliseconds
 };
 
-export type ScallopParams = {
-  addressId?: string;
-  forceAddressesInterface?: Partial<Record<NetworkType, AddressesInterface>>;
+export type ScallopCacheParams = {
   walletAddress?: string;
+  cacheOptions?: QueryClientConfig;
+  config?: ScallopCacheConfig;
 } & SuiKitParams;
 
-export type ScallopClientParams = ScallopParams &
-  ScallopBuilderParams &
-  ScallopQueryParams &
-  ScallopUtilsParams &
-  ScallopCacheParams;
-
-export type ScallopBuilderParams = ScallopParams & {
-  pythEndpoints?: string[];
-  usePythPullModel?: boolean;
-  useOnChainXOracleList?: boolean;
-} & ScallopQueryParams;
+export type ScallopIndexerParams = ScallopCacheParams & {
+  indexerApiUrl?: string;
+  axios?: AxiosInstance;
+};
 
-export type ScallopQueryParams = ScallopParams & ScallopUtilsParams;
+export type ScallopAddressParams = ScallopCacheParams & {
+  addressApiUrl?: string;
+  addressId: string;
+  auth?: string;
+  network?: NetworkType;
+  forceAddressesInterface?: Partial<Record<NetworkType, AddressesInterface>>;
+};
 
-export type ScallopUtilsParams = ScallopParams & {
-  pythEndpoints?: string[];
+export type ScallopConstantsParams = ScallopAddressParams & {
+  poolAddressesApiUrl?: string;
+  whitelistApiUrl?: string;
+  forcePoolAddressInterface?: Record<string, PoolAddress>;
+  forceWhitelistInterface?: Whitelist;
 };
 
-export type ScallopCacheParams = Omit<
-  ScallopParams,
-  'addressId' | 'forceAddressesInterface'
-> & {
-  cacheOptions?: QueryClientConfig;
+export type ScallopUtilsParams = ScallopAddressParams &
+  ScallopConstantsParams & {
+    pythEndpoints?: string[];
+  };
+
+export type ScallopQueryParams = ScallopUtilsParams & ScallopIndexerParams;
+
+export type ScallopBuilderParams = ScallopQueryParams & {
+  usePythPullModel?: boolean;
+  useOnChainXOracleList?: boolean;
 };
+
+export type ScallopClientParams = ScallopBuilderParams;
+export type ScallopParams = SuiKitParams &
+  ScallopAddressParams &
+  ScallopConstantsParams & {
+    walletAddress?: string;
+  };