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

package/src/builders/oracles/oraclePackageRegistry.ts

@@ -0,0 +1,323 @@
+import { TransactionArgument } from '@scallop-io/sui-kit';
+import { ScallopUtils } from 'src/models';
+import {
+  AddressStringPath,
+  BasePackage,
+  OracleLst,
+  OracleLstConfig,
+  SupportedOracleSuiLst,
+  SupportOracleLst,
+  SupportOracleType,
+} from 'src/types';
+import { UnsupportedOracleError } from './error';
+
+export type XOraclePackages = {
+  xOraclePackageId: string;
+  xOracleId: TransactionArgument | string;
+};
+
+type LstPackages<
+  T extends SupportOracleLst,
+  U extends SupportedOracleSuiLst = SupportedOracleSuiLst,
+> = {
+  [K in U]: OracleLst<T, U>[K] & BasePackage;
+};
+
+type MaybeWithLstPackage<T, U> = T extends SupportOracleLst
+  ? U & { lst: LstPackages<T> }
+  : U;
+
+type PythStaticPackages = {
+  pythPackageId: string;
+  pythRegistryId: TransactionArgument | string;
+  pythStateId: TransactionArgument | string;
+};
+
+type PythDynamicPackages = MaybeWithLstPackage<
+  'pyth',
+  {
+    pythFeedObjectId: TransactionArgument | string;
+  }
+>;
+
+export type PythPackages = PythStaticPackages & PythDynamicPackages;
+
+type SwitchboardStaticPackages = {
+  switchboardPackageId: string;
+  switchboardRegistryId: TransactionArgument | string;
+};
+
+type SwitchboardDynamicPackages = MaybeWithLstPackage<
+  'switchboard',
+  {
+    switchboardAggregatorId: TransactionArgument | string;
+  }
+>;
+
+export type SwitchboardPackages = SwitchboardStaticPackages &
+  SwitchboardDynamicPackages;
+
+export type SupraPackages = {
+  supraPackageId: string;
+  supraHolderId: TransactionArgument | string;
+  supraRegistryId: TransactionArgument | string;
+};
+
+export type OraclePackages<T extends SupportOracleType> = T extends 'pyth'
+  ? PythPackages
+  : T extends 'switchboard'
+    ? SwitchboardPackages
+    : T extends 'supra'
+      ? SupraPackages
+      : never;
+
+type getLstPackagesReturnType<T> = T extends SupportOracleLst
+  ? LstPackages<T, SupportedOracleSuiLst>
+  : never;
+
+export interface IOraclePackageRegistry<
+  T extends SupportOracleType = SupportOracleType,
+> {
+  utils: ScallopUtils;
+  oracleName: T;
+  packageId: string;
+  getLstPackages(coinName: SupportedOracleSuiLst): getLstPackagesReturnType<T>;
+  getPackages(coinName: string): OraclePackages<T>;
+}
+
+interface IHasStaticPackages {
+  getStaticPackages: Record<string, TransactionArgument | string>;
+}
+
+export class XOraclePackageRegistry
+  implements
+    Omit<
+      IOraclePackageRegistry,
+      'oracleName' | 'packageId' | 'getPackages' | 'getLstPackages'
+    >
+{
+  constructor(readonly utils: ScallopUtils) {}
+
+  getAddressPath(path: AddressStringPath) {
+    return this.utils.address.get(path);
+  }
+
+  get getXOraclePackages() {
+    return {
+      xOraclePackageId: this.getAddressPath('core.packages.xOracle.id'),
+      xOracleId: this.getAddressPath('core.oracles.xOracle'),
+    };
+  }
+}
+
+abstract class BasePackageRegistry implements IOraclePackageRegistry {
+  abstract readonly oracleName: SupportOracleType;
+
+  constructor(
+    protected readonly xOraclePackageRegistry: XOraclePackageRegistry
+  ) {}
+
+  abstract getPackages(
+    coinName: string
+  ): OraclePackages<typeof this.oracleName>;
+
+  abstract getLstPackages(
+    coinName: SupportedOracleSuiLst
+  ): getLstPackagesReturnType<typeof this.oracleName>;
+
+  get utils() {
+    return this.xOraclePackageRegistry.utils;
+  }
+
+  get packageId() {
+    return this.xOraclePackageRegistry.getAddressPath(
+      `core.packages.${this.oracleName}.id`
+    );
+  }
+}
+
+class PythPackageRegistry
+  extends BasePackageRegistry
+  implements IHasStaticPackages
+{
+  readonly oracleName = 'pyth';
+
+  constructor(
+    protected readonly xOraclePackageRegistry: XOraclePackageRegistry
+  ) {
+    super(xOraclePackageRegistry);
+  }
+
+  get getStaticPackages() {
+    return {
+      pythPackageId: this.packageId,
+      pythRegistryId: this.xOraclePackageRegistry.getAddressPath(
+        'core.oracles.pyth.registry'
+      ),
+      pythStateId: this.xOraclePackageRegistry.getAddressPath(
+        'core.oracles.pyth.state'
+      ),
+    };
+  }
+
+  private getLstOracleConfigPackages(coinName: SupportedOracleSuiLst) {
+    const oracleLstConfig = this.xOraclePackageRegistry.getAddressPath(
+      `core.oracles.pyth.lst.${coinName}`
+    ) as OracleLstConfig<typeof coinName>[typeof coinName];
+    return oracleLstConfig;
+  }
+
+  getLstPackages(coinName: SupportedOracleSuiLst) {
+    const lstPackages = this.xOraclePackageRegistry.getAddressPath(
+      `core.packages.pyth.lst.${coinName}`
+    ) as BasePackage;
+
+    // get the oracle config for the coin
+    const oracleLstConfig = this.getLstOracleConfigPackages(coinName);
+    return {
+      [coinName]: {
+        ...lstPackages,
+        ...oracleLstConfig,
+      },
+    };
+  }
+
+  getPackages(coinName: string): OraclePackages<'pyth'> {
+    const lstPackages = this.getLstPackages(coinName as SupportedOracleSuiLst);
+
+    return {
+      ...this.getStaticPackages,
+      pythFeedObjectId: this.xOraclePackageRegistry.getAddressPath(
+        `core.coins.${coinName}.oracle.pyth.feedObject`
+      ),
+      lst: lstPackages,
+    };
+  }
+}
+
+class SupraPackageRegistry extends BasePackageRegistry {
+  readonly oracleName = 'supra';
+
+  constructor(
+    protected readonly xOraclePackageRegistry: XOraclePackageRegistry
+  ) {
+    super(xOraclePackageRegistry);
+  }
+
+  getLstPackages(
+    _: SupportedOracleSuiLst
+  ): getLstPackagesReturnType<typeof this.oracleName> {
+    throw new Error('Method not implemented.');
+  }
+
+  getPackages(_: string) {
+    return {
+      supraPackageId: this.packageId,
+      supraRegistryId: this.xOraclePackageRegistry.getAddressPath(
+        'core.oracles.supra.registry'
+      ),
+      supraHolderId: this.xOraclePackageRegistry.getAddressPath(
+        'core.oracles.supra.holder'
+      ),
+    } as OraclePackages<typeof this.oracleName>;
+  }
+}
+
+class SwitchboardPackageRegistry
+  extends BasePackageRegistry
+  implements IHasStaticPackages
+{
+  readonly oracleName = 'switchboard';
+
+  constructor(
+    protected readonly xOraclePackageRegistry: XOraclePackageRegistry
+  ) {
+    super(xOraclePackageRegistry);
+  }
+
+  getLstPackages(
+    _: SupportedOracleSuiLst
+  ): getLstPackagesReturnType<typeof this.oracleName> {
+    throw new Error('Method not implemented.');
+  }
+
+  get getStaticPackages() {
+    return {
+      switchboardPackageId: this.packageId,
+      switchboardRegistryId: this.xOraclePackageRegistry.getAddressPath(
+        'core.oracles.switchboard.registry'
+      ),
+    };
+  }
+
+  getPackages(coinName: string) {
+    return {
+      ...this.getStaticPackages,
+      switchboardAggregatorId: this.xOraclePackageRegistry.getAddressPath(
+        `core.coins.${coinName}.oracle.switchboard`
+      ),
+    } as OraclePackages<typeof this.oracleName>;
+  }
+}
+
+export class OraclePackageRegistry {
+  private readonly registryMap = new Map<
+    SupportOracleType,
+    IOraclePackageRegistry
+  >();
+
+  constructor(readonly xOraclePackageRegistry: XOraclePackageRegistry) {}
+
+  /**
+   * Register a new updater (pyth, supra, switchboard)
+   */
+  register(
+    cb: (
+      xOraclePackageRegistry: XOraclePackageRegistry
+    ) => IOraclePackageRegistry
+  ): void {
+    const registry = cb(this.xOraclePackageRegistry);
+    if (this.registryMap.has(registry.oracleName)) {
+      throw new Error(
+        `Updater already registered for oracleKey: ${registry.oracleName}`
+      );
+    }
+    this.registryMap.set(registry.oracleName, registry);
+  }
+
+  /**
+   * Retrieve the handler by key; throws if missing
+   */
+  get(oracleName: SupportOracleType): IOraclePackageRegistry {
+    const handler = this.registryMap.get(oracleName);
+    if (!handler) {
+      throw new Error(
+        `No XOraclePriceUpdater registered for oracle: ${oracleName}`
+      );
+    }
+    return handler;
+  }
+
+  /**
+   * Optional: Check if a handler exists for the given key
+   */
+  has(oracleName: SupportOracleType): boolean {
+    return this.registryMap.has(oracleName);
+  }
+}
+
+export const createPackageRegistry = (
+  oracleName: SupportOracleType,
+  xOraclePackageRegistry: XOraclePackageRegistry
+): IOraclePackageRegistry => {
+  switch (oracleName) {
+    case 'pyth':
+      return new PythPackageRegistry(xOraclePackageRegistry);
+    case 'supra':
+      return new SupraPackageRegistry(xOraclePackageRegistry);
+    case 'switchboard':
+      return new SwitchboardPackageRegistry(xOraclePackageRegistry);
+    default:
+      throw new UnsupportedOracleError(oracleName);
+  }
+};

package/src/builders/oracles/priceFeedUpdater.ts

@@ -0,0 +1,112 @@
+import {
+  SuiPriceServiceConnection,
+  SuiPythClient,
+} from '@pythnetwork/pyth-sui-js';
+import { SuiTxBlock } from '@scallop-io/sui-kit';
+import { ScallopBuilder } from 'src/models';
+import { SupportOracleType } from 'src/types';
+
+type PythPriceFeedUpdateOptions = {
+  usePythPullModel: boolean;
+  useOnChainXOracleList: boolean;
+  pythSponsoredFeeds: string[];
+};
+
+type SupraPriceFeedUpdateOptions = {};
+type SwitchboardPriceFeedUpdateOptions = {};
+
+export type PriceFeedUpdateOptions = PythPriceFeedUpdateOptions &
+  SupraPriceFeedUpdateOptions &
+  SwitchboardPriceFeedUpdateOptions;
+
+export interface IPriceFeedUpdater {
+  oracleName: SupportOracleType;
+  updatePriceFeeds(): Promise<void>;
+}
+
+class PythPriceFeedUpdater implements IPriceFeedUpdater {
+  public readonly oracleName: SupportOracleType = 'pyth';
+
+  constructor(
+    public readonly tx: SuiTxBlock,
+    private readonly builder: ScallopBuilder,
+    private readonly coinNames: string[],
+    private readonly options: {
+      usePythPullModel: boolean;
+      useOnChainXOracleList: boolean;
+      pythSponsoredFeeds: string[];
+    }
+  ) {}
+
+  private filterSponsoredFeeds() {
+    const { usePythPullModel, pythSponsoredFeeds } = this.options;
+    const sponsoredFeedsSet = new Set(pythSponsoredFeeds);
+
+    return this.coinNames.filter((coinName) => {
+      const notUsingPullAndNotSponsored =
+        !usePythPullModel && !sponsoredFeedsSet.has(coinName);
+      return usePythPullModel || notUsingPullAndNotSponsored;
+    });
+  }
+
+  async updatePriceFeeds(): Promise<void> {
+    const pythClient = new SuiPythClient(
+      this.builder.suiKit.client,
+      this.builder.address.get('core.oracles.pyth.state'),
+      this.builder.address.get('core.oracles.pyth.wormholeState')
+    );
+    const filteredCoinNames = this.filterSponsoredFeeds();
+    if (filteredCoinNames.length === 0) {
+      return;
+    }
+    const priceIds = filteredCoinNames.map((assetCoinName) =>
+      this.builder.address.get(`core.coins.${assetCoinName}.oracle.pyth.feed`)
+    );
+
+    // iterate through the endpoints
+    const endpoints = this.builder.utils.pythEndpoints ?? [
+      ...this.builder.constants.whitelist.pythEndpoints,
+    ];
+    for (const endpoint of endpoints) {
+      try {
+        const pythConnection = new SuiPriceServiceConnection(endpoint);
+        const priceUpdateData =
+          await pythConnection.getPriceFeedsUpdateData(priceIds);
+        await pythClient.updatePriceFeeds(
+          this.tx.txBlock,
+          priceUpdateData,
+          priceIds
+        );
+
+        break;
+      } catch (e) {
+        console.warn(
+          `Failed to update price feeds with endpoint ${endpoint}: ${e}`
+        );
+      }
+    }
+  }
+}
+
+export const createPriceFeedUpdater = (
+  oracleName: SupportOracleType,
+  tx: SuiTxBlock,
+  builder: ScallopBuilder,
+  coinNames: string[],
+  options: {
+    usePythPullModel: boolean;
+    useOnChainXOracleList: boolean;
+    pythSponsoredFeeds: string[];
+  }
+) => {
+  switch (oracleName) {
+    case 'pyth':
+      return new PythPriceFeedUpdater(tx, builder, coinNames, options);
+    case 'supra':
+      throw new Error('Supra price feed updater is not implemented yet.');
+    case 'switchboard':
+      throw new Error('Switchboard price feed updater is not implemented yet.');
+    default:
+      throw new Error(`Unsupported oracle type: ${oracleName}`);
+  }
+};

package/src/builders/oracles/priceUpdateRequester.ts

@@ -0,0 +1,50 @@
+import {
+  SUI_CLOCK_OBJECT_ID,
+  SuiTxBlock,
+  TransactionArgument,
+} from '@scallop-io/sui-kit';
+import { XOraclePackageRegistry } from './oraclePackageRegistry';
+
+interface IPriceUpdateRequester {
+  buildRequest(coinName: string): TransactionArgument;
+  confirmRequest(coinName: string, request: TransactionArgument): void;
+}
+
+export class PriceUpdateRequester implements IPriceUpdateRequester {
+  constructor(
+    private readonly txBlock: SuiTxBlock,
+    private readonly xOraclePackageRegistry: XOraclePackageRegistry
+  ) {}
+
+  get utils() {
+    return this.xOraclePackageRegistry.utils;
+  }
+
+  buildRequest(coinName: string): TransactionArgument {
+    const { xOraclePackageId, xOracleId } =
+      this.xOraclePackageRegistry.getXOraclePackages;
+    const target = `${xOraclePackageId}::x_oracle::price_update_request`;
+    const typeArgs = [this.utils.parseCoinType(coinName)];
+    return this.txBlock.moveCall(target, [xOracleId], typeArgs);
+  }
+
+  confirmRequest(coinName: string, request: TransactionArgument): void {
+    const { xOraclePackageId, xOracleId } =
+      this.xOraclePackageRegistry.getXOraclePackages;
+    const target = `${xOraclePackageId}::x_oracle::confirm_price_update_request`;
+    const typeArgs = [this.utils.parseCoinType(coinName)];
+    this.txBlock.moveCall(
+      target,
+      [
+        xOracleId,
+        request,
+        this.txBlock.sharedObjectRef({
+          objectId: SUI_CLOCK_OBJECT_ID,
+          mutable: false,
+          initialSharedVersion: '1',
+        }),
+      ],
+      typeArgs
+    );
+  }
+}

package/src/builders/oracles/xOracleUpdateStrategy.ts

@@ -0,0 +1,178 @@
+import {
+  SUI_CLOCK_OBJECT_ID,
+  SuiTxBlock,
+  TransactionArgument,
+} from '@scallop-io/sui-kit';
+import { IOraclePackageRegistry } from './oraclePackageRegistry';
+import {
+  SupportedOracleSuiLst,
+  SupportOracleType,
+  xOracleRuleType,
+} from 'src/types';
+import { UnsupportedLstOracleError } from './error';
+
+export interface IXOracleUpdateStrategy<
+  T extends SupportOracleType,
+  U extends string = string,
+> {
+  oracleType: T;
+  updatePrice(
+    tx: SuiTxBlock,
+    request: TransactionArgument,
+    coinName: U,
+    rule: xOracleRuleType
+  ): void;
+}
+
+abstract class BaseUpdateStrategy<
+  T extends SupportOracleType,
+  U extends string = string,
+> implements IXOracleUpdateStrategy<T, U>
+{
+  constructor(protected readonly registry: IOraclePackageRegistry<T>) {}
+  abstract readonly oracleType: T;
+
+  protected get clockObject() {
+    return {
+      objectId: SUI_CLOCK_OBJECT_ID,
+      mutable: false,
+      initialSharedVersion: '1',
+    };
+  }
+
+  protected get utils() {
+    return this.registry.utils;
+  }
+
+  abstract updatePrice(
+    tx: SuiTxBlock,
+    request: TransactionArgument,
+    coinName: string,
+    rule: xOracleRuleType
+  ): void;
+}
+
+export class PythDefaultUpdateStrategy extends BaseUpdateStrategy<'pyth'> {
+  readonly oracleType = 'pyth';
+  constructor(protected readonly registry: IOraclePackageRegistry<'pyth'>) {
+    super(registry);
+  }
+
+  updatePrice(
+    tx: SuiTxBlock,
+    request: TransactionArgument,
+    coinName: string,
+    rule: xOracleRuleType
+  ): void {
+    const { pythFeedObjectId, pythRegistryId, pythStateId, pythPackageId } =
+      this.registry.getPackages(coinName);
+    tx.moveCall(
+      `${pythPackageId}::rule::set_price_as_${rule}`,
+      [
+        request,
+        pythStateId,
+        pythFeedObjectId,
+        pythRegistryId,
+        tx.sharedObjectRef({
+          objectId: SUI_CLOCK_OBJECT_ID,
+          mutable: false,
+          initialSharedVersion: '1',
+        }),
+      ],
+      [this.utils.parseCoinType(coinName)]
+    );
+  }
+}
+export class PythSuiLstUpdateStrategy extends BaseUpdateStrategy<
+  'pyth',
+  SupportedOracleSuiLst
+> {
+  readonly oracleType = 'pyth';
+  constructor(protected readonly registry: IOraclePackageRegistry<'pyth'>) {
+    super(registry);
+  }
+
+  updatePrice(
+    tx: SuiTxBlock,
+    request: TransactionArgument,
+    coinName: SupportedOracleSuiLst,
+    rule: xOracleRuleType
+  ): void {
+    const { lst, pythFeedObjectId, pythStateId } =
+      this.registry.getPackages(coinName);
+    if (!lst[coinName]) {
+      throw new UnsupportedLstOracleError(coinName, this.oracleType);
+    }
+    const { id, configId, stakedSuiVaultId, safeId } = lst[coinName];
+    tx.moveCall(`${id}::rule::set_price_as_${rule}`, [
+      request,
+      pythStateId,
+      pythFeedObjectId,
+      configId,
+      stakedSuiVaultId,
+      safeId,
+      tx.sharedObjectRef(this.clockObject),
+    ]);
+  }
+}
+
+export class SupraDefaultUpdateStrategy extends BaseUpdateStrategy<'supra'> {
+  readonly oracleType = 'supra';
+  constructor(protected readonly registry: IOraclePackageRegistry<'supra'>) {
+    super(registry);
+  }
+
+  updatePrice(
+    tx: SuiTxBlock,
+    request: TransactionArgument,
+    coinName: string,
+    rule: xOracleRuleType
+  ): void {
+    const { supraPackageId, supraHolderId, supraRegistryId } =
+      this.registry.getPackages(coinName);
+
+    tx.moveCall(
+      `${supraPackageId}::rule::set_price_as_${rule}`,
+      [
+        request,
+        supraHolderId,
+        supraRegistryId,
+        tx.sharedObjectRef(this.clockObject),
+      ],
+      [this.utils.parseCoinType(coinName)]
+    );
+  }
+}
+
+export class SwitchboardDefaultUpdateStrategy extends BaseUpdateStrategy<'switchboard'> {
+  readonly oracleType = 'switchboard';
+  constructor(
+    protected readonly registry: IOraclePackageRegistry<'switchboard'>
+  ) {
+    super(registry);
+  }
+
+  updatePrice(
+    tx: SuiTxBlock,
+    request: TransactionArgument,
+    coinName: string,
+    rule: xOracleRuleType
+  ): void {
+    const {
+      switchboardPackageId,
+      switchboardAggregatorId,
+      switchboardRegistryId,
+    } = this.registry.getPackages(coinName);
+
+    tx.moveCall(
+      `${switchboardPackageId}::rule::set_price_as_${rule}`,
+      [
+        request,
+        switchboardAggregatorId,
+        switchboardRegistryId,
+        tx.sharedObjectRef(this.clockObject),
+      ],
+      [this.utils.parseCoinType(coinName)]
+    );
+  }
+}