@kestrelfi/lyc-sdk 1.0.1

package/src/utils/feeDripMetrics.ts

@@ -0,0 +1,146 @@
+const BASIS_POINTS = 10_000;
+const SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
+
+export type FeeDripAbsorptionStatus =
+  | "estimated"
+  | "no_fees"
+  | "parked"
+  | "apy_saturated"
+  | "unavailable";
+
+export interface FeeDripMetricsInput {
+  currentPriceRaw: bigint;
+  apyReferencePriceRaw: bigint;
+  apyReferenceTs: bigint;
+  /** Timestamp at which `currentPriceRaw` was last written on-chain. */
+  currentPriceTs: bigint;
+  totalSupplyRaw: bigint;
+  tokenDecimals: number;
+  undrippedFeeCollateralRaw: bigint;
+  feeDripMaxApyBps: number;
+  feeDripDurationSecs: bigint;
+  dripEndTs: bigint;
+  nowTs: bigint;
+}
+
+export interface FeeDripMetrics {
+  /** Simple annualized price return from the on-chain APY reference, in basis points. */
+  currentApyBps: number | null;
+  /** Estimated seconds until the current fee buffer is fully released. */
+  absorptionEtaSeconds: number | null;
+  absorptionStatus: FeeDripAbsorptionStatus;
+}
+
+/**
+ * Derives the current fee-window APY and the time needed to release the
+ * outstanding fee buffer if the observed APY remains constant.
+ *
+ * The buffer's price impact is:
+ *   fee_price_delta [price units]
+ *     = buffer [collateral base units] * 10^token_decimals / supply [yToken base units]
+ *
+ * Dividing by the current price gives the remaining holder return. Dividing
+ * that return by `(max_apy - current_apy) [return/year]` gives the APY-limited
+ * release time in years. The actual estimate is the slower of that limit and
+ * the remaining linear drip schedule.
+ */
+export function calculateFeeDripMetrics(input: FeeDripMetricsInput): FeeDripMetrics {
+  const currentApyBps = calculateCurrentApyBps(input);
+
+  if (input.undrippedFeeCollateralRaw <= BigInt(0)) {
+    return {
+      currentApyBps,
+      absorptionEtaSeconds: 0,
+      absorptionStatus: "no_fees",
+    };
+  }
+
+  if (input.feeDripDurationSecs <= BigInt(0)) {
+    return {
+      currentApyBps,
+      absorptionEtaSeconds: null,
+      absorptionStatus: "parked",
+    };
+  }
+
+  const estimateTs = input.nowTs > input.currentPriceTs ? input.nowTs : input.currentPriceTs;
+  const linearEtaSeconds = Number(
+    input.dripEndTs > estimateTs ? input.dripEndTs - estimateTs : BigInt(0)
+  );
+
+  if (input.feeDripMaxApyBps === 0) {
+    return finiteEstimate(currentApyBps, linearEtaSeconds);
+  }
+
+  if (
+    currentApyBps == null ||
+    input.currentPriceRaw <= BigInt(0) ||
+    input.totalSupplyRaw <= BigInt(0) ||
+    input.tokenDecimals < 0
+  ) {
+    return {
+      currentApyBps,
+      absorptionEtaSeconds: null,
+      absorptionStatus: "unavailable",
+    };
+  }
+
+  const availableApyBps = input.feeDripMaxApyBps - currentApyBps;
+  if (availableApyBps <= 0) {
+    return {
+      currentApyBps,
+      absorptionEtaSeconds: null,
+      absorptionStatus: "apy_saturated",
+    };
+  }
+
+  let scale = BigInt(1);
+  for (let decimal = 0; decimal < input.tokenDecimals; decimal += 1) {
+    scale *= BigInt(10);
+  }
+  const remainingPriceReturn =
+    Number(input.undrippedFeeCollateralRaw * scale) /
+    Number(input.totalSupplyRaw * input.currentPriceRaw);
+  const availableAnnualReturn = availableApyBps / BASIS_POINTS;
+  const apyEtaSeconds = Math.ceil(
+    (remainingPriceReturn / availableAnnualReturn) * SECONDS_PER_YEAR
+  );
+
+  return finiteEstimate(currentApyBps, Math.max(linearEtaSeconds, apyEtaSeconds));
+}
+
+function calculateCurrentApyBps(input: FeeDripMetricsInput): number | null {
+  if (
+    input.currentPriceRaw <= BigInt(0) ||
+    input.apyReferencePriceRaw <= BigInt(0) ||
+    input.apyReferenceTs <= BigInt(0) ||
+    input.currentPriceTs <= input.apyReferenceTs
+  ) {
+    return null;
+  }
+
+  const elapsedSeconds = Number(input.currentPriceTs - input.apyReferenceTs);
+  const priceReturn = Number(input.currentPriceRaw) / Number(input.apyReferencePriceRaw) - 1;
+  const currentApyBps = priceReturn * (SECONDS_PER_YEAR / elapsedSeconds) * BASIS_POINTS;
+
+  return Number.isFinite(currentApyBps) ? currentApyBps : null;
+}
+
+function finiteEstimate(
+  currentApyBps: number | null,
+  absorptionEtaSeconds: number
+): FeeDripMetrics {
+  if (!Number.isFinite(absorptionEtaSeconds) || absorptionEtaSeconds < 0) {
+    return {
+      currentApyBps,
+      absorptionEtaSeconds: null,
+      absorptionStatus: "unavailable",
+    };
+  }
+
+  return {
+    currentApyBps,
+    absorptionEtaSeconds: Math.ceil(absorptionEtaSeconds),
+    absorptionStatus: "estimated",
+  };
+}

package/src/utils/general.ts

@@ -0,0 +1,54 @@
+import { BN } from "@anchor-lang/core";
+import type { Address } from "@solana/kit";
+import { fromUiAmount } from "common";
+import type { YieldingBankExternalLiquiditySource } from "../client/types";
+
+/**
+ * PodBool is a Rust `#[repr(transparent)]` newtype over `u8`.
+ * Anchor deserializes tuple-struct fields using positional integer keys, so
+ * `PodBool(1)` arrives from the RPC as `{ '0': 1 }` instead of a plain number.
+ *
+ * This helper extracts the underlying u8 value so callers work with a plain
+ * number rather than the intermediate struct object.
+ */
+export function podBoolToNumber(val: { 0: number } | number): number {
+  if (typeof val === "number") return val;
+  return (val as Record<string | number, number>)[0] ?? 0;
+}
+
+/**
+ * Build external-liquidity source descriptors for one mint across multiple accounts.
+ */
+export function toYieldingBankExternalLiquiditySources(
+  mint: Address,
+  accounts: Address[]
+): YieldingBankExternalLiquiditySource[] {
+  return accounts.map((account) => ({ mint, account }));
+}
+
+/**
+ * Convert a raw token amount and raw oracle price into 8-decimal USD TVL units.
+ */
+export function amountToTvl(
+  amount: number | bigint | BN,
+  price: number | bigint | BN,
+  decimals: number
+): BN {
+  const amountBn = new BN(amount.toString());
+  const priceBn = new BN(price.toString());
+  const assetScale = fromUiAmount(1, decimals);
+  const tvlScale = fromUiAmount(1, 8);
+  const scaleFactor = assetScale.mul(assetScale).div(tvlScale);
+  return amountBn.mul(priceBn).div(scaleFactor);
+}
+
+const EPOCH_BUCKET_MS = 60_000;
+
+/**
+ * Generate a redemption epoch ID by flooring `Date.now()` to the nearest minute.
+ * Burns within the same 60-second window will share an epoch PDA, allowing the
+ * manager to batch-process them together.
+ */
+export function currentEpochId(): BN {
+  return new BN(Math.floor(Date.now() / EPOCH_BUCKET_MS) * EPOCH_BUCKET_MS);
+}

package/src/utils/index.ts

@@ -0,0 +1,13 @@
+export * from "./enrichment";
+export * from "./lycData";
+export * from "./lookupTables";
+export * from "./ix";
+export * from "./general";
+export * from "./data";
+export * from "./cache";
+export * from "./transactions";
+export * from "./lendingPosition";
+export * from "./yieldingBank";
+export * from "./timelock";
+export * from "./tokenFeeMath";
+export * from "./feeDripMetrics";

package/src/utils/ix.ts

@@ -0,0 +1,227 @@
+import { type Address } from "@solana/kit";
+import { IdlTypes } from "@anchor-lang/core";
+import {
+  IX_SYSVAR_META,
+  createMultiCpiRefs,
+  type CustomAccountMeta,
+  type InstructionRefs,
+  toWeb3Pk,
+  toCustomAccountMeta,
+} from "common";
+import type { LongYieldCarry } from "../idl/long_yield_carry";
+import type {
+  AssetConfig,
+  AssetAllocationConfig,
+  DecreaseCarryPositionPlan,
+  ExternalPositionConfig,
+  YieldingBankAllocationConfig,
+} from "../client/types";
+
+function toAnchorAssetConfig(cfg: AssetConfig) {
+  return {
+    oracle: toWeb3Pk(cfg.oracle),
+    oracleType: cfg.oracleType,
+    externalLiquidity: cfg.externalLiquidityType,
+  };
+}
+
+function toAnchorAssetAllocationConfig(cfg: AssetAllocationConfig) {
+  return {
+    mint: toWeb3Pk(cfg.mint),
+    decimals: cfg.decimals,
+    tokenProgram: cfg.tokenProgram,
+  };
+}
+
+function toAnchorExternalPositionConfig(cfg: ExternalPositionConfig) {
+  return {
+    lendingPlatform: cfg.lendingPlatform,
+    lendingType: cfg.lendingType,
+    pool: toWeb3Pk(cfg.pool),
+    collateralReserve: toWeb3Pk(cfg.collateralReserve),
+    debtReserve: toWeb3Pk(cfg.debtReserve),
+    protocolUserAcc: toWeb3Pk(cfg.protocolUserAcc),
+    collateral: toAnchorAssetAllocationConfig(cfg.collateral),
+    debt: toAnchorAssetAllocationConfig(cfg.debt),
+  };
+}
+
+export function toAnchorAllocationConfig(
+  cfg: YieldingBankAllocationConfig
+): IdlTypes<LongYieldCarry>["yieldingBankAllocationConfig"] {
+  return {
+    assetHolding: cfg.assetHolding ? toAnchorAssetConfig(cfg.assetHolding) : null,
+    externalPosition: cfg.externalPosition
+      ? toAnchorExternalPositionConfig(cfg.externalPosition)
+      : null,
+  };
+}
+
+/**
+ * Build the carry-trade account metas that are prepended to remaining_accounts
+ * for increase/decrease carry position instructions.
+ *
+ * The two ATA accounts are tagged with `isRequiredAta` so that
+ * `getCreateAtaInstructions` will create them if they don't yet exist.
+ *
+ * Order must match `parse_carry_trade_accounts` on the Rust side:
+ *   0. token              (writable)
+ *   1. yieldingBank       (writable)
+ *   2. tokenLpDebtTa      (writable, ATA)
+ *   3. yieldingBankTa     (writable, ATA)
+ *   4. lendingPositionUserAccount (readonly)
+ *   5. lendingPositionCollateralReserve (readonly)
+ *   6. debtOracle         (readonly)
+ *   7. debtTokenProgram   (readonly)
+ *   8. instructions_sysvar (readonly)
+ */
+export function buildCarryTradeAccountMetas(
+  token: Address,
+  yieldingBank: Address,
+  tokenLpDebtTa: Address,
+  yieldingBankTa: Address,
+  lendingPositionUserAccount: Address,
+  lendingPositionCollateralReserve: Address,
+  debtOracle: Address,
+  debtMint: Address,
+  debtTokenProgram: Address
+): CustomAccountMeta[] {
+  return [
+    toCustomAccountMeta(token, true),
+    toCustomAccountMeta(yieldingBank, true),
+    toCustomAccountMeta(tokenLpDebtTa, true, {
+      owner: token,
+      mint: debtMint,
+      tokenProgram: debtTokenProgram,
+    }),
+    toCustomAccountMeta(yieldingBankTa, true, {
+      owner: yieldingBank,
+      mint: debtMint,
+      tokenProgram: debtTokenProgram,
+    }),
+    toCustomAccountMeta(lendingPositionUserAccount),
+    toCustomAccountMeta(lendingPositionCollateralReserve),
+    toCustomAccountMeta(debtOracle),
+    toCustomAccountMeta(debtTokenProgram),
+    IX_SYSVAR_META,
+  ];
+}
+
+/**
+ * Build the initial remaining-accounts prefix for `rebalance_token`.
+ *
+ * Order must match `RebalanceTokenAccounts::parse` on the Rust side:
+ *   0. token                              (writable)
+ *   1. yieldingBank                       (writable)
+ *   2. sourceDebtTokenProgram             (readonly)
+ *   3. yieldingBankSourceDebtAta          (writable, ATA)
+ *   4. sourceLpUserAccount                (readonly)
+ *   5. sourceLpCollateralReserve          (readonly)
+ *   6. sourceLpDebtOracle                 (readonly — also serves as the
+ *                                          dust-sweep source_debt_oracle)
+ *   7. destinationLpUserAccount           (readonly)
+ *   8. destinationLpCollateralReserve     (readonly)
+ *   9. destinationLpDebtOracle            (readonly)
+ *
+ * The destination debt mint is referenced by inner CPIs (borrow / swap) and
+ * reaches the pool through CPI dedup; it does not need a fixed slot here.
+ * The token PDA's source-debt ATA is part of the flash-borrow / repay path
+ * and is also resolved at runtime from the CPI account pool — only the
+ * yielding-bank's source-debt ATA needs an explicit slot for the dust sweep.
+ */
+export function buildRebalanceTokenInitialAccounts(args: {
+  token: Address;
+  yieldingBank: Address;
+  sourceDebtMint: Address;
+  sourceDebtTokenProgram: Address;
+  yieldingBankSourceDebtAta: Address;
+  lpUserAccount: Address;
+  sourceDebtOracle: Address;
+  destinationDebtOracle: Address;
+}): CustomAccountMeta[] {
+  return [
+    toCustomAccountMeta(args.token, true),
+    toCustomAccountMeta(args.yieldingBank, true),
+    toCustomAccountMeta(args.sourceDebtTokenProgram),
+    toCustomAccountMeta(args.yieldingBankSourceDebtAta, true, {
+      owner: args.yieldingBank,
+      mint: args.sourceDebtMint,
+      tokenProgram: args.sourceDebtTokenProgram,
+    }),
+    toCustomAccountMeta(args.lpUserAccount),
+    toCustomAccountMeta(args.sourceDebtOracle),
+    toCustomAccountMeta(args.destinationDebtOracle),
+  ];
+}
+
+/**
+ * Normalize grouped CPI refs for `decrease_carry_position`.
+ *
+ * The plan can contain either:
+ * - one group: repay only, or
+ * - two groups: yielding-bank swap/redeem first, then repay.
+ */
+export function resolveDecreaseCarryIxRefs(
+  refsGroups: InstructionRefs[],
+  options?: { hasTokenPrerequisiteCpis?: boolean }
+): {
+  ybIxRefs?: InstructionRefs;
+  prerequisiteCpis?: InstructionRefs;
+  tokenIxRefs: InstructionRefs;
+} {
+  const hasTokenPrerequisiteCpis = options?.hasTokenPrerequisiteCpis ?? false;
+  const lastRefs = refsGroups[refsGroups.length - 1];
+
+  if (!lastRefs) {
+    throw new Error("Expected at least one CPI ref group for decrease carry flow");
+  }
+
+  const prerequisiteCpis = hasTokenPrerequisiteCpis ? refsGroups[refsGroups.length - 2] : undefined;
+  if (hasTokenPrerequisiteCpis && !prerequisiteCpis) {
+    throw new Error("Expected prerequisite CPI ref group for decrease carry flow");
+  }
+
+  const ybIxRefs =
+    refsGroups[0] && refsGroups[0] !== prerequisiteCpis && refsGroups[0] !== lastRefs
+      ? refsGroups[0]
+      : undefined;
+
+  return {
+    tokenIxRefs: lastRefs,
+    ...(prerequisiteCpis ? { prerequisiteCpis } : {}),
+    ...(ybIxRefs ? { ybIxRefs } : {}),
+  };
+}
+
+export interface ResolvedDecreaseCarryCpiPlan {
+  accounts: CustomAccountMeta[];
+  lookupTables: Address[];
+  ybIxRefs?: InstructionRefs;
+  prerequisiteCpis?: InstructionRefs;
+  tokenIxRefs: InstructionRefs;
+}
+
+/**
+ * Build the grouped CPI pool for `decrease_carry_position` and normalize the
+ * resulting ref groups into the instruction params the SDK passes on-chain.
+ */
+export function resolveDecreaseCarryCpiPlan(
+  plan: DecreaseCarryPositionPlan
+): ResolvedDecreaseCarryCpiPlan {
+  const cpiDataGroups = [
+    ...(plan.cpiDataGroups.length === 2 ? [plan.cpiDataGroups[0]] : []),
+    ...(plan.tokenPrerequisiteCpis?.length ? [plan.tokenPrerequisiteCpis] : []),
+    plan.cpiDataGroups[plan.cpiDataGroups.length - 1],
+  ];
+  const { accounts, refsGroups, lookupTables } = createMultiCpiRefs(cpiDataGroups, {
+    initialAccounts: plan.initialAccounts,
+  });
+
+  return {
+    accounts,
+    lookupTables,
+    ...resolveDecreaseCarryIxRefs(refsGroups, {
+      hasTokenPrerequisiteCpis: Boolean(plan.tokenPrerequisiteCpis?.length),
+    }),
+  };
+}

package/src/utils/lendingPosition.ts

@@ -0,0 +1,221 @@
+import { type Address } from "@solana/kit";
+import {
+  enumToLendingPlatform,
+  enumToOracleType,
+  enumToTokenProgram,
+  LendingPlatform,
+  lendingPlatformToEnum,
+  TokenProgram,
+  fromWeb3Pk,
+  mints,
+} from "common";
+import {
+  getEligiblePools,
+  type LendingPlatformClientBase,
+  type LendingPlatformData,
+} from "lending-platforms";
+import { oracle } from "oracle";
+import type { LYCToken } from "../models/lycToken";
+import type {
+  CreateTokenLendingPositionAccounts,
+  CreateTokenLendingPositionParams,
+} from "../client/types";
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export interface BuildLendingPositionAllocationArgs {
+  /** Lending platform client used to resolve reserves and user accounts. */
+  lendingClient: LendingPlatformClientBase<LendingPlatformData>;
+  /** Token PDA that will own the lending position. */
+  tokenPda: Address;
+  /** Collateral mint address. Used to resolve the collateral reserve in the pool. */
+  collateralMint: Address;
+  /** Debt mint address. Decimals and token program are resolved from the mint registry. */
+  debtMint: Address;
+  /** Debt reserve address. If omitted, looked up from the pool by `debtMint`. */
+  debtReserve?: Address;
+  /** Obligation / user-account ID within the lending pool. */
+  userAccountId: number;
+  /**
+   * Lending pool address. When omitted, resolved automatically from the
+   * collateral mint via {@link getEligiblePools}. Throws if the mint is
+   * listed in zero or multiple pools (caller must disambiguate).
+   */
+  pool?: Address;
+  /** @default LendingPlatform.Kamino */
+  lendingPlatform?: LendingPlatform;
+  /** @default 9000 */
+  targetUtilizationRateBps?: number;
+  /** @default 150 */
+  maxDeviationAboveTargetUtilBps?: number;
+  /** @default 300 */
+  maxDeviationBelowTargetUtilBps?: number;
+}
+
+export interface LendingPositionAllocation {
+  params: CreateTokenLendingPositionParams;
+  accounts: CreateTokenLendingPositionAccounts;
+  pool: Address;
+  collateralReserve: Address;
+  debtReserve: Address;
+  protocolUserAccount: Address;
+  userAccountId: number;
+}
+
+const DEFAULT_TARGET_UTILIZATION_RATE_BPS = 9000;
+
+export interface GetAvailableTokenLendingUserAccountIdArgs {
+  lendingClient: LendingPlatformClientBase<LendingPlatformData>;
+  token: LYCToken;
+  pool: Address;
+  lendingPlatform?: LendingPlatform;
+}
+
+// =============================================================================
+// Pool resolution
+// =============================================================================
+
+/**
+ * Resolves the lending pool for a collateral mint when the caller didn't
+ * supply one explicitly. Uses the static `KAMINO_ACCOUNTS` registry to
+ * find which pool(s) list the mint.
+ *
+ * - Exactly one pool   → returns it.
+ * - Zero pools         → throws (mint not listed anywhere).
+ * - Multiple pools     → throws (caller must pass `pool` to disambiguate).
+ */
+export function resolveDefaultPool(collateralMint: Address): Address {
+  const mintInfo = mints.get(collateralMint);
+  const symbol = mintInfo?.symbol ?? String(collateralMint);
+
+  const eligible = getEligiblePools(symbol);
+
+  if (eligible.length === 0) {
+    throw new Error(
+      `resolveDefaultPool: collateral mint ${symbol} (${collateralMint}) is not listed in any known lending pool`
+    );
+  }
+
+  if (eligible.length > 1) {
+    throw new Error(
+      `resolveDefaultPool: collateral mint ${symbol} is listed in multiple pools — ` +
+        `pass \`pool\` explicitly. Eligible pools:\n` +
+        eligible.map((m) => `  ${m}`).join("\n")
+    );
+  }
+
+  return eligible[0];
+}
+
+export async function getAvailableTokenLendingUserAccountId({
+  lendingClient,
+  token,
+  pool,
+  lendingPlatform = LendingPlatform.Kamino,
+}: GetAvailableTokenLendingUserAccountIdArgs): Promise<number> {
+  const activeProtocolUserAccounts = token.activeLendingPositions
+    .filter(({ data }) => lendingPlatformToEnum(data.platform) === lendingPlatform)
+    .map(({ data }) => fromWeb3Pk(data.protocolUserAcc));
+
+  return lendingClient.getAvailableUserAccountId(pool, token.address, activeProtocolUserAccounts);
+}
+
+// =============================================================================
+// Builder
+// =============================================================================
+
+/**
+ * Resolves reserves, oracle data, and user-account PDA, then assembles a
+ * `CreateTokenLendingPositionParams` ready for `ix.createTokenLendingPosition`.
+ *
+ * The collateral reserve is resolved from the collateral mint against the pool.
+ * Debt metadata (decimals, token program) is resolved from the mint registry;
+ * the debt reserve address is either provided directly or looked up by mint.
+ */
+export async function buildLendingPositionAllocation(
+  args: BuildLendingPositionAllocationArgs
+): Promise<LendingPositionAllocation> {
+  const {
+    lendingClient,
+    tokenPda,
+    collateralMint,
+    debtMint,
+    userAccountId,
+    lendingPlatform = LendingPlatform.Kamino,
+    targetUtilizationRateBps = DEFAULT_TARGET_UTILIZATION_RATE_BPS,
+    maxDeviationAboveTargetUtilBps = 150,
+    maxDeviationBelowTargetUtilBps = 300,
+  } = args;
+
+  const debtMintInfo = mints.get(debtMint);
+  if (!debtMintInfo) {
+    throw new Error(
+      `buildLendingPositionAllocation: debt mint ${debtMint} not found in mint registry`
+    );
+  }
+
+  const pool = args.pool ?? resolveDefaultPool(collateralMint);
+
+  const collateralReserve = await lendingClient.data.fetchReserveByMint(pool, collateralMint);
+  if (!collateralReserve) {
+    throw new Error(
+      `buildLendingPositionAllocation: no reserve found for collateral mint ${collateralMint} in pool ${pool}`
+    );
+  }
+  const collateralReserveAddress = collateralReserve.address;
+
+  let debtReserveAddress: Address;
+  if (args.debtReserve) {
+    debtReserveAddress = args.debtReserve;
+  } else {
+    const reserve = await lendingClient.data.fetchReserveByMint(pool, debtMint);
+    if (!reserve) {
+      throw new Error(
+        `buildLendingPositionAllocation: no reserve found for debt mint ${debtMint} in pool ${pool}`
+      );
+    }
+    debtReserveAddress = reserve.address;
+  }
+
+  const protocolUserAccount = await lendingClient.accounts.getUserAccountAddress(
+    pool,
+    tokenPda,
+    userAccountId
+  );
+
+  const debtOracleData = oracle.getOracleData(debtMint);
+  const debtTokenProgram = enumToTokenProgram(
+    debtMintInfo.isToken2022 ? TokenProgram.Token2022 : TokenProgram.Spl
+  );
+
+  const params: CreateTokenLendingPositionParams = {
+    lendingPlatform: enumToLendingPlatform(lendingPlatform),
+    pool,
+    debtReserve: debtReserveAddress,
+    targetUtilizationRateBps,
+    maxDeviationAboveTargetUtilBps,
+    maxDeviationBelowTargetUtilBps,
+    debtMint,
+    debtDecimals: debtMintInfo.decimals,
+    debtTokenProgram,
+    debtOracleType: enumToOracleType(debtOracleData.oracleType),
+  };
+
+  const accounts: CreateTokenLendingPositionAccounts = {
+    protocolUserAcc: protocolUserAccount,
+    collateralReserve: collateralReserveAddress,
+    debtOracle: debtOracleData.oracle,
+  };
+
+  return {
+    params,
+    accounts,
+    pool,
+    collateralReserve: collateralReserveAddress,
+    debtReserve: debtReserveAddress,
+    protocolUserAccount,
+    userAccountId,
+  };
+}