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

package/src/utils/core.ts

@@ -0,0 +1,18 @@
+import { SuiObjectData } from '@mysten/sui/client';
+
+export const parseObjectAs = <T>(object: SuiObjectData): T => {
+  if (!(object && object.content && 'fields' in object.content))
+    throw new Error(`Failed to parse object ${object}`);
+
+  const fields = object.content.fields as any;
+
+  if (typeof fields === 'object' && 'value' in fields) {
+    const value = fields.value;
+    if (typeof value === 'object' && 'fields' in value)
+      return value.fields as T;
+    return value as T;
+  } else if (typeof fields === 'object') {
+    return fields as T;
+  }
+  return fields as T;
+};

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+export * from './builder';
+export * from './query';
+export * from './util';
+export * from './indexer';
+export * from './core';

package/src/utils/indexer.ts

@@ -0,0 +1,47 @@
+/**
+ * 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
+  };
+}

package/src/{queries/utils.ts → utils/query.ts}

@@ -1,7 +1,7 @@
 import BigNumber from 'bignumber.js';
 import { normalizeStructTag } from '@mysten/sui/utils';
-import type { ScallopUtils } from 'src/models';
-import {
+import type { ScallopUtils } from '../models';
+import type {
   OriginMarketPoolData,
   ParsedMarketPoolData,
   CalculatedMarketPoolData,
@@ -14,17 +14,16 @@ import {
   OriginSpoolRewardPoolData,
   ParsedSpoolRewardPoolData,
   CalculatedSpoolRewardPoolData,
-  OriginBorrowIncentivePoolPointData,
-  ParsedBorrowIncentivePoolPointData,
   OriginBorrowIncentivePoolData,
   ParsedBorrowIncentivePoolData,
+  OriginBorrowIncentiveAccountData,
+  ParsedBorrowIncentiveAccountData,
+  OriginBorrowIncentivePoolPointData,
+  ParsedBorrowIncentivePoolPointData,
   CalculatedBorrowIncentivePoolPointData,
   OriginBorrowIncentiveAccountPoolData,
   ParsedBorrowIncentiveAccountPoolData,
-  OriginBorrowIncentiveAccountData,
-  ParsedBorrowIncentiveAccountData,
-} from 'src/types/query';
-import { SuiObjectData } from '@mysten/sui/client';
+} from '../types';
 
 /**
  *  Parse origin market pool data to a more readable format.
@@ -643,20 +642,3 @@ export const estimatedFactor = (
 
   return adjustFactor;
 };
-
-export const parseObjectAs = <T>(object: SuiObjectData): T => {
-  if (!(object && object.content && 'fields' in object.content))
-    throw new Error(`Failed to parse object ${object}`);
-
-  const fields = object.content.fields as any;
-
-  if (typeof fields === 'object' && 'value' in fields) {
-    const value = fields.value;
-    if (typeof value === 'object' && 'fields' in value)
-      return value.fields as T;
-    return value as T;
-  } else if (typeof fields === 'object') {
-    return fields as T;
-  }
-  return fields as T;
-};

package/src/utils/util.ts

@@ -0,0 +1,42 @@
+import { MAX_LOCK_DURATION } from 'src/constants';
+// 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 partitionArray = <T>(array: T[], chunkSize: number) => {
+  const result: T[][] = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+};
+
+export const parseUrl = (url: string) => {
+  if (url.endsWith('/')) {
+    url = url.slice(0, -1);
+  }
+  return url;
+};

package/src/builders/oracles/error.ts

@@ -1,18 +0,0 @@
-/**
- * Thrown when someone asks for an oracle type we haven’t onboarded yet.
- */
-class UnsupportedOracleError extends Error {
-  constructor(oracle: string) {
-    super(`Unsupported oracle type: ${oracle}`);
-    this.name = 'UnsupportedOracleError';
-  }
-}
-
-class UnsupportedLstOracleError extends Error {
-  constructor(lst: string, oracle: string) {
-    super(`Unsupported LST oracle update for: ${lst} with oracle: ${oracle}`);
-    this.name = 'UnsupportedLstOracleError';
-  }
-}
-
-export { UnsupportedOracleError, UnsupportedLstOracleError };

package/src/builders/oracles/oraclePackageRegistry.ts

@@ -1,336 +0,0 @@
-import { TransactionArgument } from '@scallop-io/sui-kit';
-import { ScallopUtils } from 'src/models';
-import {
-  AddressStringPath,
-  BasePackage,
-  PythOracleLstConfig,
-  SupportOracleLst,
-} from 'src/types/address';
-import { UnsupportedOracleError } from './error';
-import { SupportedOracleSuiLst, SupportOracleType } from 'src/types/constant';
-import { SUPPORT_SUI_LST } from 'src/constants';
-
-export type XOraclePackages = {
-  xOraclePackageId: string;
-  xOracleId: TransactionArgument | string;
-};
-
-type RecordValueType<T> = T extends Record<any, infer V> ? V : never;
-
-export type PythLstPackages<T extends SupportedOracleSuiLst> = RecordValueType<
-  PythOracleLstConfig<T>
-> &
-  BasePackage;
-
-type MaybeWithLstPackage<T, U> = T extends SupportOracleLst
-  ? T extends 'pyth'
-    ? U & { lst: PythLstPackages<SupportedOracleSuiLst> }
-    : never
-  : 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 = SupportOracleType> =
-  T extends 'pyth'
-    ? PythPackages
-    : T extends 'switchboard'
-      ? SwitchboardPackages
-      : T extends 'supra'
-        ? SupraPackages
-        : never;
-
-type getLstPackagesReturnType<
-  T extends SupportOracleType,
-  U extends SupportedOracleSuiLst = SupportedOracleSuiLst,
-> = T extends 'pyth' ? PythLstPackages<U> : never;
-
-const PYTH_LST_PATHS: Record<SupportedOracleSuiLst, AddressStringPath> = {
-  afsui: 'core.oracles.pyth.lst.afsui',
-  hasui: 'core.oracles.pyth.lst.hasui',
-};
-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 path = PYTH_LST_PATHS[coinName];
-    if (path) {
-      return this.xOraclePackageRegistry.getAddressPath(path);
-    }
-  }
-
-  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 {
-      ...lstPackages,
-      ...oracleLstConfig,
-    };
-  }
-
-  private resolvePythFeedForSuiLst(coinName: string) {
-    if (SUPPORT_SUI_LST.includes(coinName as any)) {
-      return 'sui';
-    }
-    return coinName;
-  }
-
-  getPackages(coinName: string) {
-    const lstPackages = this.getLstPackages(coinName as SupportedOracleSuiLst);
-
-    return {
-      ...this.getStaticPackages,
-      pythFeedObjectId: this.xOraclePackageRegistry.getAddressPath(
-        `core.coins.${this.resolvePythFeedForSuiLst(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'
-      ),
-    };
-  }
-}
-
-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

@@ -1,112 +0,0 @@
-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/constant';
-
-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

@@ -1,50 +0,0 @@
-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
-    );
-  }
-}