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

package/src/types/builder/index.ts

@@ -1,7 +1,23 @@
+import type { CoreTxBlock } from './core';
+import type { SpoolTxBlock } from './spool';
+import type { BorrowIncentiveTxBlock } from './borrowIncentive';
+import type { VeScaTxBlock } from './vesca';
+import type { ReferralTxBlock } from './referral';
+import { LoyaltyProgramTxBlock } from './loyaltyProgram';
+import { SCoinTxBlock } from './sCoin';
+
 export type * from './core';
 export type * from './spool';
 export type * from './borrowIncentive';
 export type * from './vesca';
 export type * from './loyaltyProgram';
 export type * from './sCoin';
-export type * from './type';
+
+export type BaseScallopTxBlock = ReferralTxBlock &
+  LoyaltyProgramTxBlock &
+  BorrowIncentiveTxBlock &
+  VeScaTxBlock;
+
+export type SuiTxBlockWithSCoin = BaseScallopTxBlock & SCoinTxBlock;
+export type SuiTxBlockWithSpool = SuiTxBlockWithSCoin & SpoolTxBlock;
+export type ScallopTxBlock = SuiTxBlockWithSpool & CoreTxBlock;

package/src/types/constant/enum.ts

@@ -0,0 +1,64 @@
+export type Coins = {
+  [K in string]: K;
+};
+
+export type AssetCoins = {
+  [K in string]: K;
+};
+
+export type MarketCoins = {
+  [K in string]: K;
+};
+
+export type SCoins = {
+  [K in string]: K;
+};
+
+export type StakeMarketCoins = {
+  [K in string]: K;
+};
+
+export type StakeRewardCoins = {
+  [key in string]: string;
+};
+
+export type SuiBridgeCoins = {
+  [K in string]: K;
+};
+
+export type BorrowIncentiveRewardCoins = {
+  [key in string]: string[];
+};
+
+export type AssetCoinIds = {
+  [key in string]: string;
+};
+
+export type SCoinIds = {
+  [key in string]: string;
+};
+
+export type SCoinTreasuryCaps = {
+  [key in string]: string;
+};
+
+export type SCoinConverterTreasury = {
+  [key in string]: string;
+};
+
+type PickFromUnion<T, K extends string> = K extends T ? K : never;
+
+export type WormholeCoinIds = {
+  [key in PickFromUnion<
+    string,
+    'weth' | 'wbtc' | 'wusdc' | 'wusdt' | 'wapt' | 'wsol'
+  >]: string;
+};
+
+export type VoloCoinIds = {
+  [key in PickFromUnion<string, 'vsui'>]: string;
+};
+
+export type SuiBridgedCoinPackageIds = {
+  [key in string]: string;
+};

package/src/types/constant/index.ts

@@ -1,4 +1,3 @@
 export type * from './common';
-export type * from './queryKeys';
+export type * from './enum';
 export type * from './xOracle';
-export type * from './package';

package/src/types/constant/xOracle.ts

@@ -1,15 +1,12 @@
-import {
-  SUPPORT_ORACLES,
-  X_ORACLE_RULES,
-  SUPPORT_SUI_LST,
-} from 'src/constants/xoracle';
+export const _SUPPORT_ORACLES = ['supra', 'switchboard', 'pyth'] as const;
+export type SupportOracleType = (typeof _SUPPORT_ORACLES)[number];
 
-export type SupportOracleType = (typeof SUPPORT_ORACLES)[number];
-export type xOracleRuleType = (typeof X_ORACLE_RULES)[number];
-
-export type xOracleRules = Record<xOracleRuleType, SupportOracleType[]>;
+export type xOracleRules = {
+  primary: SupportOracleType[];
+  secondary: SupportOracleType[];
+};
+export type xOracleRuleType = keyof xOracleRules;
 
 export type xOracleListType = {
   [key in string]: xOracleRules;
 };
-export type SupportedOracleSuiLst = (typeof SUPPORT_SUI_LST)[number];

package/src/types/index.ts

@@ -2,4 +2,4 @@ export type * from './builder';
 export type * from './constant';
 export type * from './query';
 export type * from './address';
-export type * from './util';
+export type * from './utils';

package/src/types/query/core.ts

@@ -293,6 +293,9 @@ export interface MarketQueryInterface {
     liquidationFactor: {
       value: string;
     };
+    // liquidationPenalty: {
+    //   value: string;
+    // };
     liquidationPanelty: {
       value: string;
     };

package/src/types/query/index.ts

@@ -2,5 +2,6 @@ export type * from './borrowIncentive';
 export type * from './core';
 export type * from './loyaltyProgram';
 export type * from './portfolio';
+export type * from './sCoin';
 export type * from './spool';
 export type * from './vesca';

package/src/types/query/sCoin.ts

@@ -0,0 +1 @@
+export type sCoinBalance = number;

package/src/{builders/utils.ts → utils/builder.ts}

@@ -5,7 +5,7 @@ import {
   MAX_LOCK_ROUNDS,
   MIN_INITIAL_LOCK_AMOUNT,
   MIN_TOP_UP_AMOUNT,
-} from 'src/constants/vesca';
+} from 'src/constants';
 import type { SuiObjectArg } from '@scallop-io/sui-kit';
 
 /**

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);
-  }
-};