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

package/src/builders/oracles/xOracleUpdateStrategy.ts

@@ -1,178 +0,0 @@
-import {
-  SUI_CLOCK_OBJECT_ID,
-  SuiTxBlock,
-  TransactionArgument,
-} from '@scallop-io/sui-kit';
-import { IOraclePackageRegistry } from './oraclePackageRegistry';
-import {
-  SupportedOracleSuiLst,
-  SupportOracleType,
-  xOracleRuleType,
-} from 'src/types/constant';
-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)]
-    );
-  }
-}

package/src/builders/oracles/xOracleUpdater.ts

@@ -1,160 +0,0 @@
-import { SuiTxBlock, TransactionArgument } from '@scallop-io/sui-kit';
-import { SupportOracleType, xOracleRuleType } from 'src/types/constant';
-import { SUPPORT_SUI_LST } from 'src/constants/xoracle';
-import { IOraclePackageRegistry } from './oraclePackageRegistry';
-import {
-  IXOracleUpdateStrategy,
-  PythDefaultUpdateStrategy,
-  PythSuiLstUpdateStrategy,
-  SupraDefaultUpdateStrategy,
-  SwitchboardDefaultUpdateStrategy,
-} from './xOracleUpdateStrategy';
-import { UnsupportedLstOracleError } from './error';
-
-export interface IXOracleUpdater<
-  T extends SupportOracleType = SupportOracleType,
-> {
-  oracleName: T; // e.g. 'pyth', 'supra', 'switchboard'
-  updateXOracle(
-    coinName: string,
-    rule: xOracleRuleType,
-    request: TransactionArgument
-  ): void;
-}
-
-abstract class BaseXOracleUpdater<
-  T extends SupportOracleType = SupportOracleType,
-> implements IXOracleUpdater
-{
-  protected strategies: Map<string, IXOracleUpdateStrategy<T>>;
-  abstract readonly oracleName: T;
-
-  constructor(
-    protected readonly tx: SuiTxBlock,
-    protected readonly registry: IOraclePackageRegistry<T>,
-    listStrategies: Record<string, IXOracleUpdateStrategy<T>>
-  ) {
-    this.strategies = new Map(Object.entries(listStrategies));
-  }
-
-  abstract updateXOracle(
-    coinName: string,
-    rule: xOracleRuleType,
-    request: TransactionArgument
-  ): void;
-}
-
-class PythXOracleUpdater extends BaseXOracleUpdater<'pyth'> {
-  readonly oracleName = 'pyth';
-  protected readonly SUPPORT_SUI_LST_SET: Set<string> = new Set(
-    SUPPORT_SUI_LST
-  );
-
-  constructor(tx: SuiTxBlock, registry: IOraclePackageRegistry<'pyth'>) {
-    super(tx, registry, {
-      default: new PythDefaultUpdateStrategy(registry),
-      sui_lst: new PythSuiLstUpdateStrategy(registry),
-    });
-  }
-
-  private resolveStrategy(
-    coinName: string
-  ): IXOracleUpdateStrategy<typeof this.oracleName> {
-    // decide which key to look up in this.strategies
-    let key: string;
-
-    if (this.SUPPORT_SUI_LST_SET.has(coinName)) {
-      key = 'sui_lst';
-    }
-    // else if (this.WALRUS_LST_SET.has(coinName)) {
-    //   key = 'walrus_lst';
-    // }
-    else {
-      key = 'default';
-    }
-
-    const strat = this.strategies.get(key);
-    if (!strat) {
-      // guard if you forgot to register default or list strategies
-      throw new UnsupportedLstOracleError(coinName, this.oracleName);
-    }
-
-    return strat as IXOracleUpdateStrategy<typeof this.oracleName>;
-  }
-
-  updateXOracle(
-    coinName: string,
-    rule: xOracleRuleType,
-    request: TransactionArgument
-  ): void {
-    const strategy = this.resolveStrategy(coinName);
-    strategy.updatePrice(this.tx, request, coinName, rule);
-  }
-}
-
-class SupraXOracleUpdater extends BaseXOracleUpdater<'supra'> {
-  readonly oracleName = 'supra';
-
-  constructor(tx: SuiTxBlock, registry: IOraclePackageRegistry<'supra'>) {
-    super(tx, registry, {
-      default: new SupraDefaultUpdateStrategy(registry), // Placeholder, implement Supra strategy
-    });
-  }
-
-  updateXOracle(
-    coinName: string,
-    rule: xOracleRuleType,
-    request: TransactionArgument
-  ): void {
-    const stragtegy = this.strategies.get('default');
-    stragtegy?.updatePrice(this.tx, request, coinName, rule);
-  }
-}
-
-class SwitchboardXOracleUpdater extends BaseXOracleUpdater<'switchboard'> {
-  readonly oracleName = 'switchboard';
-  constructor(tx: SuiTxBlock, registry: IOraclePackageRegistry<'switchboard'>) {
-    super(tx, registry, {
-      // Placeholder, implement Switchboard strategy
-      default: new SwitchboardDefaultUpdateStrategy(registry),
-    });
-  }
-
-  updateXOracle(
-    coinName: string,
-    rule: xOracleRuleType,
-    request: TransactionArgument
-  ): void {
-    const stragtegy = this.strategies.get('default');
-    stragtegy?.updatePrice(this.tx, request, coinName, rule);
-  }
-}
-
-export const createXOracleUpdater = (
-  tx: SuiTxBlock,
-  registry: IOraclePackageRegistry
-) => {
-  const oracleType = registry.oracleName;
-  switch (oracleType) {
-    case 'pyth': {
-      return new PythXOracleUpdater(
-        tx,
-        registry as IOraclePackageRegistry<'pyth'>
-      );
-    }
-    case 'supra': {
-      return new SupraXOracleUpdater(
-        tx,
-        registry as IOraclePackageRegistry<'supra'>
-      );
-    }
-    case 'switchboard': {
-      return new SwitchboardXOracleUpdater(
-        tx,
-        registry as IOraclePackageRegistry<'switchboard'>
-      );
-    }
-    default:
-      throw new Error(`Unsupported oracle type: ${oracleType}`);
-  }
-};

package/src/constants/api.ts

@@ -1,2 +0,0 @@
-export const API_BASE_URL = 'https://sui.apis.scallop.io' as const;
-export const SDK_API_BASE_URL = 'https://sdk.api.scallop.io' as const;

package/src/models/utils.ts

@@ -1,97 +0,0 @@
-/**
- * Generic wrapper for methods with indexer fallback.
- *
- * @param method - The method to call with fallback behavior.
- * @param context - The context (`this`) of the class instance.
- * @param args - The arguments to pass to the method.
- * @returns The result of the method call.
- */
-export async function callMethodWithIndexerFallback(
-  method: Function,
-  context: any,
-  ...args: any[]
-) {
-  const lastArgs = args[args.length - 1]; // Assume last argument is always `indexer`
-
-  if (typeof lastArgs === 'object' && lastArgs.indexer) {
-    try {
-      return await method.apply(context, args);
-    } catch (e: any) {
-      console.warn(
-        `Indexer requests failed: ${e.message}. Retrying without indexer..`
-      );
-      return await method.apply(context, [
-        ...args.slice(0, -1),
-        {
-          ...lastArgs,
-          indexer: false,
-        },
-      ]);
-    }
-  }
-  return await method.apply(context, args);
-}
-
-/**
- * This function creates a wrapper for methods that have an indexer parameter.
- * It ensures fallback behavior if indexer fails.
- *
- * @param method - The method to wrap.
- * @returns A function that applies indexer fallback.
- */
-export function withIndexerFallback(method: Function) {
-  return (...args: any[]) => {
-    // @ts-ignore
-    return callMethodWithIndexerFallback(method, this, ...args); // Preserve `this` with arrow function
-  };
-}
-
-import { SuiTxBlock } from '@scallop-io/sui-kit';
-import { MAX_LOCK_DURATION } from 'src/constants/vesca';
-// import { ScallopConstants } from 'src/models/scallopConstants';
-
-/**
- * Find the closest unlock round timestamp (12AM) to the given unlock at timestamp in seconds.
- *
- * @param unlockAtInSecondTimestamp - Unlock at in seconds timestamp to find the closest round.
- * @returns Closest round (12AM) in seconds timestamp.
- */
-export const findClosestUnlockRound = (unlockAtInSecondTimestamp: number) => {
-  const unlockDate = new Date(unlockAtInSecondTimestamp * 1000);
-  const closestTwelveAM = new Date(unlockAtInSecondTimestamp * 1000);
-
-  closestTwelveAM.setUTCHours(0, 0, 0, 0); // Set the time to the next 12 AM UTC
-
-  // If the current time is past 12 AM, set the date to the next day
-  if (unlockDate.getUTCHours() >= 0) {
-    closestTwelveAM.setUTCDate(closestTwelveAM.getUTCDate() + 1);
-  }
-
-  const now = new Date().getTime();
-  // check if unlock period > 4 years
-  if (closestTwelveAM.getTime() - now > MAX_LOCK_DURATION * 1000) {
-    closestTwelveAM.setUTCDate(closestTwelveAM.getUTCDate() - 1);
-  }
-  return Math.floor(closestTwelveAM.getTime() / 1000);
-};
-
-export const parseUrl = (url: string) => {
-  if (url.endsWith('/')) {
-    url = url.slice(0, -1);
-  }
-  return url;
-};
-
-/**
- * Check and get the sender from the transaction block.
- *
- * @param txBlock - TxBlock created by SuiKit.
- * @return Sender of transaction.
- */
-export const requireSender = (txBlock: SuiTxBlock) => {
-  const sender = txBlock.blockData.sender;
-  if (!sender) {
-    throw new Error('Sender is required');
-  }
-  return sender;
-};

package/src/types/builder/type.ts

@@ -1,25 +0,0 @@
-import type { CoreTxBlock, NestedResult } from './core';
-import type { SpoolTxBlock } from './spool';
-import type { BorrowIncentiveTxBlock } from './borrowIncentive';
-import type { VeScaTxBlock } from './vesca';
-import type { ReferralTxBlock } from './referral';
-import type { LoyaltyProgramTxBlock } from './loyaltyProgram';
-import type { SCoinTxBlock } from './sCoin';
-
-export type BaseScallopTxBlock = ReferralTxBlock &
-  LoyaltyProgramTxBlock &
-  BorrowIncentiveTxBlock &
-  VeScaTxBlock;
-
-export type SuiTxBlockWithSCoin = BaseScallopTxBlock & SCoinTxBlock;
-export type SuiTxBlockWithSpool = SuiTxBlockWithSCoin & SpoolTxBlock;
-export type ScallopTxBlock = SuiTxBlockWithSpool & CoreTxBlock;
-
-export type SelectCoinReturnType<T extends string> = T extends 'sui'
-  ? {
-      takeCoin: NestedResult;
-    }
-  : {
-      takeCoin: NestedResult;
-      leftCoin: NestedResult;
-    };

package/src/types/constant/package.ts

@@ -1,16 +0,0 @@
-const _PACKAGE_NAMES = [
-  'coinDecimalsRegistry',
-  'math',
-  'whitelist',
-  'x',
-  'protocol',
-  'protocolWhitelist',
-  'query',
-  'supra',
-  'pyth',
-  'switchboard',
-  'xOracle',
-  'testCoin',
-] as const;
-
-export type PackageName = (typeof _PACKAGE_NAMES)[number];