@scallop-io/sui-scallop-sdk 3.0.2 → 4.1.0

package/src/repositories/price/helpers.ts

@@ -0,0 +1,237 @@
+import { SuiClientTypes } from '@mysten/sui/client';
+import {
+  PriceApiContext,
+  PriceIndexerContext,
+  PriceOnChainContext,
+} from './types.js';
+import { queryKeys } from 'src/constants/queryKeys.js';
+import { PriceFeedObjectSchema } from './schema.js';
+import { calculatePrice } from './utils.js';
+import { logError, type OnChainReadContext } from '../utils.js';
+import {
+  ScallopIndexerError,
+  ScallopParseError,
+  ScallopRpcError,
+} from 'src/errors/index.js';
+import { SuiPriceServiceConnection } from '@pythnetwork/pyth-sui-js';
+import type { SuiObjectData } from 'src/types/index.js';
+import { MarketCollateral, MarketPool } from '../market/types.js';
+import { partitionArray } from 'src/utils/array.js';
+
+export const getPythPricesFromApi = async (
+  ctx: PriceApiContext,
+  coinNames: string[]
+) => {
+  const {
+    fetchWithCache,
+    metadata: { addresses },
+    pythPriceServiceConfig: { endpoint, config },
+  } = ctx;
+
+  // Multiple coins can share the same feed — dedupe before hitting the API.
+  // A coin without a configured pyth feed maps to `undefined` and defaults to 0.
+  const feedIdByCoin = new Map<string, string | undefined>(
+    coinNames.map((coinName) => [
+      coinName,
+      addresses.coins[coinName]?.oracle?.pyth?.feed,
+    ])
+  );
+  const priceFeedIds = Array.from(new Set(feedIdByCoin.values())).filter(
+    (feedId): feedId is string => !!feedId
+  );
+
+  const client = new SuiPriceServiceConnection(endpoint, config);
+  const feeds = await client.getLatestPriceFeeds(priceFeedIds);
+  if (!feeds) {
+    throw logError(
+      ctx.logger,
+      new ScallopIndexerError('Failed to fetch price feeds from Pyth API', {
+        context: { endpoint, priceFeedIds },
+      })
+    );
+  }
+
+  return await fetchWithCache({
+    queryKey: queryKeys.oracle.getPythLatestPriceFeeds(endpoint, priceFeedIds),
+    queryFn: () => {
+      // Resolve each unique feed once, then fan back out to every coin.
+      const priceByFeedId = new Map<string, number>();
+      for (const feed of feeds) {
+        priceByFeedId.set(
+          feed.id,
+          feed.getPriceUnchecked().getPriceAsNumberUnchecked()
+        );
+      }
+
+      // A coin with no configured feed, or a feed the API didn't return,
+      // defaults to a price of 0 rather than throwing.
+      const prices: Record<string, number> = {};
+      for (const [coinName, feedId] of feedIdByCoin) {
+        prices[coinName] =
+          (feedId !== undefined ? priceByFeedId.get(feedId) : undefined) ?? 0;
+      }
+      return prices;
+    },
+  });
+};
+
+/**
+ * Fetch a single raw Pyth price-feed object by id (cached). Returns `null` when
+ * the object is absent. Parsing is left to the caller — this is the raw-object
+ * read the legacy `ScallopUtils.getPythPrice` did via `queryGetObject`.
+ */
+export const getPythFeedObjectFromOnChain = async (
+  ctx: OnChainReadContext,
+  feedObjectId: string
+): Promise<SuiObjectData | null> => {
+  const { onchain, fetchWithCache } = ctx;
+  const options: SuiClientTypes.GetObjectOptions<{ json: true }> = {
+    objectId: feedObjectId,
+    include: { json: true },
+  };
+  const { object } = await fetchWithCache({
+    queryKey: queryKeys.rpc.getObject({ ...options, node: onchain.url }),
+    queryFn: () => onchain.getObject(options),
+  });
+  return object ?? null;
+};
+
+/**
+ * Batch-fetch raw Pyth price-feed objects in ONE getObjects call (cached). The
+ * caller keys results by `objectId`, so per-object failures are dropped rather
+ * than positioned — matching the legacy `queryGetObjects`, which returned only
+ * the successfully-fetched objects.
+ */
+export const getPythFeedObjectsFromOnChain = async (
+  ctx: OnChainReadContext,
+  feedObjectIds: string[]
+): Promise<SuiObjectData[]> => {
+  if (feedObjectIds.length === 0) return [];
+  const { onchain, fetchWithCache } = ctx;
+  const options: SuiClientTypes.GetObjectsOptions<{ json: true }> = {
+    objectIds: feedObjectIds,
+    include: { json: true },
+  };
+  const { objects } = await fetchWithCache({
+    queryKey: queryKeys.rpc.getObjects({ ...options, node: onchain.url }),
+    queryFn: () => onchain.client.getObjects(options),
+  });
+  return objects.filter((o): o is SuiObjectData => !(o instanceof Error));
+};
+
+export const getPythPricesFromOnChain = async (
+  ctx: PriceOnChainContext,
+  coinNames: string[]
+) => {
+  const {
+    onchain,
+    fetchWithCache,
+    metadata: { addresses },
+  } = ctx;
+
+  // Multiple coins can share the same feed object — dedupe before fetching.
+  // A coin without a configured pyth feed object maps to an empty/undefined
+  // value and defaults to 0 (filtered out of the fetch below).
+  const feedObjectByCoin = new Map<string, string | undefined>(
+    coinNames.map((coinName) => [
+      coinName,
+      addresses.coins[coinName]?.oracle?.pyth?.feedObject,
+    ])
+  );
+  const feedObjectIds = Array.from(new Set(feedObjectByCoin.values())).filter(
+    (feedObject): feedObject is string => !!feedObject
+  );
+
+  // Parse each unique feed object once, keyed by its object id. getObjects
+  // supports at most 50 ids per call — batch in chunks of 50.
+  const priceByFeedObject = new Map<string, number>();
+  for (const batch of partitionArray(feedObjectIds, 50)) {
+    const fetchOptions: SuiClientTypes.GetObjectsOptions<{ json: true }> = {
+      objectIds: batch,
+      include: {
+        json: true,
+      },
+    };
+
+    const { objects: priceFeedObjects } = await fetchWithCache({
+      queryKey: queryKeys.rpc.getObjects({
+        ...fetchOptions,
+        node: onchain.url,
+      }),
+      queryFn: () => onchain.client.getObjects(fetchOptions),
+    });
+
+    for (const priceFeedObject of priceFeedObjects) {
+      if (priceFeedObject instanceof Error) {
+        throw logError(
+          ctx.logger,
+          new ScallopRpcError('Failed to fetch price feed object on chain', {
+            cause: priceFeedObject,
+          })
+        );
+      }
+
+      const { data, success } = PriceFeedObjectSchema.safeParse(
+        priceFeedObject.json
+      );
+      if (!success) {
+        throw logError(
+          ctx.logger,
+          new ScallopParseError('Failed to parse price feed object', {
+            context: {
+              objectId: priceFeedObject.objectId,
+              json: JSON.stringify(priceFeedObject.json),
+            },
+          })
+        );
+      }
+
+      const { price_feed } = data.price_info;
+      priceByFeedObject.set(
+        priceFeedObject.objectId,
+        calculatePrice(price_feed.price).toNumber()
+      );
+    }
+  }
+
+  // Fan the unique feed-object prices back out to every requested coin.
+  // A coin with no feed object, or one missing on chain, defaults to 0.
+  const prices: Record<string, number> = {};
+  for (const [coinName, feedObject] of feedObjectByCoin) {
+    prices[coinName] =
+      (feedObject !== undefined
+        ? priceByFeedObject.get(feedObject)
+        : undefined) ?? 0;
+  }
+  return prices;
+};
+
+export const getPricesFromIndexer = async (
+  ctx: PriceIndexerContext,
+  {
+    coinNames,
+  }: {
+    coinNames: string[];
+  }
+) => {
+  const { indexer, fetchWithCache } = ctx;
+  const path = '/api/market/migrate';
+
+  const resp = await fetchWithCache<{
+    pools: MarketPool[];
+    collaterals: MarketCollateral[];
+  }>({
+    queryKey: queryKeys.api.getMarkets(),
+    queryFn: () => indexer.get(path),
+  });
+
+  return resp.pools.reduce(
+    (acc, pool) => {
+      if (coinNames.includes(pool.coinName)) {
+        acc[pool.coinName] = pool.coinPrice;
+      }
+      return acc;
+    },
+    {} as Record<string, number>
+  );
+};

package/src/repositories/price/index.ts

@@ -0,0 +1,91 @@
+/**
+ * Pyth prices
+ * indexer coin prices
+ * all coin prices
+ * price update policies
+ * asset oracle config
+ * switchboard aggregator ids
+ */
+
+import { IndexerDataSource } from 'src/datasources/indexer.js';
+import { OnChainDataSource } from 'src/datasources/onchain.js';
+import { BaseRepository } from '../base.js';
+import { QuerySource, runWithDataSourceFallback } from '../utils.js';
+import { DEFAULT_PYTH_URL } from './const.js';
+import {
+  getPricesFromIndexer,
+  getPythFeedObjectFromOnChain,
+  getPythFeedObjectsFromOnChain,
+  getPythPricesFromApi,
+  getPythPricesFromOnChain,
+} from './helpers.js';
+import {
+  PriceApiConfig,
+  PriceRepositoryParams,
+  PriceRepositoryContext,
+  PriceRepositoryMetadata,
+} from './types.js';
+
+export class PriceRepository extends BaseRepository<
+  PriceRepositoryContext,
+  PriceRepositoryMetadata
+> {
+  private readonly config: PriceApiConfig;
+  private readonly indexer: IndexerDataSource;
+  private readonly onchain: OnChainDataSource;
+
+  constructor({
+    pythPriceServiceConfig,
+    indexer,
+    onchain,
+    ...params
+  }: PriceRepositoryParams) {
+    super(params);
+    this.config = pythPriceServiceConfig ?? {
+      endpoint: DEFAULT_PYTH_URL,
+      config: {
+        timeout: 4_000,
+        httpRetries: 1,
+      },
+    };
+    this.indexer = indexer;
+    this.onchain = onchain;
+  }
+
+  get context() {
+    return {
+      ...this.baseContext,
+      onchain: this.onchain,
+      indexer: this.indexer,
+      pythPriceServiceConfig: this.config,
+    };
+  }
+
+  getPricesFromPyth({
+    coinNames,
+    source = 'api-first',
+  }: {
+    coinNames: string[];
+    source?: QuerySource;
+  }) {
+    return runWithDataSourceFallback({
+      source,
+      label: 'PriceRepository.getPriceFromPyth',
+      logger: this.logger,
+      api: () => getPythPricesFromApi(this.context, coinNames),
+      onchain: () => getPythPricesFromOnChain(this.context, coinNames),
+    });
+  }
+
+  getPythFeedObject(feedObjectId: string) {
+    return getPythFeedObjectFromOnChain(this.context, feedObjectId);
+  }
+
+  getPythFeedObjects(feedObjectIds: string[]) {
+    return getPythFeedObjectsFromOnChain(this.context, feedObjectIds);
+  }
+
+  getPricesFromIndexer(args: { coinNames: string[] }) {
+    return getPricesFromIndexer(this.context, args);
+  }
+}

package/src/repositories/price/schema.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+
+export const PriceFeedObjectSchema = z.object({
+  id: z.string(),
+  price_info: z.object({
+    arrival_time: z.string(),
+    attestation_time: z.string(),
+    price_feed: z.object({
+      ema_price: z.object({
+        conf: z.string(),
+        expo: z.object({ magnitude: z.string(), negative: z.boolean() }),
+        price: z.object({ magnitude: z.string(), negative: z.boolean() }),
+        timestamp: z.string(),
+      }),
+      price: z.object({
+        conf: z.string(),
+        expo: z.object({ magnitude: z.string(), negative: z.boolean() }),
+        price: z.object({ magnitude: z.string(), negative: z.boolean() }),
+        timestamp: z.string(),
+      }),
+      price_identifier: z.object({ bytes: z.string() }),
+    }),
+  }),
+});

package/src/repositories/price/types.ts

@@ -0,0 +1,56 @@
+import { AddressesInterface } from 'src/types/address.js';
+import { BaseContext, BaseRepoParams } from '../types.js';
+import { PriceServiceConnectionConfig } from '@pythnetwork/pyth-sui-js';
+import { IndexerDataSource } from 'src/datasources/indexer.js';
+import { OnChainDataSource } from 'src/datasources/onchain.js';
+
+// Derived from the canonical `core.coins` value shape (single source of truth for
+// the per-coin oracle/treasury config). Kept as a dense `Record` (the schema's is
+// `Partial`) via `NonNullable`, preserving the repo's "coin is present" contract.
+export type CoinsAddresses = {
+  coins: Record<
+    string,
+    NonNullable<AddressesInterface['core']['coins'][string]>
+  >;
+};
+
+export type PriceRepositoryMetadata = {
+  addresses: CoinsAddresses;
+};
+
+export type PriceApiConfig = {
+  endpoint: string;
+  config: PriceServiceConnectionConfig;
+};
+
+export type PriceRepositoryContext = BaseContext & {
+  metadata: PriceRepositoryMetadata;
+  onchain: OnChainDataSource;
+  indexer: IndexerDataSource;
+  pythPriceServiceConfig: PriceApiConfig;
+};
+
+export type PriceRepositoryParams = BaseRepoParams & {
+  onchain: OnChainDataSource;
+  indexer: IndexerDataSource;
+  metadata: PriceRepositoryMetadata;
+  pythPriceServiceConfig?: PriceApiConfig;
+};
+
+/** Minimal context for the Pyth API price read. */
+export type PriceApiContext = Pick<
+  PriceRepositoryContext,
+  'fetchWithCache' | 'metadata' | 'pythPriceServiceConfig' | 'logger'
+>;
+
+/** Minimal context for the on-chain Pyth feed-object price read. */
+export type PriceOnChainContext = Pick<
+  PriceRepositoryContext,
+  'onchain' | 'fetchWithCache' | 'metadata' | 'logger'
+>;
+
+/** Minimal context for the indexer coin-price read. */
+export type PriceIndexerContext = Pick<
+  PriceRepositoryContext,
+  'indexer' | 'fetchWithCache'
+>;

package/src/repositories/price/utils.ts

@@ -0,0 +1,21 @@
+import { BigNumber } from 'bignumber.js';
+
+export const calculatePrice = ({
+  price,
+  expo,
+}: {
+  price: {
+    magnitude: string;
+    negative: boolean;
+  };
+  expo: {
+    magnitude: string;
+    negative: boolean;
+  };
+}) => {
+  const expoSign = expo.negative ? -1 : 1;
+  const priceSign = price.negative ? -1 : 1;
+  return BigNumber(price.magnitude)
+    .multipliedBy(BigNumber(10).shiftedBy(expoSign * +expo.magnitude))
+    .multipliedBy(priceSign);
+};

package/src/repositories/referral/bcs.ts

@@ -0,0 +1,3 @@
+import { bcs } from '@mysten/sui/bcs';
+
+export const ReferrerVeScaKeyBcs = bcs.Address;

package/src/repositories/referral/helper.ts

@@ -0,0 +1,24 @@
+import { SuiClientTypes } from '@mysten/sui/client';
+import { getDynamicFieldOrNull } from '../utils.js';
+import { ReferralBindingContext } from './types.js';
+import { encodeDynamicFieldNameForV2 } from 'src/utils/dynamicField.js';
+import { ReferrerVeScaKeyBcs } from './bcs.js';
+
+export const getVeScaKeyIdFromRefBindingsFromOnChain = async (
+  ctx: ReferralBindingContext,
+  refereeAddress: string
+) => {
+  const {
+    metadata: { addresses },
+  } = ctx;
+  const fetchOptions: SuiClientTypes.GetDynamicFieldOptions = {
+    parentId: addresses.referral.bindingTableId,
+    name: encodeDynamicFieldNameForV2({
+      type: 'address',
+      value: refereeAddress,
+    }),
+  };
+  const result = await getDynamicFieldOrNull(ctx, fetchOptions);
+  if (!result) return null;
+  return ReferrerVeScaKeyBcs.parse(result.dynamicField.value.bcs);
+};

package/src/repositories/referral/index.ts

@@ -0,0 +1,31 @@
+import { BaseRepository } from '../base.js';
+import { OnChainDataSource } from 'src/datasources/onchain.js';
+import { getVeScaKeyIdFromRefBindingsFromOnChain } from './helper.js';
+import {
+  ReferralRepoParams,
+  ReferralRepoContext,
+  ReferralRepoMetadata,
+} from './types.js';
+
+export class ReferralRepository extends BaseRepository<
+  ReferralRepoContext,
+  ReferralRepoMetadata
+> {
+  private readonly onchain: OnChainDataSource;
+
+  constructor({ onchain, ...params }: ReferralRepoParams) {
+    super(params);
+    this.onchain = onchain;
+  }
+
+  get context() {
+    return { ...this.baseContext, onchain: this.onchain };
+  }
+
+  getVeScaKeyIdFromReferralBindings(refereeAddress: string) {
+    return getVeScaKeyIdFromRefBindingsFromOnChain(
+      this.context,
+      refereeAddress
+    );
+  }
+}

package/src/repositories/referral/types.ts

@@ -0,0 +1,33 @@
+import { AddressesInterface } from 'src/types/address.js';
+import { BaseContext, BaseRepoParams } from '../types.js';
+import { OnChainDataSource } from 'src/datasources/onchain.js';
+
+type ReferralAddresses<
+  T extends keyof AddressesInterface['referral'] =
+    keyof AddressesInterface['referral'],
+> = {
+  referral: Pick<AddressesInterface['referral'], T>;
+};
+
+export type ReferralRepoMetadata = {
+  addresses: ReferralAddresses<'bindingTableId'>;
+};
+
+export type ReferralRepoContext = BaseContext & {
+  onchain: OnChainDataSource;
+  metadata: ReferralRepoMetadata;
+};
+export type ReferralRepoParams = BaseRepoParams & {
+  onchain: OnChainDataSource;
+  metadata: ReferralRepoMetadata;
+};
+
+/**
+ * Narrowed context for `getVeScaKeyIdFromRefBindingsFromOnChain`: it reads only
+ * `metadata.addresses.referral.bindingTableId`, plus the `onchain` /
+ * `fetchWithCache` fields it forwards to `getDynamicFieldOrNull`.
+ */
+export type ReferralBindingContext = BaseContext & {
+  onchain: OnChainDataSource;
+  metadata: { addresses: ReferralAddresses<'bindingTableId'> };
+};

package/src/repositories/spool/const.ts

@@ -0,0 +1 @@
+export const YEAR_IN_SECONDS = 365 * 24 * 60 * 60; // 1 year in seconds