@kestrelfi/lyc-sdk 1.0.1 → 1.0.3

package/src/utils/feeDripMetrics.ts

@@ -1,146 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,227 +0,0 @@
-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

@@ -1,221 +0,0 @@
-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,
-  };
-}