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

package/src/repositories/xOracle/helpers.ts

@@ -0,0 +1,304 @@
+import { SuiClientTypes } from '@mysten/sui/client';
+import {
+  SupportedOracle,
+  XOracleAssetOraclesContext,
+  XOracleOnDemandAggContext,
+  XOraclePriceUpdatePolicyContext,
+  XOracleSwitchboardRegistryContext,
+  XOracleUpdatePolicyRulesContext,
+} from './types.js';
+import { queryKeys } from 'src/constants/queryKeys.js';
+import { bcs } from '@mysten/sui/bcs';
+import { prepend0x } from './utils.js';
+import { PricePolicyRulesVecSet } from './bcs.js';
+import { getDynamicFieldOrNull, logError } from '../utils.js';
+import { encodeDynamicFieldNameForV2 } from 'src/utils/dynamicField.js';
+import { ScallopParseError, ScallopRpcError } from 'src/errors/index.js';
+
+const SWITCHBOARD_REGISTRY_SCAN_THRESHOLD = 3;
+
+const queryUpdatePolicyRules = async (
+  ctx: XOracleUpdatePolicyRulesContext,
+  vecSetId: string
+): Promise<Record<string, SupportedOracle[]>> => {
+  const { onchain, fetchWithCache, metadata } = ctx;
+  const { addresses, parseCoinNameFromType } = metadata;
+  const limit = 50;
+
+  const ruleTypeNameToOracleType: Record<string, SupportedOracle> = {
+    [`${addresses.pyth.object}::rule::Rule`]: 'pyth',
+    [`${addresses.supra.object}::rule::Rule`]: 'supra',
+    [`${addresses.switchboard.object}::rule::Rule`]: 'switchboard',
+  };
+
+  let nextCursor = null;
+  let nextPage = true;
+
+  const results: Record<string, SupportedOracle[]> = {};
+
+  do {
+    const fetchOptions: SuiClientTypes.ListDynamicFieldsOptions = {
+      parentId: vecSetId,
+      cursor: nextCursor,
+      limit,
+      //@ts-ignore - Supported on grpc implementation
+      include: {
+        value: true,
+      },
+    };
+    const { dynamicFields, cursor, hasNextPage } = await fetchWithCache({
+      queryKey: queryKeys.rpc.getDynamicFields({
+        ...fetchOptions,
+        node: onchain.url,
+      }),
+      queryFn: () => onchain.client.listDynamicFields(fetchOptions),
+    });
+
+    nextCursor = cursor;
+    nextPage = hasNextPage;
+
+    // Process the dynamic fields
+    dynamicFields.forEach((field) => {
+      // Get coin type
+      const coinType = prepend0x(bcs.string().parse(field.name.bcs));
+      const coinName = parseCoinNameFromType(coinType);
+      // @ts-ignore - value is supported on grpc implementation
+      const parsedValue = PricePolicyRulesVecSet.parse(field.value.bcs);
+
+      if (!results[coinName]) {
+        results[coinName] = [];
+      }
+
+      // Iterate through parsedValue
+      parsedValue.contents.forEach(({ name }) => {
+        const oracle = ruleTypeNameToOracleType[prepend0x(name)];
+        if (oracle) {
+          results[coinName].push(oracle);
+        }
+      });
+    });
+  } while (nextPage);
+
+  return results;
+};
+
+export const getAssetOraclesFromOnChain = async (
+  ctx: XOracleAssetOraclesContext
+) => {
+  const {
+    metadata: { addresses, whitelist },
+  } = ctx;
+  const [primary, secondary] = await Promise.all([
+    queryUpdatePolicyRules(
+      ctx,
+      addresses.oracles.primaryPriceUpdatePolicyVecsetId
+    ),
+    queryUpdatePolicyRules(
+      ctx,
+      addresses.oracles.secondaryPriceUpdatePolicyVecsetId
+    ),
+  ]);
+
+  return [...whitelist.lending.values()].reduce(
+    (acc, assetName) => {
+      acc[assetName] = {
+        primary: primary[assetName] ?? [],
+        secondary: secondary[assetName] ?? [],
+      };
+      return acc;
+    },
+    {} as Record<
+      string,
+      { primary: SupportedOracle[]; secondary: SupportedOracle[] }
+    >
+  );
+};
+
+/**
+ * Primary/secondary price-update-policy dynamic fields.
+ *
+ * NOTE: the return shape changed from the legacy `getPriceUpdatePolicies`
+ * (which leaked `SuiObjectResponse`). This returns the new-gen client's
+ * dynamic-field result (or `null` when the policy rules key isn't present).
+ */
+export const getPriceUpdatePoliciesFromOnChain = async (
+  ctx: XOraclePriceUpdatePolicyContext
+) => {
+  const { addresses } = ctx.metadata;
+  const keyType = `${addresses.xOracleObject}::price_update_policy::PriceUpdatePolicyRulesKey`;
+  const nameBcs = bcs
+    .struct('TypeName', { dummy_field: bcs.bool() })
+    .serialize({ dummy_field: false })
+    .toBytes();
+
+  const [primary, secondary] = await Promise.all([
+    getDynamicFieldOrNull(ctx, {
+      parentId: addresses.oracles.primaryPriceUpdatePolicyObject,
+      name: { type: keyType, bcs: nameBcs },
+    }),
+    getDynamicFieldOrNull(ctx, {
+      parentId: addresses.oracles.secondaryPriceUpdatePolicyObject,
+      name: { type: keyType, bcs: nameBcs },
+    }),
+  ]);
+
+  return { primary, secondary };
+};
+
+/**
+ * Switchboard on-demand aggregator object ids for the given coins, aligned to
+ * the input order. Uses the address-API registration when present, else looks
+ * the coin up in the on-chain switchboard registry table.
+ */
+export const getOnDemandAggObjectIdsFromOnChain = async (
+  ctx: XOracleOnDemandAggContext,
+  coinNames: string[]
+): Promise<string[]> => {
+  const { addresses, parseCoinType, getSwitchboardAggAddress } = ctx.metadata;
+  const registryTableId = addresses.oracles.switchboardRegistryTableId;
+
+  const missingAgg: Array<{ idx: number; coinName: string }> = [];
+  const registeredAggs: Array<string | null> = coinNames.map(
+    (coinName, idx) => {
+      const registered = getSwitchboardAggAddress(coinName);
+      if (registered) return registered;
+      missingAgg.push({ idx, coinName });
+      return null;
+    }
+  );
+
+  if (missingAgg.length === 0) return registeredAggs as string[];
+
+  if (missingAgg.length > SWITCHBOARD_REGISTRY_SCAN_THRESHOLD) {
+    const missingCoinTypes = new Map<
+      string,
+      { idx: number; coinName: string }
+    >();
+    for (const missing of missingAgg) {
+      const coinType = parseCoinType(missing.coinName);
+      if (!coinType) {
+        throw logError(
+          ctx.logger,
+          new ScallopParseError(`Invalid coin name: ${missing.coinName}`, {
+            context: { coinName: missing.coinName },
+          })
+        );
+      }
+      missingCoinTypes.set(coinType.slice(2), missing);
+    }
+
+    const scannedAggs = await querySwitchboardRegistryAggs(
+      ctx,
+      registryTableId,
+      missingCoinTypes
+    );
+    for (const [coinTypeKey, { idx }] of missingCoinTypes) {
+      const agg = scannedAggs[coinTypeKey];
+      if (!agg) {
+        throw logError(
+          ctx.logger,
+          new ScallopRpcError(
+            `No on-demand aggregator found for 0x${coinTypeKey}`,
+            { context: { coinTypeKey } }
+          )
+        );
+      }
+      registeredAggs[idx] = agg;
+    }
+
+    return registeredAggs as string[];
+  }
+
+  await Promise.all(
+    missingAgg.map(async ({ idx, coinName }) => {
+      const coinType = parseCoinType(coinName);
+      if (!coinType) {
+        throw logError(
+          ctx.logger,
+          new ScallopParseError(`Invalid coin name: ${coinName}`, {
+            context: { coinName },
+          })
+        );
+      }
+      const result = await getDynamicFieldOrNull(ctx, {
+        parentId: registryTableId,
+        name: encodeDynamicFieldNameForV2({
+          type: '0x1::type_name::TypeName',
+          value: { name: coinType.slice(2) },
+        }),
+      });
+      if (!result) {
+        throw logError(
+          ctx.logger,
+          new ScallopRpcError(`No on-demand aggregator found for ${coinType}`, {
+            context: { coinType },
+          })
+        );
+      }
+      // The registry value is the aggregator object id (an address).
+      // UNVERIFIED: confirm the bcs shape against a live registry entry.
+      registeredAggs[idx] = bcs.Address.parse(result.dynamicField.value.bcs);
+    })
+  );
+
+  return registeredAggs as string[];
+};
+
+const parseRegistryCoinTypeKey = (
+  field: SuiClientTypes.DynamicFieldEntry
+): string | undefined => {
+  try {
+    return bcs.struct('TypeName', { name: bcs.string() }).parse(field.name.bcs)
+      .name;
+  } catch {
+    try {
+      return bcs.string().parse(field.name.bcs);
+    } catch {
+      return undefined;
+    }
+  }
+};
+
+const querySwitchboardRegistryAggs = async (
+  ctx: XOracleSwitchboardRegistryContext,
+  registryTableId: string,
+  missingCoinTypes: ReadonlyMap<string, { idx: number; coinName: string }>
+): Promise<Record<string, string>> => {
+  const { onchain, fetchWithCache } = ctx;
+  const result: Record<string, string> = {};
+  let cursor: string | null | undefined = null;
+  let hasNextPage = false;
+
+  do {
+    const options: SuiClientTypes.ListDynamicFieldsOptions = {
+      parentId: registryTableId,
+      cursor,
+      limit: 50,
+      // @ts-ignore - Supported on grpc implementation
+      include: { value: true },
+    };
+    const resp = await fetchWithCache({
+      queryKey: queryKeys.rpc.getDynamicFields({
+        ...options,
+        node: onchain.url,
+      }),
+      queryFn: () => onchain.client.listDynamicFields(options),
+    });
+
+    for (const field of resp.dynamicFields) {
+      const coinTypeKey = parseRegistryCoinTypeKey(field);
+      if (!coinTypeKey || !missingCoinTypes.has(coinTypeKey)) continue;
+      // @ts-ignore - value is supported on grpc implementation
+      const valueBcs = field.value?.bcs;
+      if (valueBcs) {
+        result[coinTypeKey] = bcs.Address.parse(valueBcs);
+      }
+    }
+
+    cursor = resp.cursor;
+    hasNextPage =
+      resp.hasNextPage && Object.keys(result).length < missingCoinTypes.size;
+  } while (hasNextPage);
+
+  return result;
+};

package/src/repositories/xOracle/index.ts

@@ -0,0 +1,45 @@
+import { BaseRepository } from '../base.js';
+import { OnChainDataSource } from 'src/datasources/onchain.js';
+import {
+  getAssetOraclesFromOnChain,
+  getOnDemandAggObjectIdsFromOnChain,
+  getPriceUpdatePoliciesFromOnChain,
+} from './helpers.js';
+import {
+  XOracleMetadata,
+  XOracleRepoParams,
+  XOracleRepoContext,
+} from './types.js';
+
+export class XOracleRepository extends BaseRepository<
+  XOracleRepoContext,
+  XOracleMetadata
+> {
+  private readonly onchain: OnChainDataSource;
+
+  constructor({ onchain, ...params }: XOracleRepoParams) {
+    super(params);
+    this.onchain = onchain;
+  }
+
+  get context() {
+    return { ...this.baseContext, onchain: this.onchain };
+  }
+
+  /**
+   * Return supported primary and secondary oracles for supported assets
+   */
+  getAssetOracles() {
+    return getAssetOraclesFromOnChain(this.context);
+  }
+
+  /** Primary/secondary price-update-policy dynamic fields. */
+  getPriceUpdatePolicies() {
+    return getPriceUpdatePoliciesFromOnChain(this.context);
+  }
+
+  /** Switchboard on-demand aggregator object ids for the given coins. */
+  getOnDemandAggObjectIds(coinNames: string[]) {
+    return getOnDemandAggObjectIdsFromOnChain(this.context, coinNames);
+  }
+}

package/src/repositories/xOracle/types.ts

@@ -0,0 +1,96 @@
+import { BaseContext, BaseRepoParams } from '../types.js';
+import { OnChainDataSource } from 'src/datasources/onchain.js';
+import { SUPPORTED_ORACLES } from './const.js';
+
+export type SupportedOracle = (typeof SUPPORTED_ORACLES)[number];
+
+type SupportedOracleAddresses = Record<SupportedOracle, { object: string }>;
+type XOracleAddresses = {
+  /** `core.packages.xOracle.object` — used to build the policy-rules key type. */
+  xOracleObject: string;
+  oracles: {
+    primaryPriceUpdatePolicyVecsetId: string;
+    secondaryPriceUpdatePolicyVecsetId: string;
+    primaryPriceUpdatePolicyObject: string;
+    secondaryPriceUpdatePolicyObject: string;
+    switchboardRegistryTableId: string;
+  };
+};
+
+export type XOracleMetadata = {
+  addresses: SupportedOracleAddresses & XOracleAddresses;
+  whitelist: {
+    lending: ReadonlySet<string>;
+  };
+  parseCoinNameFromType: (type: string) => string;
+  parseCoinType: (coinName: string) => string;
+  /** Pre-registered switchboard aggregator id for a coin, if the address API
+   *  carries one (`core.coins.<coin>.oracle.switchboard`). */
+  getSwitchboardAggAddress: (coinName: string) => string | undefined;
+};
+
+export type XOracleRepoContext = BaseContext & {
+  onchain: OnChainDataSource;
+  metadata: XOracleMetadata;
+};
+
+export type XOracleRepoParams = BaseRepoParams & {
+  onchain: OnChainDataSource;
+  metadata: XOracleMetadata;
+};
+
+/**
+ * Reads update-policy rule VecSets per coin: paginated on-chain dynamic-field
+ * scan + coin-name parsing. Needs the oracle rule package addresses.
+ */
+export type XOracleUpdatePolicyRulesContext = Pick<
+  XOracleRepoContext,
+  'onchain' | 'fetchWithCache' | 'logger'
+> & {
+  metadata: Pick<XOracleMetadata, 'addresses' | 'parseCoinNameFromType'>;
+};
+
+/**
+ * Assembles primary/secondary asset oracles across the lending whitelist.
+ * Reads the rule VecSet ids + lending whitelist; delegates per-vecset scans to
+ * `queryUpdatePolicyRules` (hence the rule-scan slice on top).
+ */
+export type XOracleAssetOraclesContext = XOracleUpdatePolicyRulesContext & {
+  metadata: Pick<
+    XOracleMetadata,
+    'addresses' | 'parseCoinNameFromType' | 'whitelist'
+  >;
+};
+
+/**
+ * Reads the price-update-policy dynamic fields. Needs only the policy object
+ * ids from `addresses`; the dynamic-field reads go through
+ * `getDynamicFieldOrNull` (hence the `onchain`/`fetchWithCache` slice).
+ */
+export type XOraclePriceUpdatePolicyContext = Pick<
+  XOracleRepoContext,
+  'onchain' | 'fetchWithCache'
+> & {
+  metadata: Pick<XOracleMetadata, 'addresses'>;
+};
+
+/**
+ * Resolves switchboard on-demand aggregator ids for coins. Needs the registry
+ * table id + coin-type/aggregator parse helpers, plus the on-chain reads for
+ * the registry scan / dynamic-field lookups.
+ */
+export type XOracleOnDemandAggContext = Pick<
+  XOracleRepoContext,
+  'onchain' | 'fetchWithCache' | 'logger'
+> & {
+  metadata: Pick<
+    XOracleMetadata,
+    'addresses' | 'parseCoinType' | 'getSwitchboardAggAddress'
+  >;
+};
+
+/** Paginated scan of the switchboard registry table. On-chain reads only. */
+export type XOracleSwitchboardRegistryContext = Pick<
+  XOracleRepoContext,
+  'onchain' | 'fetchWithCache'
+>;

package/src/repositories/xOracle/utils.ts

@@ -0,0 +1,3 @@
+export const prepend0x = (str: string) => {
+  return str.startsWith('0x') ? str : `0x${str}`;
+};

package/src/services/client/BorrowService.ts

@@ -0,0 +1,229 @@
+import type { TransactionResult } from '@mysten/sui/transactions';
+import type { ClientServiceContext, ClientTxResult } from './types.js';
+import { ScallopTransactionBuildError } from 'src/errors/index.js';
+
+/**
+ * Application service for borrow-side lifecycle operations:
+ *  - obligation creation
+ *  - borrow / repay
+ *  - supply + auto-stake convenience
+ *  - borrow-incentive stake / unstake / claim
+ *
+ * Each method preserves the public ScallopClient signature one-to-one.
+ */
+export class BorrowService {
+  constructor(private readonly ctx: ClientServiceContext) {}
+
+  async openObligation<S extends boolean>(
+    sign: S = true as S
+  ): Promise<ClientTxResult<S>> {
+    const txBlock = this.ctx.builder.createTxBlock();
+    txBlock.openObligationEntry();
+    if (sign) {
+      return (await this.ctx.executor.signAndSendTxn(
+        txBlock
+      )) as ClientTxResult<S>;
+    }
+    return txBlock.txBlock as ClientTxResult<S>;
+  }
+
+  async borrow<S extends boolean>(
+    poolCoinName: string,
+    amount: number,
+    sign: S = true as S,
+    obligationId: string,
+    obligationKey: string,
+    walletAddress?: string,
+    isSponsoredTx?: boolean
+  ): Promise<ClientTxResult<S>> {
+    const txBlock = this.ctx.builder.createTxBlock();
+    const sender = walletAddress ?? this.ctx.walletAddress;
+    txBlock.setSender(sender);
+
+    const availableStake =
+      this.ctx.constants.whitelist.lending.has(poolCoinName);
+    if (sign && availableStake) {
+      await txBlock.unstakeObligationQuick(obligationId, obligationKey);
+    }
+    const coin = await txBlock.borrowQuick(
+      amount,
+      poolCoinName,
+      obligationId,
+      obligationKey,
+      { isSponsoredTx }
+    );
+    txBlock.transferObjects([coin], sender);
+    if (sign && availableStake) {
+      await txBlock.stakeObligationWithVeScaQuick(obligationId, obligationKey);
+    }
+
+    if (sign) {
+      return (await this.ctx.executor.signAndSendTxn(
+        txBlock
+      )) as ClientTxResult<S>;
+    }
+    return txBlock.txBlock as ClientTxResult<S>;
+  }
+
+  async repay<S extends boolean>(
+    poolCoinName: string,
+    amount: number,
+    sign: S = true as S,
+    obligationId: string,
+    obligationKey: string,
+    walletAddress?: string,
+    isSponsoredTx?: boolean
+  ): Promise<ClientTxResult<S>> {
+    const txBlock = this.ctx.builder.createTxBlock();
+    const sender = walletAddress ?? this.ctx.walletAddress;
+    txBlock.setSender(sender);
+
+    const availableStake =
+      this.ctx.constants.whitelist.lending.has(poolCoinName);
+    if (sign && availableStake) {
+      await txBlock.unstakeObligationQuick(obligationId, obligationKey);
+    }
+    await txBlock.repayQuick(amount, poolCoinName, obligationId, isSponsoredTx);
+    if (sign && availableStake) {
+      await txBlock.stakeObligationWithVeScaQuick(obligationId, obligationKey);
+    }
+
+    if (sign) {
+      return (await this.ctx.executor.signAndSendTxn(
+        txBlock
+      )) as ClientTxResult<S>;
+    }
+    return txBlock.txBlock as ClientTxResult<S>;
+  }
+
+  async supplyAndStake<S extends boolean>(
+    stakeCoinName: string,
+    amount: number,
+    sign: S = true as S,
+    stakeAccountId?: string,
+    walletAddress?: string
+  ): Promise<ClientTxResult<S>> {
+    const txBlock = this.ctx.builder.createTxBlock();
+    const sender = walletAddress ?? this.ctx.walletAddress;
+    txBlock.setSender(sender);
+
+    const stakeMarketCoinName =
+      this.ctx.utils.parseMarketCoinName<string>(stakeCoinName);
+    const stakeAccounts =
+      await this.ctx.query.getStakeAccounts(stakeMarketCoinName);
+    const targetStakeAccount = stakeAccountId ?? stakeAccounts[0]?.id;
+
+    const marketCoin = await txBlock.supplyQuick(amount, stakeCoinName, false);
+    if (targetStakeAccount) {
+      await txBlock.stakeQuick(
+        marketCoin,
+        stakeMarketCoinName,
+        targetStakeAccount
+      );
+    } else {
+      const account = txBlock.createStakeAccount(stakeMarketCoinName);
+      await txBlock.stakeQuick(marketCoin, stakeMarketCoinName, account);
+      txBlock.transferObjects([account], sender);
+    }
+
+    if (sign) {
+      return (await this.ctx.executor.signAndSendTxn(
+        txBlock
+      )) as ClientTxResult<S>;
+    }
+    return txBlock.txBlock as ClientTxResult<S>;
+  }
+
+  async stakeObligation<S extends boolean>(
+    obligationId: string,
+    obligationKeyId: string,
+    sign: S = true as S,
+    walletAddress?: string
+  ): Promise<ClientTxResult<S>> {
+    const txBlock = this.ctx.builder.createTxBlock();
+    txBlock.setSender(walletAddress ?? this.ctx.walletAddress);
+    await txBlock.stakeObligationWithVeScaQuick(obligationId, obligationKeyId);
+
+    if (sign) {
+      return (await this.ctx.executor.signAndSendTxn(
+        txBlock
+      )) as ClientTxResult<S>;
+    }
+    return txBlock.txBlock as ClientTxResult<S>;
+  }
+
+  async unstakeObligation<S extends boolean>(
+    obligationId: string,
+    obligationKeyId: string,
+    sign: S = true as S,
+    walletAddress?: string
+  ): Promise<ClientTxResult<S>> {
+    const txBlock = this.ctx.builder.createTxBlock();
+    txBlock.setSender(walletAddress ?? this.ctx.walletAddress);
+    await txBlock.unstakeObligationQuick(obligationId, obligationKeyId);
+
+    if (sign) {
+      return (await this.ctx.executor.signAndSendTxn(
+        txBlock
+      )) as ClientTxResult<S>;
+    }
+    return txBlock.txBlock as ClientTxResult<S>;
+  }
+
+  async claimBorrowIncentive<S extends boolean>(
+    obligationId: string,
+    obligationKeyId: string,
+    sign: S = true as S,
+    walletAddress?: string
+  ): Promise<ClientTxResult<S>> {
+    const txBlock = this.ctx.builder.createTxBlock();
+    const sender = walletAddress ?? this.ctx.walletAddress;
+    txBlock.setSender(sender);
+
+    const rewardCoinsCollection: Record<string, TransactionResult[]> = {};
+    const obligationAccount =
+      await this.ctx.query.getObligationAccount(obligationId);
+    if (!obligationAccount) {
+      throw new ScallopTransactionBuildError('Obligation not found', {
+        context: { obligationId },
+      });
+    }
+    const rewardCoinNames = Object.values(obligationAccount.borrowIncentives)
+      .filter((t): t is NonNullable<typeof t> => !!t)
+      .flatMap(({ rewards }) =>
+        rewards.filter(({ availableClaimAmount }) => availableClaimAmount > 0)
+      )
+      .flatMap(({ coinName }) => coinName);
+
+    for (const rewardCoinName of rewardCoinNames) {
+      const rewardCoin = await txBlock.claimBorrowIncentiveQuick(
+        rewardCoinName,
+        obligationId,
+        obligationKeyId
+      );
+      if (!rewardCoinsCollection[rewardCoinName]) {
+        rewardCoinsCollection[rewardCoinName] = [rewardCoin];
+      } else {
+        rewardCoinsCollection[rewardCoinName].push(rewardCoin);
+      }
+    }
+
+    txBlock.transferObjects(
+      Object.values(rewardCoinsCollection).map((rewardCoins) => {
+        const mergeDest = rewardCoins[0];
+        if (rewardCoins.length > 1) {
+          txBlock.mergeCoins(mergeDest, rewardCoins.slice(1));
+        }
+        return mergeDest;
+      }),
+      sender
+    );
+
+    if (sign) {
+      return (await this.ctx.executor.signAndSendTxn(
+        txBlock
+      )) as ClientTxResult<S>;
+    }
+    return txBlock.txBlock as ClientTxResult<S>;
+  }
+}