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

package/src/builders/oracles/index.ts

@@ -1,18 +1,14 @@
-import { X_ORACLE_LIST } from 'src/constants/xoracle';
-import { createXOracleUpdater, IXOracleUpdater } from './xOracleUpdater';
-import {
-  createPackageRegistry,
-  XOraclePackageRegistry,
-} from './oraclePackageRegistry';
-import {
-  createPriceFeedUpdater,
-  PriceFeedUpdateOptions,
-} from './priceFeedUpdater';
+import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui/utils';
+import type { TransactionArgument } from '@mysten/sui/transactions';
 import type { SuiTxBlock as SuiKitTxBlock } from '@scallop-io/sui-kit';
 import type { ScallopBuilder } from 'src/models';
-import type { SupportOracleType, xOracleRuleType } from 'src/types/constant';
-import { PriceUpdateRequester } from './priceUpdateRequester';
-import { UnsupportedOracleError } from './error';
+import type {
+  SupportOracleType,
+  xOracleRules,
+  xOracleRuleType,
+} from 'src/types';
+import { xOracleList as X_ORACLE_LIST } from 'src/constants';
+import { updatePythPriceFeeds } from './pyth';
 
 /**
  * Update the price of the oracle for multiple coin.
@@ -26,126 +22,381 @@ export const updateOracles = async (
   builder: ScallopBuilder,
   txBlock: SuiKitTxBlock,
   assetCoinNames: string[] = [...builder.constants.whitelist.lending],
-  options: Partial<PriceFeedUpdateOptions> = {}
+  options?: {
+    usePythPullModel?: boolean;
+    useOnChainXOracleList?: boolean;
+    sponsoredFeeds?: string[];
+    isSponsoredTx?: boolean;
+  }
 ) => {
-  // Validate the options
-  assetCoinNames = [...new Set(assetCoinNames)]; // Remove duplicates
-  const mergedOptions = {
-    usePythPullModel: builder.usePythPullModel,
-    useOnChainXOracleList: builder.useOnChainXOracleList,
-    pythSponsoredFeeds: builder.pythSponsoredFeeds,
-    ...options,
-  } as PriceFeedUpdateOptions;
-
-  // Retrieve the xOracle list from the builder or use the default one.
-  const xOracleList = mergedOptions.useOnChainXOracleList
-    ? await builder.query.getAssetOracles()
-    : X_ORACLE_LIST; // Record<coinName, Record<xOracleRuleType, SupportOracleType[]>>
-
-  const xOracleListAsSet = Object.entries(xOracleList).reduce(
-    (acc, [coinName, { primary, secondary }]) => {
-      acc[coinName] = {
-        primary: new Set(primary),
-        secondary: new Set(secondary),
-      };
-      return acc;
-    },
-    {} as Record<string, Record<xOracleRuleType, Set<SupportOracleType>>>
+  const usePythPullModel =
+    options?.usePythPullModel ?? builder.usePythPullModel;
+  const useOnChainXOracleList =
+    options?.useOnChainXOracleList ?? builder.useOnChainXOracleList;
+  const sponsoredFeeds = new Set(
+    options?.sponsoredFeeds ?? builder.sponsoredFeeds
   );
+  const isSponsoredTx = options?.isSponsoredTx ?? false;
+
+  // Validate the sponsoredFeeds content.
+  sponsoredFeeds.forEach((feed) => {
+    if (!builder.constants.whitelist.lending.has(feed)) {
+      throw new Error(`${feed} is not valid feed`);
+    }
+  });
+
+  const xOracleList = useOnChainXOracleList
+    ? await builder.query.getAssetOracles()
+    : X_ORACLE_LIST;
 
-  // Get all oracle types no duplicates from all rules (primary and secondary).
-  const oracleTypesSet = new Set(
+  // const rules: SupportOracleType[] = builder.isTestnet ? ['pyth'] : ['pyth'];
+  const flattenedRules = new Set(
     Object.values(xOracleList).flatMap(({ primary, secondary }) => [
       ...primary,
       ...secondary,
     ])
   );
 
-  const getRuleType = (
+  const filterAssetCoinNames = (
     assetCoinName: string,
-    oracleType: SupportOracleType
+    rule: SupportOracleType
   ) => {
-    const ruleSet = xOracleListAsSet[assetCoinName];
-    if (!ruleSet)
-      return {
-        isPrimary: false,
-        isSecondary: false,
-      };
-
-    const { primary, secondary } = ruleSet;
-    const isPrimary = primary.has(oracleType);
-    const isSecondary = secondary.has(oracleType);
-
-    return {
-      isPrimary,
-      isSecondary,
-    };
+    const assetXOracle = xOracleList[assetCoinName];
+    return (
+      assetXOracle &&
+      (assetXOracle.primary.includes(rule) ||
+        assetXOracle.secondary.includes(rule))
+    );
   };
 
-  // Create a package registry for xOracle
-  const xOraclePackageRegistry = new XOraclePackageRegistry(builder.utils);
-
-  // Create xOracle updater for each oracle type
-  const xOracleUpdaters: Partial<Record<SupportOracleType, IXOracleUpdater>> =
-    {};
-
-  // Iterate through oracle set
-  for (const oracleType of oracleTypesSet) {
-    const filteredAssetCoinNames = assetCoinNames.filter((assetCoinName) => {
-      const { isPrimary, isSecondary } = getRuleType(assetCoinName, oracleType);
-      if (!isPrimary && !isSecondary) return false;
-      return true;
-    });
-
-    if (filteredAssetCoinNames.length > 0) {
-      // Update all necessary price feeds
-      await createPriceFeedUpdater(
-        oracleType,
-        txBlock,
+  const updateAssetCoinNames = [...new Set(assetCoinNames)];
+  const pythAssetCoinNames = updateAssetCoinNames.filter((assetCoinName) =>
+    filterAssetCoinNames(assetCoinName, 'pyth')
+  );
+
+  if (flattenedRules.has('pyth')) {
+    const needToUpdatePythPriceFeeds: string[] = [];
+    for (const pythAssetCoinName of pythAssetCoinNames) {
+      /**
+       * Check if the Pyth pull model is not used but the feed is not sponsored.
+       * This is used to determine if we should update the Pyth price feeds.
+       */
+      const notUsingPullAndNotSponsored =
+        !usePythPullModel && !sponsoredFeeds.has(pythAssetCoinName);
+
+      if (usePythPullModel || notUsingPullAndNotSponsored) {
+        needToUpdatePythPriceFeeds.push(pythAssetCoinName);
+      }
+    }
+
+    if (needToUpdatePythPriceFeeds.length > 0) {
+      await updatePythPriceFeeds(
         builder,
-        filteredAssetCoinNames,
-        mergedOptions
-      ).updatePriceFeeds();
+        needToUpdatePythPriceFeeds,
+        txBlock,
+        isSponsoredTx
+      );
     }
+  }
 
-    // Create the xOracle updater for the current oracle type
-    xOracleUpdaters[oracleType] = createXOracleUpdater(
-      txBlock,
-      createPackageRegistry(oracleType, xOraclePackageRegistry)
-    );
+  // Remove duplicate coin names.
+  for (const assetCoinName of updateAssetCoinNames) {
+    updateOracle(builder, txBlock, assetCoinName, xOracleList[assetCoinName]);
   }
+};
+
+/**
+ * Update the price of the oracle for specific coin.
+ *
+ * @param builder - The scallop builder.
+ * @param txBlock - TxBlock created by SuiKit.
+ * @param assetCoinName - Specific support asset coin name.
+ */
+const updateOracle = (
+  builder: ScallopBuilder,
+  txBlock: SuiKitTxBlock,
+  assetCoinName: string,
+  rules: xOracleRules
+) => {
+  const coinType = builder.utils.parseCoinType(assetCoinName);
 
-  // Create a price update requester
-  const priceUpdateRequester = new PriceUpdateRequester(
+  updatePrice(
     txBlock,
-    xOraclePackageRegistry
+    rules,
+    builder.address.get('core.packages.xOracle.id'),
+    builder.address.get('core.oracles.xOracle'),
+    builder.address.get('core.packages.pyth.id'),
+    builder.address.get('core.oracles.pyth.registry'),
+    builder.address.get('core.oracles.pyth.state'),
+    builder.address.get(`core.coins.${assetCoinName}.oracle.pyth.feedObject`),
+    builder.address.get('core.packages.switchboard.id'),
+    builder.address.get('core.oracles.switchboard.registry'),
+    builder.address.get(`core.coins.${assetCoinName}.oracle.switchboard`),
+    builder.address.get('core.packages.supra.id'),
+    builder.address.get('core.oracles.supra.registry'),
+    builder.address.get(`core.oracles.supra.holder`),
+    coinType
   );
+};
 
-  for (const assetCoinName of assetCoinNames) {
-    const rules = xOracleList[assetCoinName];
-
-    // build the price update request for the asset coin
-    // Each coin name has its own price update request
-    const updateRequest = priceUpdateRequester.buildRequest(assetCoinName);
-
-    // Iterate through each rule and update the xOracle for each oracle type
-    Object.keys(rules).forEach((rule) => {
-      const oracles = rules[rule as xOracleRuleType];
-      oracles.forEach((oracleType) => {
-        const updater = xOracleUpdaters[oracleType];
-        if (!updater) {
-          // Should never happen if ORACLE_TYPES is the source of truth
-          throw new UnsupportedOracleError(oracleType);
-        }
-        updater.updateXOracle(
-          assetCoinName,
-          rule as xOracleRuleType,
-          updateRequest
-        );
-      });
-    });
-
-    // Confirm the price update request for all oracles
-    priceUpdateRequester.confirmRequest(assetCoinName, updateRequest);
-  }
+/**
+ * Construct a transaction block for update the price.
+ *
+ * @param txBlock - The transaction block.
+ * @param rules - The oracle rules.
+ * @param xOraclePackageId - The xOracle package id.
+ * @param xOracleId - The xOracle Id from xOracle package.
+ * @param pythPackageId - The pyth package id.
+ * @param pythRegistryId - The registry id from pyth package.
+ * @param pythStateId - The price state id from pyth package.
+ * @param pythFeedObjectId - The feed object id from pyth package.
+ * @param switchboardPackageId - The switchboard package id.
+ * @param switchboardRegistryId - The registry id from switchboard package.
+ * @param switchboardAggregatorId - The aggregator id from switchboard package.
+ * @param supraPackageId - The supra package id.
+ * @param supraRegistryId - The registry id from supra package.
+ * @param supraHolderId - The holder id from supra package.
+ * @param coinType - The type of coin.
+ * @return TxBlock created by SuiKit.
+ */
+const updatePrice = (
+  txBlock: SuiKitTxBlock,
+  rules: xOracleRules,
+  xOraclePackageId: string,
+  xOracleId: TransactionArgument | string,
+  pythPackageId: string,
+  pythRegistryId: TransactionArgument | string,
+  pythStateId: TransactionArgument | string,
+  pythFeedObjectId: TransactionArgument | string,
+  switchboardPackageId: string,
+  switchboardRegistryId: TransactionArgument | string,
+  switchboardAggregatorId: TransactionArgument | string,
+  supraPackageId: string,
+  supraRegistryId: TransactionArgument | string,
+  supraHolderId: TransactionArgument | string,
+  coinType: string
+) => {
+  const request = priceUpdateRequest(
+    txBlock,
+    xOraclePackageId,
+    xOracleId,
+    coinType
+  );
+  Object.entries(rules).forEach(([type, rule]: [any, string[]]) => {
+    if (rule.includes('pyth')) {
+      updatePythPrice(
+        type,
+        txBlock,
+        pythPackageId,
+        request,
+        pythStateId,
+        pythFeedObjectId,
+        pythRegistryId,
+        coinType
+      );
+    }
+    if (rule.includes('supra')) {
+      updateSupraPrice(
+        type,
+        txBlock,
+        supraPackageId,
+        request,
+        supraHolderId,
+        supraRegistryId,
+        coinType
+      );
+    }
+    if (rule.includes('switchboard')) {
+      updateSwitchboardPrice(
+        type,
+        txBlock,
+        switchboardPackageId,
+        request,
+        switchboardAggregatorId,
+        switchboardRegistryId,
+        coinType
+      );
+    }
+  });
+
+  confirmPriceUpdateRequest(
+    txBlock,
+    xOraclePackageId,
+    xOracleId,
+    request,
+    coinType
+  );
+  return txBlock;
+};
+
+/**
+ * Construct a transaction block for request price update.
+ *
+ * @param txBlock - The transaction block.
+ * @param packageId - The xOracle package id.
+ * @param xOracleId - The xOracle Id from xOracle package.
+ * @param coinType - The type of coin.
+ * @return TxBlock created by SuiKit.
+ */
+const priceUpdateRequest = (
+  txBlock: SuiKitTxBlock,
+  packageId: string,
+  xOracleId: TransactionArgument | string,
+  coinType: string
+) => {
+  const target = `${packageId}::x_oracle::price_update_request`;
+  const typeArgs = [coinType];
+  return txBlock.moveCall(target, [xOracleId], typeArgs);
+};
+
+/**
+ * Construct a transaction block for confirm price update request.
+ *
+ * @param txBlock - The transaction block.
+ * @param packageId - The xOracle package id.
+ * @param xOracleId - The xOracle Id from xOracle package.
+ * @param request - The result of the request.
+ * @param coinType - The type of coin.
+ * @return TxBlock created by SuiKit.
+ */
+const confirmPriceUpdateRequest = (
+  txBlock: SuiKitTxBlock,
+  packageId: string,
+  xOracleId: TransactionArgument | string,
+  request: TransactionArgument,
+  coinType: string
+) => {
+  const target = `${packageId}::x_oracle::confirm_price_update_request`;
+  const typeArgs = [coinType];
+  txBlock.moveCall(
+    target,
+    [
+      xOracleId,
+      request,
+      txBlock.sharedObjectRef({
+        objectId: SUI_CLOCK_OBJECT_ID,
+        mutable: false,
+        initialSharedVersion: '1',
+      }),
+    ],
+    typeArgs
+  );
+  return txBlock;
+};
+
+/**
+ * Construct a transaction block for update supra price.
+ *
+ * @param type - The type of price rule.
+ * @param txBlock - The transaction block.
+ * @param packageId - The supra package id.
+ * @param request - The result of the request.
+ * @param holderId - The holder id from supra package.
+ * @param registryId - The registry id from supra package.
+ * @param coinType - The type of coin.
+ * @return TxBlock created by SuiKit.
+ */
+const updateSupraPrice = (
+  type: xOracleRuleType,
+  txBlock: SuiKitTxBlock,
+  packageId: string,
+  request: TransactionArgument,
+  holderId: TransactionArgument | string,
+  registryId: TransactionArgument | string,
+  coinType: string
+) => {
+  txBlock.moveCall(
+    `${packageId}::rule::set_price_as_${type}`,
+    [
+      request,
+      holderId,
+      registryId,
+      txBlock.sharedObjectRef({
+        objectId: SUI_CLOCK_OBJECT_ID,
+        initialSharedVersion: '1',
+        mutable: false,
+      }),
+    ],
+    [coinType]
+  );
+};
+
+/**
+ * Construct a transaction block for update switchboard price.
+ *
+ * @param type - The type of price rule.
+ * @param txBlock - The transaction block.
+ * @param packageId - The switchboard package id.
+ * @param request - The result of the request.
+ * @param aggregatorId - The aggregator id from switchboard package.
+ * @param registryId - The registry id from switchboard package.
+ * @param coinType - The type of coin.
+ * @return TxBlock created by SuiKit.
+ */
+const updateSwitchboardPrice = (
+  type: xOracleRuleType,
+  txBlock: SuiKitTxBlock,
+  packageId: string,
+  request: TransactionArgument,
+  aggregatorId: TransactionArgument | string,
+  registryId: TransactionArgument | string,
+  coinType: string
+) => {
+  txBlock.moveCall(
+    // `${packageId}::rule::set_price_as_${type}`,
+    `${packageId}::rule::set_as_${type}_price`,
+    [
+      request,
+      aggregatorId,
+      registryId,
+      txBlock.sharedObjectRef({
+        objectId: SUI_CLOCK_OBJECT_ID,
+        initialSharedVersion: '1',
+        mutable: false,
+      }),
+    ],
+    [coinType]
+  );
+};
+
+/**
+ * Construct a transaction block for update pyth price.
+ *
+ * @param type - The type of price rule.
+ * @param txBlock - The transaction block.
+ * @param packageId - The pyth package id.
+ * @param request - The result of the request.
+ * @param stateId - The price state id from pyth package.
+ * @param wormholeStateId - The whormhole state id from pyth package.
+ * @param feedObjectId - The feed object id from pyth package.
+ * @param vaaFromFeeId - The vaa from pyth api with feed id.
+ * @param registryId - The registry id from pyth package.
+ * @param coinType - The type of coin.
+ * @return TxBlock created by SuiKit.
+ */
+const updatePythPrice = (
+  type: xOracleRuleType,
+  txBlock: SuiKitTxBlock,
+  packageId: string,
+  request: TransactionArgument,
+  stateId: TransactionArgument | string,
+  feedObjectId: TransactionArgument | string,
+  registryId: TransactionArgument | string,
+  coinType: string
+) => {
+  txBlock.moveCall(
+    `${packageId}::rule::set_price_as_${type}`,
+    [
+      request,
+      stateId,
+      feedObjectId,
+      registryId,
+      txBlock.sharedObjectRef({
+        objectId: SUI_CLOCK_OBJECT_ID,
+        initialSharedVersion: '1',
+        mutable: false,
+      }),
+    ],
+    [coinType]
+  );
 };

package/src/builders/oracles/pyth.ts

@@ -0,0 +1,135 @@
+import {
+  HexString,
+  SuiPriceServiceConnection,
+  SuiPythClient,
+} from '@pythnetwork/pyth-sui-js';
+import { ScallopBuilder } from 'src/models';
+import {
+  SUI_CLOCK_OBJECT_ID,
+  type SuiTxBlock as SuiKitTxBlock,
+  type Transaction,
+} from '@scallop-io/sui-kit';
+import { SuiClient } from '@mysten/sui/client';
+
+type ObjectId = string;
+class ScallopPythClient extends SuiPythClient {
+  constructor(
+    provider: SuiClient,
+    pythStateId: ObjectId,
+    wormholeStateId: ObjectId,
+    private params: {
+      // addressId?: string;
+      defaultPackageId: ObjectId;
+      gasStationId: ObjectId;
+    }
+  ) {
+    super(provider, pythStateId, wormholeStateId);
+  }
+
+  async updatePriceFeedsWithSponsoredBaseUpdateFee(
+    tx: Transaction,
+    updates: Buffer[],
+    feedIds: HexString[]
+  ) {
+    if (!this.params) throw new Error('Please provide params');
+    const { defaultPackageId: scallopSponsorPackage, gasStationId } =
+      this.params;
+    const packageId = await this.getPythPackageId();
+    let priceUpdatesHotPotato = await this.verifyVaasAndGetHotPotato(
+      tx,
+      updates,
+      packageId
+    );
+
+    const priceInfoObjects = [];
+    for (const feedId of feedIds) {
+      const priceInfoObjectId = await this.getPriceFeedObjectId(feedId);
+      if (!priceInfoObjectId) {
+        throw new Error(`Price feed object not found for ID: ${feedId}`);
+      }
+      priceInfoObjects.push(priceInfoObjectId);
+    }
+
+    const clockObjectRef = tx.sharedObjectRef({
+      objectId: SUI_CLOCK_OBJECT_ID,
+      mutable: false,
+      initialSharedVersion: '1',
+    });
+
+    for (let i = 0; i < priceInfoObjects.length; i++) {
+      const priceInfoObjectId = priceInfoObjects[i];
+      [priceUpdatesHotPotato] = tx.moveCall({
+        target: `${scallopSponsorPackage}::pyth_sponsor::update_single_price_feed_with_sponsor`,
+        arguments: [
+          tx.object(this.pythStateId),
+          priceUpdatesHotPotato,
+          tx.object(priceInfoObjectId),
+          tx.object(gasStationId),
+          clockObjectRef,
+        ],
+      });
+    }
+
+    tx.moveCall({
+      target: `${packageId}::hot_potato_vector::destroy`,
+      arguments: [priceUpdatesHotPotato],
+      typeArguments: [`${packageId}::price_info::PriceInfo`],
+    });
+  }
+}
+
+export const updatePythPriceFeeds = async (
+  builder: ScallopBuilder,
+  assetCoinNames: string[],
+  txBlock: SuiKitTxBlock,
+  isSponsoredTx: boolean = false
+) => {
+  const pythClient = new ScallopPythClient(
+    builder.suiKit.client,
+    builder.address.get('core.oracles.pyth.state'),
+    builder.address.get('core.oracles.pyth.wormholeState'),
+    {
+      defaultPackageId:
+        '0xa6f9bec2f9748656b6af8aafb5d7bc1a0d5faf25ac9645fc7f447822cd509325',
+      gasStationId:
+        '0xa8b8dcc9880166edb57b53e05f8df7364d31b5d9b7d107fd27f0b69cf338b687',
+    }
+  );
+  const priceIds = assetCoinNames.map((assetCoinName) =>
+    builder.address.get(`core.coins.${assetCoinName}.oracle.pyth.feed`)
+  );
+
+  const endpoints = builder.utils.pythEndpoints ?? [
+    ...builder.constants.whitelist.pythEndpoints,
+  ];
+
+  // iterate through the endpoints
+  for (const endpoint of endpoints) {
+    try {
+      const pythConnection = new SuiPriceServiceConnection(endpoint);
+      const priceUpdateData =
+        await pythConnection.getPriceFeedsUpdateData(priceIds);
+
+      if (isSponsoredTx) {
+        // Use gas station to sponsor the baseFeeUpdate
+        await pythClient.updatePriceFeedsWithSponsoredBaseUpdateFee(
+          txBlock.txBlock,
+          priceUpdateData,
+          priceIds
+        );
+      } else {
+        await pythClient.updatePriceFeeds(
+          txBlock.txBlock,
+          priceUpdateData,
+          priceIds
+        );
+      }
+
+      return;
+    } catch (e) {
+      console.warn(
+        `Failed to update price feeds with endpoint ${endpoint}: ${e}`
+      );
+    }
+  }
+};

package/src/builders/referralBuilder.ts

@@ -1,5 +1,5 @@
 import { ScallopBuilder } from 'src/models';
-import { ScallopTxBlock } from 'src/types/builder';
+import { ScallopTxBlock } from 'src/types';
 import {
   SUI_CLOCK_OBJECT_ID,
   SuiTxBlock as SuiKitTxBlock,
@@ -13,7 +13,7 @@ import {
   ReferralTxBlock,
   SuiTxBlockWithReferralNormalMethods,
 } from 'src/types/builder/referral';
-import { requireSender } from './utils';
+import { requireSender } from 'src/utils';
 
 const generateReferralNormalMethod: GenerateReferralNormalMethod = ({
   builder,
@@ -111,16 +111,10 @@ const generateReferralQuickMethod: GenerateReferralQuickMethod = ({
       const objToTransfer: SuiObjectArg[] = [];
       for (const coinName of coinNames) {
         if (coinName === 'sui') {
-          const rewardCoin = await txBlock.claimReferralRevenue(
-            veScaKey,
-            coinName
-          );
+          const rewardCoin = txBlock.claimReferralRevenue(veScaKey, coinName);
           objToTransfer.push(rewardCoin);
         } else {
-          const rewardCoin = await txBlock.claimReferralRevenue(
-            veScaKey,
-            coinName
-          );
+          const rewardCoin = txBlock.claimReferralRevenue(veScaKey, coinName);
           try {
             // get the matching user coin if exists
             const coins = await builder.suiKit.suiInteractor.selectCoins(

package/src/builders/sCoinBuilder.ts

@@ -8,8 +8,8 @@ import {
   ScallopTxBlock,
   SuiTxBlockWithSCoinNormalMethods,
   sCoinPkgIds,
-} from 'src/types/builder';
-import { requireSender } from './utils';
+} from 'src/types';
+import { requireSender } from 'src/utils';
 
 const generateSCoinNormalMethod: GenerateSCoinNormalMethod = ({
   builder,