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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scallop-io/sui-scallop-sdk",
-  "version": "1.5.3",
+  "version": "2.0.0-alpha.10",
   "description": "Typescript sdk for interacting with Scallop contract on SUI",
   "keywords": [
     "sui",

package/src/builders/coreBuilder.ts

@@ -2,7 +2,7 @@ import { Transaction } from '@mysten/sui/transactions';
 import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui/utils';
 import { SuiTxBlock as SuiKitTxBlock } from '@scallop-io/sui-kit';
 import { getObligations } from '../queries';
-import { updateOracles } from './oracle';
+import { updateOracles } from './oracles';
 import { requireSender } from '../utils';
 import type { SuiObjectArg, TransactionResult } from '@scallop-io/sui-kit';
 import type { ScallopBuilder } from '../models';
@@ -361,39 +361,16 @@ const generateCoreQuickMethod: GenerateCoreQuickMethod = ({
       const sender = requireSender(txBlock);
       const marketCoinName = builder.utils.parseMarketCoinName(poolCoinName);
 
-      // check if user has sCoin instead of marketCoin
-      try {
-        const sCoinName = builder.utils.parseSCoinName(poolCoinName);
-        if (!sCoinName) throw new Error(`No sCoin for ${poolCoinName}`);
-        const {
-          leftCoin,
-          takeCoin: sCoins,
-          totalAmount,
-        } = await builder.selectSCoin(txBlock, sCoinName, amount, sender);
-        txBlock.transferObjects([leftCoin], sender);
-        const marketCoins = txBlock.burnSCoin(sCoinName, sCoins);
+      const sCoinName = builder.utils.parseSCoinName(poolCoinName);
+      if (!sCoinName) throw new Error(`No sCoin for ${poolCoinName}`);
 
-        // check amount
-        amount -= totalAmount;
-        try {
-          if (amount > 0) {
-            // sCoin is not enough, try market coin
-            const { leftCoin, takeCoin: walletMarketCoins } =
-              await builder.selectMarketCoin(
-                txBlock,
-                marketCoinName,
-                amount,
-                sender
-              );
-            txBlock.transferObjects([leftCoin], sender);
-            txBlock.mergeCoins(marketCoins, [walletMarketCoins]);
-          }
-        } catch (_e) {
-          // ignore
-        }
-        return txBlock.withdraw(marketCoins, poolCoinName);
-      } catch (_e) {
-        // no sCoin found
+      // check if user has sCoin instead of marketCoin
+      const {
+        leftCoin,
+        takeCoin: sCoins,
+        totalAmount,
+      } = await builder.selectSCoin(txBlock, sCoinName, amount, sender);
+      if (totalAmount === 0) {
         const { leftCoin, takeCoin: walletMarketCoins } =
           await builder.selectMarketCoin(
             txBlock,
@@ -404,6 +381,29 @@ const generateCoreQuickMethod: GenerateCoreQuickMethod = ({
         txBlock.transferObjects([leftCoin], sender);
         return txBlock.withdraw(walletMarketCoins, poolCoinName);
       }
+
+      txBlock.transferObjects([leftCoin], sender);
+      const marketCoins = txBlock.burnSCoin(sCoinName, sCoins);
+
+      // check amount
+      amount -= totalAmount;
+      try {
+        if (amount > 0) {
+          // sCoin is not enough, try market coin
+          const { leftCoin, takeCoin: walletMarketCoins } =
+            await builder.selectMarketCoin(
+              txBlock,
+              marketCoinName,
+              amount,
+              sender
+            );
+          txBlock.transferObjects([leftCoin], sender);
+          txBlock.mergeCoins(marketCoins, [walletMarketCoins]);
+        }
+      } catch (_e) {
+        // ignore
+      }
+      return txBlock.withdraw(marketCoins, poolCoinName);
     },
     borrowQuick: async (amount, poolCoinName, obligationId, obligationKey) => {
       const obligationInfo = await requireObligationInfo(

package/src/builders/loyaltyProgramBuilder.ts

@@ -1,6 +1,5 @@
 import { Transaction } from '@mysten/sui/transactions';
 import { SuiTxBlock as SuiKitTxBlock } from '@scallop-io/sui-kit';
-import { coinIds } from 'src/constants';
 import { ScallopBuilder } from 'src/models';
 import {
   GenerateLoyaltyProgramNormalMethod,
@@ -44,13 +43,16 @@ const generateLoyaltyProgramQuickMethod: GenerateLoyaltyProgramQuickMethod = ({
       if (!veScaKey) throw new Error(`No veScaKey found for user ${sender}`);
 
       // claim the pending reward
-      const rewardCoin = await txBlock.claimLoyaltyRevenue(veScaKey);
+      const rewardCoin = txBlock.claimLoyaltyRevenue(veScaKey);
 
       // get existing sca coin to merge with
+      const scaCoinType = builder.constants.coinTypes.sca;
+      if (!scaCoinType) throw new Error('Coin type sca not found');
+
       await builder.utils.mergeSimilarCoins(
         txBlock,
         rewardCoin,
-        coinIds.sca,
+        scaCoinType,
         requireSender(txBlock)
       );
       txBlock.transferObjects([rewardCoin], sender);

package/src/builders/{oracle.ts → oracles/index.ts}

@@ -1,20 +1,15 @@
 import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui/utils';
-import {
-  SuiPythClient,
-  SuiPriceServiceConnection,
-} from '@pythnetwork/pyth-sui-js';
-import { SUPPORT_COLLATERALS, SUPPORT_POOLS } from '../constants';
 import type { TransactionArgument } from '@mysten/sui/transactions';
 import type { SuiTxBlock as SuiKitTxBlock } from '@scallop-io/sui-kit';
-import type { ScallopBuilder } from '../models';
+import type { ScallopBuilder } from 'src/models';
 import type {
-  SupportAssetCoins,
   SupportOracleType,
   xOracleRules,
   xOracleRuleType,
-} from '../types';
-import { PYTH_ENDPOINTS } from 'src/constants/pyth';
+} from 'src/types';
 import { xOracleList as X_ORACLE_LIST } from 'src/constants';
+import { updatePythPriceFeeds } from './pyth';
+// import { updateSwitchboardAggregators } from './switchboard';
 
 /**
  * Update the price of the oracle for multiple coin.
@@ -27,9 +22,7 @@ import { xOracleList as X_ORACLE_LIST } from 'src/constants';
 export const updateOracles = async (
   builder: ScallopBuilder,
   txBlock: SuiKitTxBlock,
-  assetCoinNames: SupportAssetCoins[] = [
-    ...new Set([...SUPPORT_POOLS, ...SUPPORT_COLLATERALS]),
-  ],
+  assetCoinNames: string[] = [...builder.constants.whitelist.lending],
   options: {
     usePythPullModel: boolean;
     useOnChainXOracleList: boolean;
@@ -45,58 +38,52 @@ export const updateOracles = async (
     : X_ORACLE_LIST;
 
   // const rules: SupportOracleType[] = builder.isTestnet ? ['pyth'] : ['pyth'];
-  const flattenedRules: SupportOracleType[] = [
-    ...new Set(
-      Object.values(xOracleList).flatMap(({ primary, secondary }) => [
-        ...primary,
-        ...secondary,
-      ])
-    ),
-  ];
+  const flattenedRules = new Set(
+    Object.values(xOracleList).flatMap(({ primary, secondary }) => [
+      ...primary,
+      ...secondary,
+    ])
+  );
 
-  if (flattenedRules.includes('pyth') && usePythPullModel) {
-    const pythClient = new SuiPythClient(
-      builder.suiKit.client(),
-      builder.address.get('core.oracles.pyth.state'),
-      builder.address.get('core.oracles.pyth.wormholeState')
-    );
-    const priceIds = assetCoinNames.map((assetCoinName) =>
-      builder.address.get(`core.coins.${assetCoinName}.oracle.pyth.feed`)
+  const filterAssetCoinNames = (
+    assetCoinName: string,
+    rule: SupportOracleType
+  ) => {
+    const assetXOracle = xOracleList[assetCoinName];
+    return (
+      assetXOracle &&
+      (assetXOracle.primary.includes(rule) ||
+        assetXOracle.secondary.includes(rule))
     );
+  };
 
-    // iterate through the endpoints
-    const endpoints =
-      builder.params.pythEndpoints ??
-      PYTH_ENDPOINTS[builder.isTestnet ? 'testnet' : 'mainnet'];
-    for (const endpoint of endpoints) {
-      try {
-        const pythConnection = new SuiPriceServiceConnection(endpoint);
-        const priceUpdateData =
-          await pythConnection.getPriceFeedsUpdateData(priceIds);
-        await pythClient.updatePriceFeeds(
-          txBlock.txBlock, // convert txBlock to TransactionBlock because pyth sdk not support new @mysten/sui yet
-          priceUpdateData,
-          priceIds
-        );
-
-        break;
-      } catch (e) {
-        console.warn(
-          `Failed to update price feeds with endpoint ${endpoint}: ${e}`
-        );
-      }
-    }
+  // Handle Pyth price feed
+  if (flattenedRules.has('pyth') && usePythPullModel) {
+    const pythAssetCoinNames = assetCoinNames.filter((assetCoinName) =>
+      filterAssetCoinNames(assetCoinName, 'pyth')
+    );
+    if (pythAssetCoinNames.length > 0)
+      await updatePythPriceFeeds(builder, assetCoinNames, txBlock);
   }
 
+  // Handle Switchboard on-demand aggregator
+  // if (flattenedRules.has('switchboard')) {
+  //   const switchboardAssetCoinNames = assetCoinNames.filter((assetCoinName) =>
+  //     filterAssetCoinNames(assetCoinName, 'switchboard')
+  //   );
+  //   if (switchboardAssetCoinNames.length > 0) {
+  //     await updateSwitchboardAggregators(
+  //       builder,
+  //       switchboardAssetCoinNames,
+  //       txBlock
+  //     );
+  //   }
+  // }
+
   // Remove duplicate coin names.
   const updateAssetCoinNames = [...new Set(assetCoinNames)];
   for (const assetCoinName of updateAssetCoinNames) {
-    await updateOracle(
-      builder,
-      txBlock,
-      assetCoinName,
-      xOracleList[assetCoinName]
-    );
+    updateOracle(builder, txBlock, assetCoinName, xOracleList[assetCoinName]);
   }
 };
 
@@ -107,10 +94,10 @@ export const updateOracles = async (
  * @param txBlock - TxBlock created by SuiKit.
  * @param assetCoinName - Specific support asset coin name.
  */
-const updateOracle = async (
+const updateOracle = (
   builder: ScallopBuilder,
   txBlock: SuiKitTxBlock,
-  assetCoinName: SupportAssetCoins,
+  assetCoinName: string,
   rules: xOracleRules
 ) => {
   const coinType = builder.utils.parseCoinType(assetCoinName);
@@ -177,7 +164,7 @@ const updatePrice = (
     xOracleId,
     coinType
   );
-  Object.entries(rules).forEach(([type, rule]: [any, SupportOracleType[]]) => {
+  Object.entries(rules).forEach(([type, rule]: [any, string[]]) => {
     if (rule.includes('pyth')) {
       updatePythPrice(
         type,
@@ -338,7 +325,8 @@ const updateSwitchboardPrice = (
   coinType: string
 ) => {
   txBlock.moveCall(
-    `${packageId}::rule::set_price_as_${type}`,
+    // `${packageId}::rule::set_price_as_${type}`,
+    `${packageId}::rule::set_as_${type}_price`,
     [
       request,
       aggregatorId,

package/src/builders/oracles/pyth.ts

@@ -0,0 +1,44 @@
+import {
+  SuiPriceServiceConnection,
+  SuiPythClient,
+} from '@pythnetwork/pyth-sui-js';
+import { ScallopBuilder } from 'src/models';
+import type { SuiTxBlock as SuiKitTxBlock } from '@scallop-io/sui-kit';
+
+export const updatePythPriceFeeds = async (
+  builder: ScallopBuilder,
+  assetCoinNames: string[],
+  txBlock: SuiKitTxBlock
+) => {
+  const pythClient = new SuiPythClient(
+    builder.suiKit.client(),
+    builder.address.get('core.oracles.pyth.state'),
+    builder.address.get('core.oracles.pyth.wormholeState')
+  );
+  const priceIds = assetCoinNames.map((assetCoinName) =>
+    builder.address.get(`core.coins.${assetCoinName}.oracle.pyth.feed`)
+  );
+
+  // iterate through the endpoints
+  const endpoints = builder.params.pythEndpoints ?? [
+    ...builder.constants.whitelist.pythEndpoints,
+  ];
+  for (const endpoint of endpoints) {
+    try {
+      const pythConnection = new SuiPriceServiceConnection(endpoint);
+      const priceUpdateData =
+        await pythConnection.getPriceFeedsUpdateData(priceIds);
+      await pythClient.updatePriceFeeds(
+        txBlock.txBlock, // convert txBlock to TransactionBlock because pyth sdk not support new @mysten/sui yet
+        priceUpdateData,
+        priceIds
+      );
+
+      break;
+    } catch (e) {
+      console.warn(
+        `Failed to update price feeds with endpoint ${endpoint}: ${e}`
+      );
+    }
+  }
+};

package/src/builders/oracles/switchboard.ts

@@ -0,0 +1,270 @@
+// import { ScallopBuilder } from 'src/models';
+// import {
+//   // SUI_CLOCK_OBJECT_ID,
+//   // SUI_TYPE_ARG,
+//   type SuiTxBlock as SuiKitTxBlock,
+// } from '@scallop-io/sui-kit';
+// import {
+//   Aggregator,
+//   AggregatorData,
+//   ObjectParsingHelper,
+//   // AggregatorData,
+//   // FeedEvalResponse,
+//   // ObjectParsingHelper,
+//   // Queue,
+//   SwitchboardClient,
+// } from '@switchboard-xyz/sui-sdk';
+// import { queryMultipleObjects } from 'src/queries';
+// import { MoveValue, SuiParsedData } from '@mysten/sui/client';
+// import { toHex } from '@mysten/bcs';
+// // import { CrossbarClient, IOracleJob, OracleJob } from '@switchboard-xyz/common';
+// // import axios from 'axios';
+
+// const getFieldsFromObject = (
+//   response: SuiParsedData
+// ): {
+//   [key: string]: MoveValue;
+// } => {
+//   // Check if 'data' and 'content' exist and are of the expected type
+//   if (response.dataType === 'moveObject') {
+//     // Safely return 'fields' from 'content'
+//     return response.fields as any;
+//   }
+
+//   throw new Error('Invalid response data');
+// };
+
+// const parseFeedConfigs = (responses: SuiParsedData[]): AggregatorData[] => {
+//   return responses.map(getFieldsFromObject).map((aggregatorData) => {
+//     const currentResult = (aggregatorData.current_result as any).fields;
+//     const updateState = (aggregatorData.update_state as any).fields;
+
+//     // build the data object
+//     const data: AggregatorData = {
+//       id: ObjectParsingHelper.asId(aggregatorData.id),
+//       authority: ObjectParsingHelper.asString(aggregatorData.authority),
+//       createdAtMs: ObjectParsingHelper.asNumber(aggregatorData.created_at_ms),
+//       currentResult: {
+//         maxResult: ObjectParsingHelper.asBN(currentResult.max_result),
+//         maxTimestamp: ObjectParsingHelper.asNumber(
+//           currentResult.max_timestamp_ms
+//         ),
+//         mean: ObjectParsingHelper.asBN(currentResult.mean),
+//         minResult: ObjectParsingHelper.asBN(currentResult.min_result),
+//         minTimestamp: ObjectParsingHelper.asNumber(
+//           currentResult.min_timestamp_ms
+//         ),
+//         range: ObjectParsingHelper.asBN(currentResult.range),
+//         result: ObjectParsingHelper.asBN(currentResult.result),
+//         stdev: ObjectParsingHelper.asBN(currentResult.stdev),
+//       },
+//       feedHash: toHex(
+//         ObjectParsingHelper.asUint8Array(aggregatorData.feed_hash)
+//       ),
+//       maxStalenessSeconds: ObjectParsingHelper.asNumber(
+//         aggregatorData.max_staleness_seconds
+//       ),
+//       maxVariance: ObjectParsingHelper.asNumber(aggregatorData.max_variance),
+//       minResponses: ObjectParsingHelper.asNumber(aggregatorData.min_responses),
+//       minSampleSize: ObjectParsingHelper.asNumber(
+//         aggregatorData.min_sample_size
+//       ),
+//       name: ObjectParsingHelper.asString(aggregatorData.name),
+//       queue: ObjectParsingHelper.asString(aggregatorData.queue),
+//       updateState: {
+//         currIdx: ObjectParsingHelper.asNumber(updateState.curr_idx),
+//         results: updateState.results.map((r: any) => {
+//           const oracleId = r.fields.oracle;
+//           const value = ObjectParsingHelper.asBN(r.fields.result.fields);
+//           const timestamp = parseInt(r.fields.timestamp_ms);
+//           return {
+//             oracle: oracleId,
+//             value,
+//             timestamp,
+//           };
+//         }),
+//       },
+//     };
+
+//     return data;
+//   });
+// };
+
+// // const encodeJobs = (jobArray: OracleJob[]) => {
+// //   return jobArray.map((job) => serializeOracleJob(job).toString('base64'));
+// // };
+
+// // const normalizeOracleJob = (
+// //   data: string | IOracleJob | Record<string, any>
+// // ): OracleJob => {
+// //   const parseJobObject = (jobData: Record<string, any>) => {
+// //     if (!jobData) {
+// //       throw new Error(`No job data provided: ${jobData}`);
+// //     } else if (!('tasks' in jobData)) {
+// //       throw new Error('"tasks" property is required');
+// //     } else if (!(Array.isArray(jobData.tasks) && jobData.tasks.length > 0)) {
+// //       throw new Error('"tasks" property must be a non-empty array');
+// //     }
+// //     return OracleJob.fromObject(jobData);
+// //   };
+// //   const parseJobString = (jobString: string) => {
+// //     // Strip comments using regex from https://regex101.com/r/B8WkuX/1
+// //     const cleanJson = jobString.replace(
+// //       /\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/g,
+// //       ''
+// //     );
+// //     return parseJobObject(JSON.parse(cleanJson));
+// //   };
+// //   return typeof data === 'string' ? parseJobString(data) : parseJobObject(data);
+// // };
+
+// // const serializeOracleJob = (
+// //   data: string | IOracleJob | Record<string, any>
+// // ): Buffer => {
+// //   const job = normalizeOracleJob(data);
+// //   return Buffer.from(OracleJob.encodeDelimited(job).finish());
+// // };
+
+// // const fetchSignatures = async (
+// //   feedConfig: AggregatorData
+// // ): Promise<{
+// //   responses: FeedEvalResponse[];
+// //   failures: string[];
+// // }> => {
+// //   const crossbarClient = new CrossbarClient('https://crossbar.switchboard.xyz');
+
+// //   const jobs: OracleJob[] = await crossbarClient
+// //     .fetch(feedConfig.feedHash)
+// //     .then((res) => res.jobs.map((job) => OracleJob.fromObject(job)));
+
+// //   const encodedJobs = encodeJobs(jobs);
+// //   const maxVariance = Math.floor(feedConfig.maxVariance / 1e9) * 1e9;
+// //   const minResponses = feedConfig.minResponses;
+// //   const numSignatures = feedConfig.minSampleSize;
+// //   const recentHash = toBase58(new Uint8Array(32));
+// //   const useTimestamp = true;
+
+// //   const GATEWAY_URL = 'https://api.mainnet-beta.solana.com';
+// //   const TIMEOUT = 10000;
+// //   const url = `${GATEWAY_URL}/gateway/api/v1/fetch_signatures`;
+// //   const headers = { 'Content-Type': 'application/json' };
+
+// //   const body = JSON.stringify({
+// //     api_version: '1.0.0',
+// //     jobs_b64_encoded: encodedJobs,
+// //     recent_chainhash: recentHash,
+// //     signature_scheme: 'Secp256k1',
+// //     hash_scheme: 'Sha256',
+// //     num_oracles: numSignatures,
+// //     max_variance: maxVariance,
+// //     min_responses: minResponses,
+// //     use_timestamp: useTimestamp,
+// //   });
+
+// //   return await axios
+// //     .post(url, body, {
+// //       headers,
+// //       timeout: TIMEOUT,
+// //     })
+// //     .then((r) => r.data);
+// // };
+
+// export const updateSwitchboardAggregators = async (
+//   builder: ScallopBuilder,
+//   assetCoinNames: string[],
+//   txBlock: SuiKitTxBlock
+// ) => {
+//   const switchboardClient = new SwitchboardClient(builder.suiKit.client());
+//   const onDemandAggObjects = await queryMultipleObjects(
+//     builder.cache,
+//     await builder.query.getSwitchboardOnDemandAggregatorObjectIds(
+//       assetCoinNames
+//     )
+//   );
+
+//   const feedConfigs = parseFeedConfigs(
+//     onDemandAggObjects.map((t) => t.content) as SuiParsedData[]
+//   );
+
+//   for (const idx in assetCoinNames) {
+//     // const { switchboardAddress, oracleQueueId } =
+//     //   await switchboardClient.fetchState();
+
+//     // const feedConfig = feedConfigs[idx];
+
+//     // const suiQueue = await new Queue(
+//     //   switchboardClient,
+//     //   oracleQueueId
+//     // ).loadData();
+
+//     // const { responses, failures } = await fetchSignatures(feedConfig);
+//     // const validOracles = new Set(
+//     //   suiQueue.existingOracles.map((o) => o.oracleKey)
+//     // );
+
+//     // const validResponses = responses.filter((r) => {
+//     //   return validOracles.has(toBase58(fromHex(r.oracle_pubkey)));
+//     // });
+
+//     // // if we have no valid responses (or not enough), fail out
+//     // if (
+//     //   !validResponses.length ||
+//     //   validResponses.length < feedConfig.minSampleSize
+//     // ) {
+//     //   // maybe retry by recursing into the same function / add a retry count
+//     //   throw new Error('Not enough valid oracle responses.');
+//     // }
+
+//     // // split the gas coin into the right amount for each response
+//     // const coins = txBlock.splitCoins(
+//     //   txBlock.gas,
+//     //   validResponses.map(() => suiQueue.fee)
+//     // );
+
+//     // // map the responses into the tx
+//     // validResponses.forEach((response, i) => {
+//     //   const oracle = suiQueue.existingOracles.find(
+//     //     (o) => o.oracleKey === toBase58(fromHex(response.oracle_pubkey))
+//     //   )!;
+
+//     //   const signature = Array.from(fromBase64(response.signature));
+//     //   signature.push(response.recovery_id);
+
+//     //   txBlock.moveCall(
+//     //     `${switchboardAddress}::aggregator_submit_result_action::run`,
+//     //     [
+//     //       txBlock.object(onDemandAggObjects[idx].objectId),
+//     //       txBlock.object(suiQueue.id),
+//     //       txBlock.pure.u128(response.success_value),
+//     //       txBlock.pure.bool(response.success_value.startsWith('-')),
+//     //       txBlock.pure.u64(response.timestamp!),
+//     //       txBlock.object(oracle.oracleId),
+//     //       txBlock.pure.vector('u8', signature),
+//     //       txBlock.sharedObjectRef({
+//     //         objectId: SUI_CLOCK_OBJECT_ID,
+//     //         initialSharedVersion: '1',
+//     //         mutable: false,
+//     //       }),
+//     //       coins[i],
+//     //     ],
+//     //     [SUI_TYPE_ARG]
+//     //   );
+//     // });
+
+//     // return { responses, failures };
+
+//     const switchboardAgg = new Aggregator(
+//       switchboardClient,
+//       onDemandAggObjects[idx].objectId
+//     );
+
+//     const { responses, failures } = await switchboardAgg.fetchUpdateTx(
+//       txBlock.txBlock,
+//       {
+//         feedConfigs: feedConfigs[idx],
+//       }
+//     );
+
+//     return { responses, failures };
+//   }
+// };

package/src/builders/referralBuilder.ts

@@ -1,5 +1,5 @@
 import { ScallopBuilder } from 'src/models';
-import { ScallopTxBlock, SupportCoins, SupportPoolCoins } from 'src/types';
+import { ScallopTxBlock } from 'src/types';
 import {
   SUI_CLOCK_OBJECT_ID,
   SuiTxBlock as SuiKitTxBlock,
@@ -13,7 +13,6 @@ import {
   ReferralTxBlock,
   SuiTxBlockWithReferralNormalMethods,
 } from 'src/types/builder/referral';
-import { SUPPORT_POOLS } from 'src/constants';
 import { requireSender } from 'src/utils';
 
 const generateReferralNormalMethod: GenerateReferralNormalMethod = ({
@@ -52,7 +51,7 @@ const generateReferralNormalMethod: GenerateReferralNormalMethod = ({
         []
       );
     },
-    claimReferralTicket: (poolCoinName: SupportCoins) => {
+    claimReferralTicket: (poolCoinName: string) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
       return builder.moveCall(
         txBlock,
@@ -68,7 +67,7 @@ const generateReferralNormalMethod: GenerateReferralNormalMethod = ({
         [coinType]
       );
     },
-    burnReferralTicket: (ticket: SuiObjectArg, poolCoinName: SupportCoins) => {
+    burnReferralTicket: (ticket: SuiObjectArg, poolCoinName: string) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
       builder.moveCall(
         txBlock,
@@ -82,10 +81,7 @@ const generateReferralNormalMethod: GenerateReferralNormalMethod = ({
         [coinType]
       );
     },
-    claimReferralRevenue: (
-      veScaKey: SuiObjectArg,
-      poolCoinName: SupportCoins
-    ) => {
+    claimReferralRevenue: (veScaKey: SuiObjectArg, poolCoinName: string) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
       return builder.moveCall(
         txBlock,
@@ -109,7 +105,7 @@ const generateReferralQuickMethod: GenerateReferralQuickMethod = ({
   return {
     claimReferralRevenueQuick: async (
       veScaKey: SuiObjectArg,
-      coinNames: SupportPoolCoins[] = [...SUPPORT_POOLS]
+      coinNames: string[] = [...builder.constants.whitelist.lending]
     ) => {
       const sender = requireSender(txBlock);
       const objToTransfer: SuiObjectArg[] = [];