@kestrelfi/lyc-sdk 1.0.1

package/src/types/enriched.ts

@@ -0,0 +1,187 @@
+import type { Address } from "@solana/kit";
+import type { LendingPlatform, MintRegistry } from "common";
+import type { LendingPlatformData, LendingPositionInspectMetrics } from "lending-platforms";
+import type { LYCYieldingBank } from "../models/yieldingBank";
+import type { FeeDripAbsorptionStatus } from "../utils/feeDripMetrics";
+
+export type {
+  LendingPositionInspectMetrics,
+  LendingPositionSelectedPrice,
+  LendingPositionUtilizationRatesBps,
+  LendingPositionUtilizationPrices,
+  CollateralPriceTriggerBand,
+  CollateralPriceTriggerLevel,
+} from "lending-platforms";
+
+export interface YieldingBankInspectSnapshotArgs {
+  environment: "local" | "test" | "prod";
+  mintRegistry: MintRegistry;
+  timelocksEnabledInLocal?: boolean;
+}
+
+export interface TokenInspectSnapshotArgs {
+  environment: "local" | "test" | "prod";
+  mintRegistry: MintRegistry;
+  yieldingBanks: readonly LYCYieldingBank[];
+  kaminoData: LendingPlatformData;
+  timelocksEnabledInLocal?: boolean;
+  /** Unix timestamp override for deterministic APY/fee-drip projections. */
+  nowTs?: number;
+}
+
+export interface EnrichedYieldingBankHolding {
+  kind: "base" | "asset";
+  mint: Address;
+  symbol: string;
+  amountRaw: bigint;
+  amountUi: number;
+  decimals: number;
+  priceRaw: bigint;
+  priceUi: number;
+  isTimelocked: boolean;
+}
+
+export interface EnrichedYieldingBankExternalPosition {
+  platform: LendingPlatform;
+  pool: Address;
+  tvlRaw: bigint;
+  tvlUsd: number;
+  isTimelocked: boolean;
+}
+
+export interface EnrichedYieldingBankSnapshot {
+  address: Address;
+  id: number;
+  curator: Address;
+  baseMint: Address;
+  baseSymbol: string;
+  isActive: boolean;
+  circuitBreaker: number;
+  decimals: number;
+  tvlRaw: bigint;
+  tvlUsd: number;
+  sharePrice: number;
+  totalShares: number;
+  lastRefreshedTs: bigint;
+  lastRebalancedTs: bigint;
+  isTimelocked: boolean;
+  defaultRedemptionMint?: Address;
+  defaultRedemptionSymbol?: string;
+  holdings: EnrichedYieldingBankHolding[];
+  externalYieldingPositions: EnrichedYieldingBankExternalPosition[];
+}
+
+export interface EnrichedTokenCollateralSnapshot {
+  mint: Address;
+  symbol: string;
+  decimals: number;
+  unlentAmountRaw: bigint;
+  unlentAmountUi: number;
+  pendingUnwindResidualRaw: bigint;
+  pendingUnwindResidualUi: number;
+  oraclePriceRaw: bigint;
+  oraclePriceOnChainUi: number;
+  oraclePriceRealtimeUi: number;
+  oraclePriceEmaUi: number;
+  oracle: Address;
+  /** Set for composite oracle types (e.g. PythSplStake stake pool). */
+  secondaryOracle?: Address;
+  lastRefreshedTs: bigint;
+}
+
+export interface EnrichedTokenLendingPosition {
+  index: number;
+  platform: LendingPlatform;
+  withdrawPending: boolean;
+  pool: Address;
+  userAccount: Address;
+  collateralAmountRaw: bigint;
+  collateralAmountUi: number;
+  collateralDecimals: number;
+  collateralSymbol: string;
+  debtAmountRaw: bigint;
+  debtAmountUi: number;
+  debtTvlUsdRaw: bigint;
+  debtTvlUsd: number;
+  debtMint: Address;
+  debtSymbol: string;
+  debtDecimals: number;
+  debtPriceRaw: bigint;
+  debtPriceUi: number;
+  onChainUtilizationRateBps: number;
+  targetUtilizationRateBps: number;
+  maxDeviationAboveTargetUtilBps: number;
+  maxDeviationBelowTargetUtilBps: number;
+  /** Stamped only by `rebalance_token`; 0 means never rebalanced. */
+  lastRebalancedTs: bigint;
+  inspectMetrics?: LendingPositionInspectMetrics;
+}
+
+export interface EnrichedTokenCarryPosition {
+  index: number;
+  yieldingBankId: number;
+  yieldingBankAddress?: Address;
+  baseMint: Address;
+  baseSymbol: string;
+  sharesRaw: bigint;
+  sharesUi?: number;
+  shareDecimals?: number;
+  tvlUsdRaw: bigint;
+  tvlUsd: number;
+}
+
+export interface EnrichedTokenCarrySummary {
+  totalCarryTvlUsdRaw: bigint;
+  totalCarryTvlUsd: number;
+  totalDebtUsdRaw: bigint;
+  totalDebtUsd: number;
+  netYieldUsdRaw: bigint;
+  netYieldUsd: number;
+}
+
+export interface EnrichedTokenFeesSnapshot {
+  mintingFeeBps: number;
+  burningFeeBps: number;
+  performanceFeeBps: number;
+  protocolMintBurnPctBps: number;
+  curatorMintBurnPctBps: number;
+  holderMintBurnPctBps: number;
+  curatorPerfPctBps: number;
+  feeDripMaxApyBps: number;
+  feeDripDurationSecs: bigint;
+  undrippedFeeCollateralRaw: bigint;
+  undrippedFeeCollateralUi: number;
+  dripEndTs: bigint;
+  apyReferencePriceRaw: bigint;
+  apyReferencePrice: number;
+  apyReferenceTs: bigint;
+  currentApyBps: number | null;
+  absorptionEtaSeconds: number | null;
+  absorptionStatus: FeeDripAbsorptionStatus;
+  pendingProtocolFeesRaw: bigint;
+  pendingProtocolFeesUi: number;
+  pendingCuratorFeesRaw: bigint;
+  pendingCuratorFeesUi: number;
+}
+
+export interface EnrichedTokenSnapshot {
+  address: Address;
+  id: number;
+  curator: Address;
+  mint: Address;
+  decimals: number;
+  isActive: boolean;
+  price: number;
+  totalSupply: number;
+  tvlUsdRaw: bigint;
+  tvlUsd: number;
+  lastRefreshedTs: bigint;
+  firstMintTs: bigint;
+  collateral: EnrichedTokenCollateralSnapshot;
+  lendingPositions: EnrichedTokenLendingPosition[];
+  carryPositions: EnrichedTokenCarryPosition[];
+  carrySummary: EnrichedTokenCarrySummary;
+  /** True when the token is active and its positive carry surplus is at most 1 bp of debt. */
+  hasInterestToCollect: boolean;
+  fees: EnrichedTokenFeesSnapshot;
+}

package/src/types/index.ts

@@ -0,0 +1 @@
+export * from "./enriched";

package/src/utils/cache.ts

@@ -0,0 +1,12 @@
+import { type Address } from "@solana/kit";
+import { type TransactionCacheInvalidation } from "common";
+
+export function getTokenCacheInvalidation(token: Address): TransactionCacheInvalidation {
+  return { client: "lycToken", tokenPda: token };
+}
+
+export function getYieldingBankCacheInvalidation(
+  yieldingBank: Address
+): TransactionCacheInvalidation {
+  return { client: "lycYieldingBank", yieldingBankPda: yieldingBank };
+}

package/src/utils/data.ts

@@ -0,0 +1,65 @@
+import { type Address } from "@solana/kit";
+import { accountExists } from "common";
+import type { LongYieldCarryClient } from "../client/client";
+
+/**
+ * First token ID (0–255) not yet used for the given yToken mint address.
+ *
+ * Tries `fetchAllTokens` first, then scans PDAs if RPC program accounts are unavailable.
+ */
+export async function findFreeTokenId(
+  client: LongYieldCarryClient,
+  mint: Address
+): Promise<number> {
+  try {
+    client.account.dataCache.clearAllCache();
+    const tokens = await client.account.fetchAllTokens();
+
+    if (tokens.length > 0) {
+      const usedIds = new Set(tokens.filter((t) => t.mint === mint).map((t) => t.id));
+
+      for (let id = 0; id <= 255; id++) {
+        if (!usedIds.has(id)) return id;
+      }
+      throw new Error(`No free token ID found for mint ${mint}`);
+    }
+  } catch {
+    // getProgramAccounts may not be supported / reliable on some RPCs
+  }
+
+  for (let id = 0; id <= 255; id++) {
+    const [pda] = await client.pda.deriveTokenPda(mint, id);
+    if (!(await accountExists(client.rpc, pda))) return id;
+  }
+  throw new Error(`No free token ID found for mint ${mint}`);
+}
+
+/**
+ * First yielding-bank ID (0–255) not yet used for the given base mint.
+ */
+export async function findFreeYieldingBankId(
+  client: LongYieldCarryClient,
+  baseMint: Address
+): Promise<number> {
+  try {
+    client.account.dataCache.clearAllCache();
+    const banks = await client.account.fetchAllYieldingBanks();
+
+    if (banks.length > 0) {
+      const usedIds = new Set(banks.filter((b) => b.baseMint === baseMint).map((b) => b.id));
+
+      for (let id = 0; id <= 255; id++) {
+        if (!usedIds.has(id)) return id;
+      }
+      throw new Error(`No free yielding bank ID found for mint ${baseMint}`);
+    }
+  } catch {
+    // getProgramAccounts may not be supported / reliable on some RPCs
+  }
+
+  for (let id = 0; id <= 255; id++) {
+    const [pda] = await client.pda.deriveYieldingBankPda(baseMint, id);
+    if (!(await accountExists(client.rpc, pda))) return id;
+  }
+  throw new Error(`No free yielding bank ID found for mint ${baseMint}`);
+}

package/src/utils/enrichment.ts

@@ -0,0 +1,330 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+  fromWeb3Pk,
+  LendingPlatform,
+  lendingPlatformToEnum,
+  type MintRegistry,
+  mintSymbol,
+  toBigInt,
+  toUiAmount,
+  TVL_USD_DECIMAL_PLACES,
+} from "common";
+import type { LendingPlatformData } from "lending-platforms";
+import { oracle } from "oracle";
+import type { LYCToken, TokenLendingPositionData } from "../models/lycToken";
+import type { LYCYieldingBank } from "../models/yieldingBank";
+import { LycLendingPositionManager } from "../services/carry";
+import { calculateFeeDripMetrics } from "./feeDripMetrics";
+import { podBoolToNumber } from "./general";
+import { collectableNetYieldUsd } from "./tokenFeeMath";
+import { getTimelockStatus } from "./timelock";
+import type {
+  EnrichedTokenCarryPosition,
+  EnrichedTokenLendingPosition,
+  EnrichedTokenSnapshot,
+  EnrichedYieldingBankHolding,
+  EnrichedYieldingBankSnapshot,
+  TokenInspectSnapshotArgs,
+  YieldingBankInspectSnapshotArgs,
+} from "../types/enriched";
+
+export function buildYieldingBankInspectSnapshot(
+  bank: LYCYieldingBank,
+  args: YieldingBankInspectSnapshotArgs
+): EnrichedYieldingBankSnapshot {
+  const { environment, mintRegistry, timelocksEnabledInLocal } = args;
+  const timelockOptions = { enableLocalTimelocks: timelocksEnabledInLocal };
+  const baseSymbol = mintSymbol(bank.baseMint, mintRegistry);
+  const defaultRedemptionMint =
+    bank.defaultRedemptionMint !== PublicKey.default.toBase58()
+      ? bank.defaultRedemptionMint
+      : undefined;
+
+  const holdings: EnrichedYieldingBankHolding[] = [
+    {
+      kind: "base",
+      mint: bank.baseMint,
+      symbol: baseSymbol,
+      amountRaw: toBigInt(bank.data.baseAsset.amount),
+      amountUi: toUiAmount(bank.data.baseAsset.amount, bank.data.baseAsset.decimals),
+      decimals: bank.data.baseAsset.decimals,
+      priceRaw: toBigInt(bank.data.baseAsset.price),
+      priceUi: toUiAmount(bank.data.baseAsset.price, bank.data.baseAsset.decimals),
+      isTimelocked: getTimelockStatus(
+        environment,
+        bank.data.baseAsset.timeCreated,
+        "touch",
+        timelockOptions
+      ).isTimelocked,
+    },
+    ...bank.data.assets
+      .filter((asset) => !asset.mint.equals(PublicKey.default))
+      .map((asset) => {
+        const mint = fromWeb3Pk(asset.mint);
+        return {
+          kind: "asset" as const,
+          mint,
+          symbol: mintSymbol(mint, mintRegistry),
+          amountRaw: toBigInt(asset.amount),
+          amountUi: toUiAmount(asset.amount, asset.decimals),
+          decimals: asset.decimals,
+          priceRaw: toBigInt(asset.price),
+          priceUi: toUiAmount(asset.price, asset.decimals),
+          isTimelocked: getTimelockStatus(environment, asset.timeCreated, "touch", timelockOptions)
+            .isTimelocked,
+        };
+      }),
+  ];
+
+  const externalYieldingPositions = bank.data.externalYieldingPositions
+    .map((position) => ({
+      platform: lendingPlatformToEnum(position.lendingPlatform),
+      pool: fromWeb3Pk(position.pool),
+      tvlRaw: toBigInt(position.tvl),
+      tvlUsd: toUiAmount(position.tvl, TVL_USD_DECIMAL_PLACES),
+      isTimelocked: getTimelockStatus(environment, position.timeCreated, "touch", timelockOptions)
+        .isTimelocked,
+    }))
+    .filter((position) => position.platform !== LendingPlatform.None);
+
+  return {
+    address: bank.address,
+    id: bank.id,
+    curator: fromWeb3Pk(bank.data.roles.curator),
+    baseMint: bank.baseMint,
+    baseSymbol,
+    isActive: bank.isActive,
+    circuitBreaker: bank.circuitBreaker,
+    decimals: bank.decimals,
+    tvlRaw: toBigInt(bank.data.accounting.tvl),
+    tvlUsd: toUiAmount(bank.data.accounting.tvl, TVL_USD_DECIMAL_PLACES),
+    sharePrice: bank.sharePrice,
+    totalShares: bank.totalShares,
+    lastRefreshedTs: toBigInt(bank.data.accounting.lastRefreshedTs),
+    lastRebalancedTs: toBigInt(bank.data.accounting.lastRebalancedTs),
+    isTimelocked: getTimelockStatus(
+      environment,
+      bank.data.config.timeCreatedTs,
+      "touch",
+      timelockOptions
+    ).isTimelocked,
+    defaultRedemptionMint,
+    defaultRedemptionSymbol: defaultRedemptionMint
+      ? mintSymbol(defaultRedemptionMint, mintRegistry)
+      : undefined,
+    holdings,
+    externalYieldingPositions,
+  };
+}
+
+export async function buildTokenInspectSnapshot(
+  token: LYCToken,
+  args: TokenInspectSnapshotArgs
+): Promise<EnrichedTokenSnapshot> {
+  const { environment, mintRegistry, yieldingBanks, kaminoData } = args;
+  const collateralSymbol = mintSymbol(token.collateralMint, mintRegistry);
+  const [collateralRealtimePrices, collateralEmaPrices] = await Promise.all([
+    oracle.fetchPrices([token.collateralMint], "realtime", undefined, environment),
+    oracle.fetchPrices([token.collateralMint], "ema", undefined, environment),
+  ]);
+  const collateralRealtimePriceUi = collateralRealtimePrices[token.collateralMint];
+  const collateralEmaPriceUi = collateralEmaPrices[token.collateralMint];
+
+  const lendingPositions = (
+    await Promise.all(
+      token.data.lendingPositions.map((position, index) =>
+        buildLendingPositionInspectSnapshot(
+          position,
+          index,
+          collateralSymbol,
+          token.data.collateral.decimals,
+          kaminoData,
+          mintRegistry
+        )
+      )
+    )
+  ).filter((position): position is EnrichedTokenLendingPosition => position !== undefined);
+
+  const carryPositions = token.data.debtCarry
+    .map((carry, index) => {
+      if (carry.yieldingBaseMint.equals(PublicKey.default) || toBigInt(carry.shares) <= BigInt(0)) {
+        return undefined;
+      }
+
+      const baseMint = fromWeb3Pk(carry.yieldingBaseMint);
+      const resolvedBank = yieldingBanks.find(
+        (bank) => bank.id === carry.yieldingBankId && bank.baseMint === baseMint
+      );
+
+      const position: EnrichedTokenCarryPosition = {
+        index,
+        yieldingBankId: carry.yieldingBankId,
+        yieldingBankAddress: resolvedBank?.address,
+        baseMint,
+        baseSymbol: mintSymbol(baseMint, mintRegistry),
+        sharesRaw: toBigInt(carry.shares),
+        sharesUi: resolvedBank ? toUiAmount(carry.shares, resolvedBank.decimals) : undefined,
+        shareDecimals: resolvedBank?.decimals,
+        tvlUsdRaw: toBigInt(carry.tvlUsd),
+        tvlUsd: toUiAmount(carry.tvlUsd, TVL_USD_DECIMAL_PLACES),
+      };
+
+      return position;
+    })
+    .filter((position): position is EnrichedTokenCarryPosition => position !== undefined);
+
+  const totalCarryTvlUsdRaw = carryPositions.reduce(
+    (sum, position) => sum + position.tvlUsdRaw,
+    0n
+  );
+  const totalDebtUsdRaw = lendingPositions.reduce(
+    (sum, position) => sum + position.debtTvlUsdRaw,
+    0n
+  );
+  // Net yield is the full active-carry surplus above active debt.
+  const netYieldUsdRaw = collectableNetYieldUsd(totalCarryTvlUsdRaw, totalDebtUsdRaw);
+  const apyReferencePriceRaw = toBigInt(token.data.feeDrip.apyReferencePrice);
+  const feeDripMetrics = calculateFeeDripMetrics({
+    currentPriceRaw: toBigInt(token.data.accounting.price),
+    apyReferencePriceRaw,
+    apyReferenceTs: toBigInt(token.data.feeDrip.apyReferenceTs),
+    currentPriceTs: toBigInt(token.data.accounting.lastRefreshedTs),
+    totalSupplyRaw: toBigInt(token.data.accounting.totalSupply),
+    tokenDecimals: token.decimals,
+    undrippedFeeCollateralRaw: toBigInt(token.data.feeDrip.undrippedFeeCollateral),
+    feeDripMaxApyBps: token.data.fees.feeDripMaxApyBps,
+    feeDripDurationSecs: toBigInt(token.data.fees.feeDripDurationSecs),
+    dripEndTs: toBigInt(token.data.feeDrip.dripEndTs),
+    nowTs: BigInt(args.nowTs ?? Math.floor(Date.now() / 1000)),
+  });
+
+  return {
+    address: token.address,
+    id: token.id,
+    curator: fromWeb3Pk(token.data.roles.curator),
+    mint: token.mint,
+    decimals: token.decimals,
+    isActive: token.isActive,
+    price: token.price,
+    totalSupply: token.totalSupply,
+    tvlUsdRaw: toBigInt(token.data.accounting.tvlUsd),
+    tvlUsd: toUiAmount(token.data.accounting.tvlUsd, TVL_USD_DECIMAL_PLACES),
+    lastRefreshedTs: toBigInt(token.data.accounting.lastRefreshedTs),
+    firstMintTs: toBigInt(token.data.accounting.firstMintTs),
+    collateral: {
+      mint: token.collateralMint,
+      symbol: collateralSymbol,
+      decimals: token.data.collateral.decimals,
+      unlentAmountRaw: toBigInt(token.data.collateral.unlentAmount),
+      unlentAmountUi: toUiAmount(
+        token.data.collateral.unlentAmount,
+        token.data.collateral.decimals
+      ),
+      pendingUnwindResidualRaw: toBigInt(token.data.accounting.pendingUnwindResidual),
+      pendingUnwindResidualUi: toUiAmount(
+        token.data.accounting.pendingUnwindResidual,
+        token.data.collateral.decimals
+      ),
+      oraclePriceRaw: toBigInt(token.data.collateral.price),
+      oraclePriceOnChainUi: toUiAmount(token.data.collateral.price, token.data.collateral.decimals),
+      oraclePriceRealtimeUi: collateralRealtimePriceUi,
+      oraclePriceEmaUi: collateralEmaPriceUi,
+      oracle: fromWeb3Pk(token.data.collateral.oracle),
+      secondaryOracle: token.data.collateral.secondaryOracle.equals(PublicKey.default)
+        ? undefined
+        : fromWeb3Pk(token.data.collateral.secondaryOracle),
+      lastRefreshedTs: toBigInt(token.data.collateral.lastRefreshedTs),
+    },
+    lendingPositions,
+    carryPositions,
+    carrySummary: {
+      totalCarryTvlUsdRaw,
+      totalCarryTvlUsd: toUiAmount(totalCarryTvlUsdRaw, TVL_USD_DECIMAL_PLACES),
+      totalDebtUsdRaw,
+      totalDebtUsd: toUiAmount(totalDebtUsdRaw, TVL_USD_DECIMAL_PLACES),
+      netYieldUsdRaw,
+      netYieldUsd: toUiAmount(netYieldUsdRaw, TVL_USD_DECIMAL_PLACES),
+    },
+    hasInterestToCollect: token.hasInterestToCollect(),
+    fees: {
+      mintingFeeBps: token.data.fees.mintingFeeBps,
+      burningFeeBps: token.data.fees.burningFeeBps,
+      performanceFeeBps: token.data.fees.performanceFeeBps,
+      protocolMintBurnPctBps: token.data.fees.protocolMintBurnPctBps,
+      curatorMintBurnPctBps: token.data.fees.curatorMintBurnPctBps,
+      holderMintBurnPctBps:
+        10_000 - token.data.fees.protocolMintBurnPctBps - token.data.fees.curatorMintBurnPctBps,
+      curatorPerfPctBps: token.data.fees.curatorPerfPctBps,
+      feeDripMaxApyBps: token.data.fees.feeDripMaxApyBps,
+      feeDripDurationSecs: toBigInt(token.data.fees.feeDripDurationSecs),
+      undrippedFeeCollateralRaw: toBigInt(token.data.feeDrip.undrippedFeeCollateral),
+      undrippedFeeCollateralUi: toUiAmount(
+        token.data.feeDrip.undrippedFeeCollateral,
+        token.data.collateral.decimals
+      ),
+      dripEndTs: toBigInt(token.data.feeDrip.dripEndTs),
+      apyReferencePriceRaw,
+      apyReferencePrice: toUiAmount(apyReferencePriceRaw, token.decimals),
+      apyReferenceTs: toBigInt(token.data.feeDrip.apyReferenceTs),
+      currentApyBps: feeDripMetrics.currentApyBps,
+      absorptionEtaSeconds: feeDripMetrics.absorptionEtaSeconds,
+      absorptionStatus: feeDripMetrics.absorptionStatus,
+      pendingProtocolFeesRaw: toBigInt(token.data.accounting.pendingProtocolFees),
+      pendingProtocolFeesUi: toUiAmount(token.data.accounting.pendingProtocolFees, token.decimals),
+      pendingCuratorFeesRaw: toBigInt(token.data.accounting.pendingCuratorFees),
+      pendingCuratorFeesUi: toUiAmount(token.data.accounting.pendingCuratorFees, token.decimals),
+    },
+  };
+}
+
+async function buildLendingPositionInspectSnapshot(
+  position: TokenLendingPositionData,
+  index: number,
+  collateralSymbol: string,
+  collateralDecimals: number,
+  kaminoData: LendingPlatformData,
+  mintRegistry: MintRegistry
+): Promise<EnrichedTokenLendingPosition | undefined> {
+  const platform = lendingPlatformToEnum(position.platform);
+  if (platform === LendingPlatform.None) {
+    return undefined;
+  }
+
+  let inspectMetrics;
+  if (platform === LendingPlatform.Kamino) {
+    try {
+      const manager = await LycLendingPositionManager.create(kaminoData, position);
+      inspectMetrics = (await manager.getInspectMetrics()) ?? undefined;
+    } catch {
+      inspectMetrics = undefined;
+    }
+  }
+
+  const debtMint = fromWeb3Pk(position.accounting.debt.mint);
+  return {
+    index,
+    platform,
+    withdrawPending: podBoolToNumber(position.withdrawPending) !== 0,
+    pool: fromWeb3Pk(position.pool),
+    userAccount: fromWeb3Pk(position.protocolUserAcc),
+    collateralAmountRaw: toBigInt(position.accounting.collateral),
+    collateralAmountUi: toUiAmount(position.accounting.collateral, collateralDecimals),
+    collateralDecimals,
+    collateralSymbol,
+    debtAmountRaw: toBigInt(position.accounting.debt.amount),
+    debtAmountUi: toUiAmount(position.accounting.debt.amount, position.accounting.debt.decimals),
+    debtTvlUsdRaw: toBigInt(position.accounting.debt.tvlUsd),
+    debtTvlUsd: toUiAmount(position.accounting.debt.tvlUsd, TVL_USD_DECIMAL_PLACES),
+    debtMint,
+    debtSymbol: mintSymbol(debtMint, mintRegistry),
+    debtDecimals: position.accounting.debt.decimals,
+    debtPriceRaw: toBigInt(position.accounting.debt.price),
+    debtPriceUi: toUiAmount(position.accounting.debt.price, position.accounting.debt.decimals),
+    onChainUtilizationRateBps: position.accounting.ltvUtilizationRateBps,
+    targetUtilizationRateBps: position.config.targetUtilizationRateBps,
+    maxDeviationAboveTargetUtilBps: position.config.maxDeviationAboveTargetUtilBps,
+    maxDeviationBelowTargetUtilBps: position.config.maxDeviationBelowTargetUtilBps,
+    lastRebalancedTs: toBigInt(position.lastUpdatedTs),
+    inspectMetrics,
+  };
+}