@scallop-io/sui-scallop-sdk 2.0.0-alpha.6 → 2.0.0-alpha.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scallop-io/sui-scallop-sdk",
-  "version": "2.0.0-alpha.6",
+  "version": "2.0.0-alpha.7",
   "description": "Typescript sdk for interacting with Scallop contract on SUI",
   "keywords": [
     "sui",
@@ -46,6 +46,9 @@
     "@pythnetwork/pyth-sui-js": "2.1.0",
     "@scallop-io/sui-kit": "1.3.1",
     "@scure/bip39": "^1.2.1",
+    "@switchboard-xyz/common": "^3.0.6",
+    "@switchboard-xyz/on-demand": "^2.2.0",
+    "@switchboard-xyz/sui-sdk": "0.0.21",
     "@tanstack/query-core": "5.51.15",
     "axios": "^1.6.0",
     "bech32": "^2.0.0",

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/{oracle.ts → oracles/index.ts}

@@ -1,13 +1,15 @@
 import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui/utils';
-import {
-  SuiPythClient,
-  SuiPriceServiceConnection,
-} from '@pythnetwork/pyth-sui-js';
 import type { TransactionArgument } from '@mysten/sui/transactions';
 import type { SuiTxBlock as SuiKitTxBlock } from '@scallop-io/sui-kit';
-import type { ScallopBuilder } from '../models';
-import type { xOracleRules, xOracleRuleType } from '../types';
+import type { ScallopBuilder } from 'src/models';
+import type {
+  SupportOracleType,
+  xOracleRules,
+  xOracleRuleType,
+} 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.
@@ -36,46 +38,45 @@ export const updateOracles = async (
     : X_ORACLE_LIST;
 
   // const rules: SupportOracleType[] = builder.isTestnet ? ['pyth'] : ['pyth'];
-  const flattenedRules = [
-    ...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 ?? [
-      ...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
-        );
+  // 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);
+  }
 
-        break;
-      } catch (e) {
-        console.warn(
-          `Failed to update price feeds with endpoint ${endpoint}: ${e}`
-        );
-      }
+  // 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
+      );
     }
   }
 
@@ -324,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 };
+  }
+};