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

package/src/repositories/wiring/datasources.ts

@@ -0,0 +1,42 @@
+import { ClientWithCoreApi } from '@mysten/sui/client';
+import { API_BASE_URL, SDK_API_BASE_URL } from 'src/constants/api.js';
+import { ApiDataSource } from 'src/datasources/api.js';
+import { IndexerDataSource } from 'src/datasources/indexer.js';
+import { OnChainDataSource } from 'src/datasources/onchain.js';
+
+/**
+ * The on-chain datasource is the only repo datasource that needs to be instantiated with a client,
+ * since it needs to call on-chain methods that require a client. The indexer and API datasources
+ * are just thin wrappers around fetch, so they don't need a client and can be instantiated with
+ * just a URL (which defaults to the appropriate base URL if not provided).
+ */
+export const createOnChainDataSource = (
+  client: ClientWithCoreApi,
+  url: string, // for cache keys
+  options?: { tokensPerSecond?: number }
+): OnChainDataSource =>
+  new OnChainDataSource({
+    // new-gen transport methods (getObjects/simulateTransaction/…) live on `.core`
+    client: client.core,
+    url,
+    // The datasource is now the single rate-limit point for every repo read
+    // (the old ScallopSuiKit query path is gone).
+    tokensPerSecond: options?.tokensPerSecond,
+  });
+
+/**
+ * The indexer base URL defaults to `SDK_API_BASE_URL` inside `IndexerDataSource`.
+ * Pass `url` only to point at a non-default indexer.
+ */
+export const createIndexerDataSource = (
+  url: string = SDK_API_BASE_URL
+): IndexerDataSource => new IndexerDataSource({ url });
+
+/**
+ * Plain Scallop API datasource (defaults to `API_BASE_URL`, distinct from the
+ * indexer base). Injected into repos that read the public API rather than the
+ * indexer (e.g. `poolAddresses`). Pass `url` to override.
+ */
+export const createApiDataSource = (
+  url: string = API_BASE_URL
+): ApiDataSource => new ApiDataSource({ url });

package/src/repositories/wiring/metadata.ts

@@ -0,0 +1,292 @@
+import type ScallopUtils from 'src/models/scallopUtils/index.js';
+import type {
+  MarketRepoAddressConfig,
+  MarketRepoMetadata,
+} from '../market/types.js';
+import type { CoinBalanceMetadata } from '../coinBalance/types.js';
+import type { FlashloanMetadata } from '../flashloan/types.js';
+import type { ObligationRepoMetadata } from '../obligation/types.js';
+import type { BorrowIncentiveMetadata } from '../borrowIncentive/types.js';
+import type { ReferralRepoMetadata } from '../referral/types.js';
+import type { PriceRepositoryMetadata } from '../price/types.js';
+import type { PoolAddressesRepoMetadata } from '../poolAddresses/types.js';
+import type { IsolatedAssetsMetadata } from '../isolatedAssets/types.js';
+import type { VeScaRepoMetadata } from '../veSca/types.js';
+import type { LoyaltyProgramRepoMetadata } from '../loyaltyProgram/types.js';
+import type { VeScaLoyaltyProgramRepoMetadata } from '../veScaLoyaltyProgram/types.js';
+import type { XOracleMetadata } from '../xOracle/types.js';
+import type { SpoolMetadata } from '../spool/types.js';
+import { SUPPORTED_ORACLES } from '../xOracle/const.js';
+import { ScallopConfigError } from 'src/errors/index.js';
+
+/**
+ * The ONE seam between the SDK models (`ScallopUtils` / `ScallopConstants`) and
+ * the pure repositories layer. Each `buildXMetadata` is a pure function that
+ * projects the model surface into the plain data + bound helper functions a repo
+ * expects. Repos never import the models — everything they need flows through here.
+ *
+ * Helpers are arrow-wrapped (not passed by reference) so they keep ScallopUtils'
+ * `this` binding. Address ids come from `utils.address.get(path)` — paths mirror
+ * the ones the old query layer used.
+ */
+
+export const buildMarketMetadata = (
+  utils: ScallopUtils
+): MarketRepoMetadata => ({
+  whitelist: {
+    lending: utils.constants.whitelist.lending,
+    collateral: utils.constants.whitelist.collateral,
+  },
+  poolAddresses: utils.constants.poolAddresses,
+  parseCoinNameFromType: (coinType) => utils.parseCoinNameFromType(coinType),
+  parseCoinType: (coinName) => utils.parseCoinType(coinName),
+  parseSymbol: (coinName) => utils.parseSymbol(coinName),
+  parseMarketCoinType: (coinName) => utils.parseMarketCoinType(coinName),
+  parseMarketCoinName: (coinName) => utils.parseMarketCoinName(coinName),
+  parseSCoinType: (sCoinName) => utils.parseSCoinType(sCoinName),
+  getCoinWrappedType: (coinName) => utils.getCoinWrappedType(coinName),
+  getCoinDecimal: (coinName) => utils.getCoinDecimal(coinName),
+  parseAprToApy: (apr) => utils.parseAprToApy(apr),
+});
+
+export const buildMarketAddresses = (
+  utils: ScallopUtils
+): MarketRepoAddressConfig => ({
+  queryPackageId: utils.address.get('core.packages.query.id'),
+  market: utils.address.get('core.market'),
+});
+
+export const buildCoinBalanceMetadata = (
+  utils: ScallopUtils
+): CoinBalanceMetadata => {
+  const addresses = utils.address.getAddresses();
+  if (!addresses) {
+    throw new ScallopConfigError(
+      'Addresses are not initialized; call init() before building repositories'
+    );
+  }
+  return {
+    whitelist: {
+      lending: utils.constants.whitelist.lending,
+      scoin: utils.constants.whitelist.scoin,
+    },
+    addresses: {
+      scoin: addresses.scoin,
+    },
+    parseCoinType: (coinName) => utils.parseCoinType(coinName),
+    parseSCoinType: (sCoinName) => utils.parseSCoinType(sCoinName),
+    parseMarketCoinType: (coinName) => utils.parseMarketCoinType(coinName),
+    parseSCoinNameFromType: (sCoinType) =>
+      utils.parseSCoinNameFromType(sCoinType),
+    parseUnderlyingSCoinType: (sCoinName) =>
+      utils.parseUnderlyingSCoinType(sCoinName),
+    getSCoinTreasury: (sCoinName) => utils.getSCoinTreasury(sCoinName),
+    getCoinDecimal: (coinName) => utils.getCoinDecimal(coinName),
+    parseCoinName: (marketCoinName) => utils.parseCoinName(marketCoinName),
+  };
+};
+
+export const buildFlashloanMetadata = (
+  utils: ScallopUtils
+): FlashloanMetadata => {
+  const entries = Object.entries(utils.constants.coinTypeToCoinNameMap).filter(
+    (entry): entry is [string, string] => entry[1] !== undefined
+  );
+  return { coinTypeToCoinNameMap: new Map(entries) };
+};
+
+export const buildObligationMetadata = (
+  utils: ScallopUtils
+): ObligationRepoMetadata => ({
+  addresses: {
+    protocolObjectId: utils.address.get('core.object'),
+    queryPackageId: utils.address.get('core.packages.query.id'),
+    version: utils.address.get('core.version'),
+    market: utils.address.get('core.market'),
+  },
+});
+
+export const buildBorrowIncentiveMetadata = (
+  utils: ScallopUtils
+): BorrowIncentiveMetadata => {
+  const addresses = utils.address.getAddresses();
+  if (!addresses) {
+    throw new ScallopConfigError(
+      'Addresses are not initialized; call init() before building repositories'
+    );
+  }
+  return {
+    whitelist: { lending: utils.constants.whitelist.lending },
+    addresses: {
+      borrowIncentive: addresses.borrowIncentive,
+      core: { object: utils.address.get('core.object') },
+      vesca: { object: utils.address.get('vesca.object') },
+    },
+    parseCoinNameFromType: (coinType) => utils.parseCoinNameFromType(coinType),
+    parseSymbol: (coinName) => utils.parseSymbol(coinName),
+    getCoinDecimal: (coinName) => utils.getCoinDecimal(coinName),
+  };
+};
+
+export const buildReferralMetadata = (
+  utils: ScallopUtils
+): ReferralRepoMetadata => ({
+  addresses: {
+    referral: {
+      bindingTableId: utils.address.get('referral.bindingTableId'),
+    },
+  },
+});
+
+export const buildPriceMetadata = (
+  utils: ScallopUtils
+): PriceRepositoryMetadata => {
+  const addresses = utils.address.getAddresses();
+  if (!addresses) {
+    throw new ScallopConfigError(
+      'Addresses are not initialized; call init() before building repositories'
+    );
+  }
+  // Keep only present coins (drop undefined entries) to satisfy the repo's
+  // dense `core.coins` contract.
+  const coins = Object.fromEntries(
+    Object.entries(addresses.core.coins).filter(
+      (entry): entry is [string, NonNullable<(typeof entry)[1]>] =>
+        entry[1] !== undefined
+    )
+  );
+  return { addresses: { coins } };
+};
+
+export const buildPoolAddressesMetadata = (
+  utils: ScallopUtils
+): PoolAddressesRepoMetadata => {
+  const addresses = utils.address.getAddresses();
+  if (!addresses) {
+    throw new ScallopConfigError(
+      'Addresses are not initialized; call init() before building repositories'
+    );
+  }
+  return {
+    addresses: {
+      core: { coins: addresses.core.coins, market: addresses.core.market },
+      spool: { pools: addresses.spool.pools },
+      scoin: { coins: addresses.scoin.coins },
+    },
+  };
+};
+
+export const buildIsolatedAssetsMetadata = (
+  utils: ScallopUtils
+): IsolatedAssetsMetadata => ({
+  addresses: { market: utils.address.get('core.market') },
+  poolAddresses: utils.constants.poolAddresses,
+  whitelist: { lending: utils.constants.whitelist.lending },
+});
+
+export const buildVeScaMetadata = (utils: ScallopUtils): VeScaRepoMetadata => ({
+  addresses: {
+    veSca: {
+      id: utils.address.get('vesca.id'),
+      config: utils.address.get('vesca.config'),
+      tableId: utils.address.get('vesca.tableId'),
+      object: utils.address.get('vesca.object'),
+      treasury: utils.address.get('vesca.treasury'),
+    },
+  },
+});
+
+export const buildLoyaltyProgramMetadata = (
+  utils: ScallopUtils
+): LoyaltyProgramRepoMetadata => ({
+  addresses: {
+    loyaltyProgram: {
+      rewardPool: utils.address.get('loyaltyProgram.rewardPool'),
+    },
+  },
+});
+
+export const buildVeScaLoyaltyProgramMetadata = (
+  utils: ScallopUtils
+): VeScaLoyaltyProgramRepoMetadata => {
+  const addresses = utils.address.getAddresses();
+  if (!addresses) {
+    throw new ScallopConfigError(
+      'Addresses are not initialized; call init() before building repositories'
+    );
+  }
+  return {
+    addresses: {
+      veSca: { tableId: addresses.vesca.tableId },
+      veScaLoyaltyProgram: {
+        veScaRewardPool: addresses.veScaLoyaltyProgram.veScaRewardPool,
+        veScaRewardTableId: addresses.veScaLoyaltyProgram.veScaRewardTableId,
+      },
+    },
+  };
+};
+
+export const buildSpoolMetadata = (utils: ScallopUtils): SpoolMetadata => ({
+  whitelist: { spool: utils.constants.whitelist.spool },
+  addresses: {
+    spoolObjectId: utils.address.get('spool.object'),
+    // dense map over the spool whitelist (market-coin names) → pool object ids
+    spools: [...utils.constants.whitelist.spool].reduce(
+      (acc, name) => {
+        acc[name] = {
+          id: utils.address.get(`spool.pools.${name}.id`),
+          rewardPoolId: utils.address.get(`spool.pools.${name}.rewardPoolId`),
+        };
+        return acc;
+      },
+      {} as Record<string, { id: string; rewardPoolId: string }>
+    ),
+  },
+  poolAddresses: utils.constants.poolAddresses,
+  parseCoinName: (marketCoinName) => utils.parseCoinName(marketCoinName),
+  parseSymbol: (coinName) => utils.parseSymbol(coinName),
+  parseCoinType: (coinName) => utils.parseCoinType(coinName),
+  parseMarketCoinType: (coinName) => utils.parseMarketCoinType(coinName),
+  parseSCoinType: (sCoinName) => utils.parseSCoinType(sCoinName),
+  isMarketCoin: (coinName) => utils.isMarketCoin(coinName),
+  getCoinDecimal: (coinName) => utils.getCoinDecimal(coinName) ?? 0,
+  getSpoolRewardCoinName: () => utils.getSpoolRewardCoinName(),
+});
+
+export const buildXOracleMetadata = (utils: ScallopUtils): XOracleMetadata => ({
+  addresses: {
+    // per-oracle package object ids (projection from core.packages.<oracle>.object)
+    ...SUPPORTED_ORACLES.reduce(
+      (acc, oracle) => {
+        acc[oracle] = {
+          object: utils.address.get(`core.packages.${oracle}.object`),
+        };
+        return acc;
+      },
+      {} as Record<(typeof SUPPORTED_ORACLES)[number], { object: string }>
+    ),
+    xOracleObject: utils.address.get('core.packages.xOracle.object'),
+    oracles: {
+      primaryPriceUpdatePolicyVecsetId: utils.address.get(
+        'core.oracles.primaryPriceUpdatePolicyVecsetId'
+      ),
+      secondaryPriceUpdatePolicyVecsetId: utils.address.get(
+        'core.oracles.secondaryPriceUpdatePolicyVecsetId'
+      ),
+      primaryPriceUpdatePolicyObject: utils.address.get(
+        'core.oracles.primaryPriceUpdatePolicyObject'
+      ),
+      secondaryPriceUpdatePolicyObject: utils.address.get(
+        'core.oracles.secondaryPriceUpdatePolicyObject'
+      ),
+      switchboardRegistryTableId: utils.address.get(
+        'core.oracles.switchboard.registryTableId'
+      ),
+    },
+  },
+  whitelist: { lending: utils.constants.whitelist.lending },
+  parseCoinNameFromType: (type) => utils.parseCoinNameFromType(type),
+  parseCoinType: (coinName) => utils.parseCoinType(coinName),
+  getSwitchboardAggAddress: (coinName) =>
+    utils.address.get(`core.coins.${coinName}.oracle.switchboard`),
+});

package/src/repositories/wiring/registry.ts

@@ -0,0 +1,194 @@
+import type ScallopUtils from 'src/models/scallopUtils/index.js';
+import { QueryClient, QueryClientConfig } from '@tanstack/query-core';
+import type { Logger } from 'src/logger/index.js';
+import { createApiDataSource, createIndexerDataSource } from './datasources.js';
+import {
+  buildBorrowIncentiveMetadata,
+  buildReferralMetadata,
+  buildPriceMetadata,
+  buildPoolAddressesMetadata,
+  buildCoinBalanceMetadata,
+  buildFlashloanMetadata,
+  buildIsolatedAssetsMetadata,
+  buildLoyaltyProgramMetadata,
+  buildMarketAddresses,
+  buildMarketMetadata,
+  buildObligationMetadata,
+  buildSpoolMetadata,
+  buildVeScaLoyaltyProgramMetadata,
+  buildVeScaMetadata,
+  buildXOracleMetadata,
+} from './metadata.js';
+import { MarketRepository } from '../market/index.js';
+import { CoinBalanceRepository } from '../coinBalance/index.js';
+import { FlashloanRepository } from '../flashloan/index.js';
+import { ObligationRepository } from '../obligation/index.js';
+import { BorrowIncentiveRepository } from '../borrowIncentive/index.js';
+import { IsolatedAssetsRepository } from '../isolatedAssets/index.js';
+import { VeScaRepository } from '../veSca/index.js';
+import { LoyaltyProgramRepository } from '../loyaltyProgram/index.js';
+import { XOracleRepository } from '../xOracle/index.js';
+import { SpoolRepository } from '../spool/index.js';
+import { VeScaLoyaltyProgramRepository } from '../veScaLoyaltyProgram/index.js';
+import { ReferralRepository } from '../referral/index.js';
+import { PoolAddressesRepository } from '../poolAddresses/index.js';
+import { PriceRepository } from '../price/index.js';
+import { DEFAULT_CACHE_OPTIONS } from 'src/constants/cache.js';
+
+/**
+ * Inputs the registry needs. `ScallopUtils` is the single hub — it exposes
+ * `onchain`, `queryClient`, `logger`, `address`, and `constants`, so the
+ * registry can derive every datasource + metadata bundle
+ * from it.
+ */
+export type RepositoryDeps = {
+  utils: ScallopUtils;
+  queryClient?: QueryClient; // Optional override for the utils query client
+  queryClientConfig?: QueryClientConfig; // Optional override for the utils query client config
+  /** Override the indexer base URL; defaults to the Scallop indexer. */
+  indexerUrl?: string;
+};
+
+/**
+ * The set of wired domain repositories. Every domain below is wired into the
+ * facade — `ScallopQuery` delegates each read to `repos.<domain>`.
+ */
+export interface Repositories {
+  readonly market: MarketRepository;
+  readonly coinBalance: CoinBalanceRepository;
+  readonly flashloan: FlashloanRepository;
+  readonly obligation: ObligationRepository;
+  readonly borrowIncentive: BorrowIncentiveRepository;
+  readonly isolatedAssets: IsolatedAssetsRepository;
+  readonly veSca: VeScaRepository;
+  readonly loyaltyProgram: LoyaltyProgramRepository;
+  readonly xOracle: XOracleRepository;
+  readonly spool: SpoolRepository;
+  readonly veScaLoyaltyProgram: VeScaLoyaltyProgramRepository;
+  readonly referral: ReferralRepository;
+  readonly price: PriceRepository;
+  readonly poolAddresses: PoolAddressesRepository;
+}
+
+/**
+ * Build the repository registry from the SDK models. Repos are constructed
+ * lazily (on first access) and memoised, so unused domains cost nothing and
+ * metadata is built at most once per domain.
+ */
+export const createRepositories = (deps: RepositoryDeps): Repositories => {
+  const { utils, indexerUrl, queryClientConfig = DEFAULT_CACHE_OPTIONS } = deps;
+
+  const onchain = utils.onchain;
+  const indexer = createIndexerDataSource(indexerUrl);
+  const queryClient: QueryClient =
+    deps.queryClient ?? new QueryClient(queryClientConfig);
+  const logger: Logger = utils.logger;
+  const base = { onchain, queryClient, logger };
+
+  let market: MarketRepository | undefined;
+  let coinBalance: CoinBalanceRepository | undefined;
+  let flashloan: FlashloanRepository | undefined;
+  let obligation: ObligationRepository | undefined;
+  let borrowIncentive: BorrowIncentiveRepository | undefined;
+  let isolatedAssets: IsolatedAssetsRepository | undefined;
+  let veSca: VeScaRepository | undefined;
+  let loyaltyProgram: LoyaltyProgramRepository | undefined;
+  let xOracle: XOracleRepository | undefined;
+  let spool: SpoolRepository | undefined;
+  let veScaLoyaltyProgram: VeScaLoyaltyProgramRepository | undefined;
+  let referral: ReferralRepository | undefined;
+  let price: PriceRepository | undefined;
+  let poolAddresses: PoolAddressesRepository | undefined;
+
+  return {
+    get market() {
+      return (market ??= new MarketRepository({
+        ...base,
+        indexer,
+        addresses: buildMarketAddresses(utils),
+        metadata: buildMarketMetadata(utils),
+      }));
+    },
+    get coinBalance() {
+      return (coinBalance ??= new CoinBalanceRepository({
+        ...base,
+        metadata: buildCoinBalanceMetadata(utils),
+      }));
+    },
+    get flashloan() {
+      return (flashloan ??= new FlashloanRepository({
+        ...base,
+        metadata: buildFlashloanMetadata(utils),
+      }));
+    },
+    get obligation() {
+      return (obligation ??= new ObligationRepository({
+        ...base,
+        metadata: buildObligationMetadata(utils),
+      }));
+    },
+    get borrowIncentive() {
+      return (borrowIncentive ??= new BorrowIncentiveRepository({
+        ...base,
+        metadata: buildBorrowIncentiveMetadata(utils),
+      }));
+    },
+    get isolatedAssets() {
+      return (isolatedAssets ??= new IsolatedAssetsRepository({
+        ...base,
+        metadata: buildIsolatedAssetsMetadata(utils),
+      }));
+    },
+    get veSca() {
+      return (veSca ??= new VeScaRepository({
+        ...base,
+        metadata: buildVeScaMetadata(utils),
+      }));
+    },
+    get loyaltyProgram() {
+      return (loyaltyProgram ??= new LoyaltyProgramRepository({
+        ...base,
+        metadata: buildLoyaltyProgramMetadata(utils),
+      }));
+    },
+    get xOracle() {
+      return (xOracle ??= new XOracleRepository({
+        ...base,
+        metadata: buildXOracleMetadata(utils),
+      }));
+    },
+    get spool() {
+      return (spool ??= new SpoolRepository({
+        ...base,
+        indexer,
+        metadata: buildSpoolMetadata(utils),
+      }));
+    },
+    get veScaLoyaltyProgram() {
+      return (veScaLoyaltyProgram ??= new VeScaLoyaltyProgramRepository({
+        ...base,
+        metadata: buildVeScaLoyaltyProgramMetadata(utils),
+      }));
+    },
+    get referral() {
+      return (referral ??= new ReferralRepository({
+        ...base,
+        metadata: buildReferralMetadata(utils),
+      }));
+    },
+    get price() {
+      return (price ??= new PriceRepository({
+        ...base,
+        indexer,
+        metadata: buildPriceMetadata(utils),
+      }));
+    },
+    get poolAddresses() {
+      return (poolAddresses ??= new PoolAddressesRepository({
+        ...base,
+        api: createApiDataSource(),
+        metadata: buildPoolAddressesMetadata(utils),
+      }));
+    },
+  };
+};

package/src/repositories/wiring/source.ts

@@ -0,0 +1,63 @@
+import type { QuerySource } from '../utils.js';
+
+/**
+ * The legacy facade-level data-source flags. These remain the public arg shape
+ * that backwards-compatible `ScallopQuery` read methods accept; `fromQueryOptions`
+ * maps them onto the repositories' `QuerySource`. (The values are the pre-v4
+ * vocabulary — `'rpc' | 'indexer' | 'indexer-first'` — deliberately distinct from
+ * the repos `QuerySource`.)
+ */
+export type LegacyQuerySource = 'rpc' | 'indexer' | 'indexer-first';
+
+export type QueryOptions = {
+  source?: LegacyQuerySource;
+  indexer?: boolean;
+};
+
+/**
+ * Legacy ScallopQuery read methods expressed data-source choice three different
+ * ways: a `QueryOptions.source`, an `indexer: boolean`, or a
+ * `useOnChainQuery: boolean`. The repositories layer speaks a single
+ * `QuerySource`. `toQuerySource` is the one adapter that normalises the old
+ * flags so the facade can stay backwards-compatible while delegating to repos.
+ *
+ * Precedence: an explicit `source` wins; then `useOnChainQuery`; then `indexer`;
+ * otherwise default to `'api-first'` (indexer with onchain fallback) for
+ * dual-source domains.
+ */
+export type SourceFlags = {
+  source?: QuerySource;
+  indexer?: boolean;
+  useOnChainQuery?: boolean;
+};
+
+export const toQuerySource = (flags: SourceFlags = {}): QuerySource => {
+  if (flags.source) return flags.source;
+  if (flags.useOnChainQuery !== undefined) {
+    return flags.useOnChainQuery ? 'onchain' : 'api-first';
+  }
+  if (flags.indexer !== undefined) {
+    return flags.indexer ? 'api-first' : 'onchain';
+  }
+  return 'api-first';
+};
+
+const LEGACY_SOURCE: Record<
+  NonNullable<QueryOptions['source']>,
+  QuerySource
+> = {
+  rpc: 'onchain',
+  indexer: 'api',
+  'indexer-first': 'api-first',
+};
+
+/**
+ * Map a legacy `QueryOptions` ({ source?: 'rpc' | 'indexer' | 'indexer-first',
+ * indexer? }) to the repos' `QuerySource`. Mirrors the old `resolveQuerySource`:
+ * an explicit legacy `source` wins; else `indexer` → 'api-first', otherwise
+ * 'onchain' (the old default was 'rpc').
+ */
+export const fromQueryOptions = (options?: QueryOptions): QuerySource => {
+  if (options?.source) return LEGACY_SOURCE[options.source];
+  return options?.indexer ? 'api-first' : 'onchain';
+};

package/src/repositories/xOracle/bcs.ts

@@ -0,0 +1,7 @@
+import { bcs, BcsType } from '@mysten/sui/bcs';
+
+const PriceRuleTypeName = bcs.struct('TypeName', { name: bcs.string() });
+const VecSet = (T: BcsType<{ name: string }>) =>
+  bcs.struct('VecSet', { contents: bcs.vector(T) });
+
+export const PricePolicyRulesVecSet = VecSet(PriceRuleTypeName);

package/src/repositories/xOracle/const.ts

@@ -0,0 +1 @@
+export const SUPPORTED_ORACLES = ['supra', 'switchboard', 'pyth'] as const;