@kestrelfi/lyc-sdk 1.0.1

package/dist/sdks/long-yield-carry/src/services/redemption/redemptionService.js

@@ -0,0 +1,532 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedemptionService = void 0;
+const common_1 = require("common");
+const general_1 = require("../../constants/general");
+const lendingPosition_1 = require("../lendingPosition");
+const EPOCH_WINDOW_MS = 60000;
+const DEFAULT_DCP_SWAP_SLIPPAGE_BPS = 100;
+// Retries after the initial attempt (3 attempts total). Each attempt
+// re-fetches a fresh swap quote.
+const DCP_MAX_RETRIES = 2;
+// Mirrors on-chain UTILIZATION_RATE_DEVIATION_THRESHOLD_BPS (150 bps relative margin).
+const UTILIZATION_RATE_DEVIATION_THRESHOLD_BPS = 150;
+// Extra fraction added to partial withdrawals so Kamino rounding never leaves
+// the epoch a few lamports short. 0.1% is well within the utilization margin.
+const WITHDRAWAL_OVERSHOOT_BPS = 10;
+function emptyFundingErrors() {
+    return { dcp: [], withdraw: [] };
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function errorNameAndMessage(err) {
+    if (err instanceof Error)
+        return `${err.name}: ${err.message}`;
+    return String(err);
+}
+function compactStack(stack) {
+    return stack
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .slice(0, 12)
+        .join(" | ");
+}
+function errorCause(err) {
+    return err !== null && typeof err === "object" && "cause" in err
+        ? err.cause
+        : undefined;
+}
+function errorDiagnostics(err) {
+    const diagnostics = [];
+    let current = err;
+    for (let depth = 0; current !== undefined && depth < 4; depth += 1) {
+        const prefix = depth === 0 ? "error" : `cause[${depth}]`;
+        diagnostics.push(`${prefix}: ${errorNameAndMessage(current)}`);
+        if (current instanceof Error && current.stack) {
+            diagnostics.push(`${prefix} stack: ${compactStack(current.stack)}`);
+        }
+        current = errorCause(current);
+    }
+    return diagnostics;
+}
+/**
+ * Orchestrates the redemption epoch lifecycle: detecting open epochs, waiting
+ * for their time window to elapse, funding (DCP + top-up), and processing
+ * individual async burn requests.
+ *
+ * Holds a reference to the LYC client and caches yielding-bank PDAs per token
+ * so repeated calls against the same token avoid redundant derivation.
+ */
+class RedemptionService {
+    constructor(client, opts) {
+        this.client = client;
+        this.yieldingBankCache = new Map();
+        this.dcpSwapSlippageBps = opts?.dcpSwapSlippageBps ?? DEFAULT_DCP_SWAP_SLIPPAGE_BPS;
+        this.lpService = new lendingPosition_1.LendingPositionService(client);
+        this.structuredLog = opts?.structuredLog;
+    }
+    // ── Epoch discovery ────────────────────────────────────────────────────────
+    /** Delegates to `client.account.fetchAllRedemptionEpochs`. */
+    async getAllEpochs() {
+        return this.client.account.fetchAllRedemptionEpochs({ fresh: true });
+    }
+    /** Delegates to `client.account.fetchRedemptionEpoch`. */
+    async getEpoch(epochPda) {
+        return this.client.account.fetchRedemptionEpoch(epochPda, { fresh: true });
+    }
+    /** Re-fetches an existing snapshot from on-chain state. */
+    async refreshEpoch(epoch) {
+        return this.getEpoch(epoch.pda);
+    }
+    // ── Epoch window ───────────────────────────────────────────────────────────
+    /**
+     * Returns the number of milliseconds until the epoch's acceptance window
+     * closes. Zero or negative means the window has already elapsed.
+     */
+    epochWindowRemainingMs(epoch) {
+        return Number(epoch.epochId) + EPOCH_WINDOW_MS - Date.now();
+    }
+    /**
+     * Sleeps until the epoch's 60-second acceptance window has elapsed. Returns
+     * immediately if the window is already closed.
+     */
+    async waitForEpochWindow(epoch, log) {
+        const remainingMs = this.epochWindowRemainingMs(epoch);
+        if (remainingMs <= 0) {
+            log?.("Epoch window already closed.");
+            return;
+        }
+        log?.(`Waiting ${Math.ceil(remainingMs / 1000)}s for epoch window to close...`);
+        await new Promise((resolve) => setTimeout(resolve, remainingMs));
+        log?.("Window closed.");
+    }
+    // ── Status transitions ─────────────────────────────────────────────────────
+    /**
+     * Transitions an epoch from Open → Funding. Waits for the epoch window to
+     * close first so in-flight burns can still land.
+     */
+    async closeEpoch(signer, epoch, log) {
+        if (epoch.status !== general_1.REDEMPTION_EPOCH_STATUS_OPEN)
+            return;
+        await this.waitForEpochWindow(epoch, log);
+        log?.("Setting status → Funding...");
+        const plan = await this.client.tx.setRedemptionEpochStatus.getTx({
+            token: epoch.tokenPda,
+            redemptionEpoch: epoch.pda,
+            params: { status: general_1.REDEMPTION_EPOCH_STATUS_FUNDING },
+        });
+        await this.client.sendTransaction(signer, plan);
+        this.client.clearAllCache();
+    }
+    /** Transitions an epoch from Funding → Processing. */
+    async startProcessing(signer, epoch, log) {
+        if (epoch.status > general_1.REDEMPTION_EPOCH_STATUS_FUNDING)
+            return;
+        log?.("Setting status → Processing...");
+        const plan = await this.client.tx.setRedemptionEpochStatus.getTx({
+            token: epoch.tokenPda,
+            redemptionEpoch: epoch.pda,
+            params: { status: general_1.REDEMPTION_EPOCH_STATUS_PROCESSING },
+        });
+        await this.client.sendTransaction(signer, plan);
+        this.client.clearAllCache();
+    }
+    // ── Funding ────────────────────────────────────────────────────────────────
+    /**
+     * Funds a redemption epoch. Withdraws from debt-free LPs first (no DCP
+     * needed), then — if a deficit remains — runs targeted DCP + withdraw on
+     * carry-loaded LPs, prioritizing non-optimal positions.
+     */
+    async fundEpoch(signer, epoch, log) {
+        const fundingErrors = emptyFundingErrors();
+        const fresh = await this.refreshEpoch(epoch);
+        if (this.isFullyFunded(fresh)) {
+            log?.("Already fully funded.");
+            return this.fundResult(fresh, fundingErrors);
+        }
+        const token = await this.client.account.fetchToken(fresh.tokenPda, { fresh: true });
+        const decimals = token.data.collateral.decimals;
+        const deficitUi = this.deficitUi(fresh, decimals);
+        log?.(`Deficit: ${deficitUi}`);
+        await this.fundFromDebtFreeLps(signer, token, fresh, decimals, fundingErrors, log);
+        const afterDirect = await this.refreshEpoch(epoch);
+        if (this.isFullyFunded(afterDirect)) {
+            log?.("Fully funded from debt-free LPs — no DCP needed.");
+            return this.fundResult(afterDirect, fundingErrors);
+        }
+        await this.fundFromCarryLps(signer, fresh.tokenPda, afterDirect, decimals, fundingErrors, log);
+        const afterCarry = await this.refreshEpoch(epoch);
+        if (this.isFullyFunded(afterCarry)) {
+            log?.("Fully funded.");
+            return this.fundResult(afterCarry, fundingErrors);
+        }
+        await this.creditResidualUnlent(signer, afterCarry, decimals, log);
+        const afterResidual = await this.refreshEpoch(epoch);
+        if (this.isFullyFunded(afterResidual)) {
+            log?.("Fully funded from lending positions and residual unlent reserves.");
+        }
+        return this.fundResult(afterResidual, fundingErrors);
+    }
+    // ── Request processing ─────────────────────────────────────────────────────
+    /**
+     * Processes all remaining async burn requests in a redemption epoch in FIFO
+     * order.
+     */
+    async processRequests(signer, epoch, log) {
+        const snap = await this.refreshEpoch(epoch);
+        let processed = 0;
+        for (let seq = snap.processedRequestCount; seq < snap.requestCount; seq++) {
+            const plan = await this.client.tx.processAsyncBurn.getTx({
+                token: snap.tokenPda,
+                params: { epochId: snap.epochId, sequence: seq },
+            });
+            const debug = plan.debug?.processAsyncBurn;
+            if (debug) {
+                const payoutTarget = debug.collateralDelivery === "nativeSol"
+                    ? `native SOL via request escrow ${debug.requestCollateralAccount ?? "unknown"}`
+                    : `user collateral ATA ${debug.userCollateralAccount ?? "unknown"}`;
+                log?.(`Request ${seq}: user ${debug.user}, payout ${payoutTarget}`);
+            }
+            const sig = await this.client.sendTransaction(signer, plan);
+            log?.(`Request ${seq}: ${sig}`);
+            this.client.clearAllCache();
+            processed++;
+        }
+        return { requestsProcessed: processed };
+    }
+    // ── Full lifecycle ─────────────────────────────────────────────────────────
+    /**
+     * Runs the complete epoch lifecycle: close → fund → transition to
+     * processing → process all requests.
+     *
+     * Returns true if the epoch was fully processed and closed.
+     */
+    async processEpoch(signer, epoch, log) {
+        await this.closeEpoch(signer, epoch, log);
+        const afterClose = await this.refreshEpoch(epoch);
+        const fundResult = await this.fundEpoch(signer, afterClose, log);
+        if (fundResult.errors.dcp.length > 0 || fundResult.errors.withdraw.length > 0) {
+            const summary = `${fundResult.errors.dcp.length} DCP failure(s), ${fundResult.errors.withdraw.length} withdraw failure(s)`;
+            log?.(`Funding phase recorded ${summary}.`);
+            this.structuredLog?.({
+                level: "warn",
+                event: "redemption_epoch_funding_failures",
+                data: {
+                    epochPda: afterClose.pda,
+                    tokenPda: afterClose.tokenPda,
+                    dcp: fundResult.errors.dcp,
+                    withdraw: fundResult.errors.withdraw,
+                },
+            });
+        }
+        if (!fundResult.funded) {
+            log?.(`Epoch underfunded (${fundResult.fundedCollateral} / ${fundResult.grossCollateralClaim}; ` +
+                `realized unwind loss ${fundResult.realizedUnwindLoss}).`);
+            return false;
+        }
+        const afterFunding = await this.refreshEpoch(afterClose);
+        await this.startProcessing(signer, afterFunding, log);
+        const processingEpoch = await this.refreshEpoch(afterFunding);
+        const remaining = processingEpoch.requestCount - processingEpoch.processedRequestCount;
+        log?.(`Processing ${remaining} request(s)...`);
+        await this.processRequests(signer, processingEpoch, log);
+        return true;
+    }
+    // ── Cache management ───────────────────────────────────────────────────────
+    clearYieldingBankCache() {
+        this.yieldingBankCache.clear();
+    }
+    // ── Private: funding phases ───────────────────────────────────────────────
+    /**
+     * Credits only the residual shortfall from collateral already sitting in the
+     * token PDA's unlent reserve. LP withdrawals run first so existing reserves
+     * are used as the tail of mixed LP/unlent funding, not the first source.
+     */
+    async creditResidualUnlent(signer, epoch, decimals, log) {
+        const current = await this.refreshEpoch(epoch);
+        const shortfall = current.grossCollateralClaim - current.fundedCollateral;
+        if (shortfall <= 0n)
+            return;
+        const token = await this.client.account.fetchToken(current.tokenPda, { fresh: true });
+        const rawUnlent = token.data.collateral.unlentAmount;
+        const unlent = rawUnlent === undefined ? 0n : (0, common_1.toBigInt)(rawUnlent);
+        const uncreditedUnlent = unlent > current.fundedCollateral ? unlent - current.fundedCollateral : 0n;
+        if (uncreditedUnlent === 0n)
+            return;
+        const credit = shortfall < uncreditedUnlent ? shortfall : uncreditedUnlent;
+        log?.(`Crediting residual unlent reserves (${(0, common_1.toUiAmount)(credit, decimals)}) to epoch...`);
+        const plan = await this.client.tx.creditUnlentToRedemptionEpoch.getTx({
+            token: token.address,
+            redemptionEpoch: current.pda,
+        });
+        await this.client.sendTransaction(signer, plan);
+        this.client.clearAllCache();
+    }
+    /** Phase 1: withdraw directly from LPs that have no debt (no DCP needed). */
+    async fundFromDebtFreeLps(signer, token, epoch, decimals, fundingErrors, log) {
+        const debtFreeLps = token.usedLendingPositions.filter((lp) => (0, common_1.toBigInt)(lp.data.accounting.debt.amount) === 0n);
+        if (debtFreeLps.length === 0) {
+            log?.("No debt-free LP collateral available for direct withdrawal.");
+            return;
+        }
+        log?.(`${debtFreeLps.length} debt-free LP(s) — withdrawing directly...`);
+        await this.withdrawFromLps(signer, epoch, decimals, debtFreeLps, fundingErrors, log);
+    }
+    /**
+     * Phase 2: DCP + withdraw from carry-loaded LPs, sorted so non-optimal
+     * positions are unwound first.
+     */
+    async fundFromCarryLps(signer, tokenPda, epoch, decimals, fundingErrors, log) {
+        const remainingDeficitUi = this.deficitUi(epoch, decimals);
+        log?.(`Remaining deficit after debt-free withdrawals: ${remainingDeficitUi}`);
+        const token = await this.client.account.fetchToken(tokenPda, { fresh: true });
+        const carryLps = token.usedLendingPositions.filter((lp) => (0, common_1.toBigInt)(lp.data.accounting.debt.amount) > 0n);
+        if (carryLps.length === 0) {
+            log?.("No carry-loaded LP collateral available for DCP funding.");
+            return;
+        }
+        const sorted = await this.lpService.sortByOptimality(token, carryLps, log);
+        await this.dcpAcrossLps(signer, token, epoch, remainingDeficitUi, decimals, sorted, fundingErrors, log);
+        await this.withdrawFromLps(signer, epoch, decimals, sorted, fundingErrors, log);
+    }
+    // ── Private: DCP ──────────────────────────────────────────────────────────
+    /**
+     * Runs a targeted DCP on each LP that needs collateral freed. Iterates `lps`
+     * in the caller-provided order (non-optimal positions first).
+     */
+    async dcpAcrossLps(signer, token, epoch, totalDeficitUi, decimals, lps, fundingErrors, log) {
+        if (token.activeCarryPositions.length === 0)
+            return;
+        const fallbackBanks = await this.resolveYieldingBanks(token);
+        const fallbackBank = fallbackBanks[0];
+        if (!fallbackBank)
+            return;
+        let remainingDeficitUi = totalDeficitUi;
+        for (const lp of lps) {
+            if (remainingDeficitUi <= 0)
+                break;
+            const lpCollateralUi = (0, common_1.toUiAmount)((0, common_1.toBigInt)(lp.data.accounting.collateral), decimals);
+            // Skip DCP only when the amount this LP must supply (plus the withdrawal
+            // overshoot) can be withdrawn directly while keeping post-withdraw
+            // utilization within the on-chain threshold. Current utilization being
+            // in range is not enough: withdrawing collateral with debt outstanding
+            // raises utilization, and both Kamino's max LTV and the
+            // top_up_unlent_reserves post-withdraw check validate the resulting state.
+            const neededUi = Math.min(remainingDeficitUi, lpCollateralUi);
+            const neededWithOvershootUi = neededUi * (1 + WITHDRAWAL_OVERSHOOT_BPS / 10000);
+            const maxDirectUi = (0, common_1.toUiAmount)(this.maxDirectWithdrawal(lp), decimals);
+            if (maxDirectUi >= neededWithOvershootUi) {
+                log?.(`DCP LP[${lp.index}] skipped — needed ${neededUi} within direct-withdrawal headroom (${maxDirectUi}).`);
+                remainingDeficitUi -= neededUi;
+                continue;
+            }
+            const fullUnwind = remainingDeficitUi >= lpCollateralUi;
+            const dcpSucceeded = await this.dcpSingleLp(signer, epoch, lp, fallbackBank, fullUnwind, neededUi, fundingErrors, log);
+            if (dcpSucceeded) {
+                remainingDeficitUi -= neededUi;
+            }
+        }
+    }
+    /**
+     * Max collateral (native units) withdrawable from an LP without a prior DCP.
+     *
+     * TopUpUnlentReserves re-checks `is_utilization_rate_at_or_below_target`
+     * AFTER the withdrawal (util <= target + target * threshold / 10_000), and
+     * utilization scales as `util_after = util * collateral / (collateral - w)`
+     * when debt and prices stay constant (mirrors on-chain
+     * `simulate_utilization_rate_bps_after_collateral_withdraw`). Inverting
+     * against the upper bound gives:
+     *   w_max = collateral * (limit - util) / limit
+     */
+    maxDirectWithdrawal(lp) {
+        const collateral = (0, common_1.toBigInt)(lp.data.accounting.collateral);
+        const utilBps = BigInt(lp.data.accounting.ltvUtilizationRateBps);
+        if (utilBps === 0n)
+            return collateral;
+        const target = lp.data.config.targetUtilizationRateBps;
+        const margin = Math.floor((target * UTILIZATION_RATE_DEVIATION_THRESHOLD_BPS) / 10000);
+        const limitBps = BigInt(Math.min(target + margin, 10000));
+        if (utilBps >= limitBps)
+            return 0n;
+        return (collateral * (limitBps - utilBps)) / limitBps;
+    }
+    /**
+     * Executes a single DCP on one lending position with retry logic. Uses full
+     * unwind (target utilization 0) when the deficit exceeds the LP's collateral,
+     * otherwise uses `collateralWithdrawal` steering.
+     */
+    async dcpSingleLp(signer, epoch, lp, yieldingBank, fullUnwind, withdrawUi, fundingErrors, log) {
+        const repaySteering = fullUnwind
+            ? {
+                mode: "explicitTargetUtilization",
+                targetUtilizationRateBps: 0,
+            }
+            : {
+                mode: "collateralWithdrawal",
+                collateralWithdrawalUiAmount: withdrawUi,
+                allowBelowTargetOnChain: true,
+            };
+        const label = fullUnwind ? "full unwind" : "collateralWithdrawal steering";
+        log?.(`DCP LP[${lp.index}] (${label})...`);
+        let lastError = "unknown error";
+        for (let attempt = 0; attempt <= DCP_MAX_RETRIES; attempt++) {
+            if (attempt > 0) {
+                log?.(`DCP LP[${lp.index}] retry ${attempt}/${DCP_MAX_RETRIES}...`);
+                this.client.clearAllCache();
+            }
+            const attemptLabel = `${attempt + 1}/${DCP_MAX_RETRIES + 1}`;
+            log?.(`DCP LP[${lp.index}] attempt ${attemptLabel}: building plan ` +
+                `(token=${epoch.tokenPda}, epoch=${epoch.pda}, yieldingBank=${yieldingBank}, signer=${signer.address}).`);
+            let plan;
+            try {
+                plan = await this.client.tx.decreaseCarryPosition.getTx({
+                    signer: signer.address,
+                    token: epoch.tokenPda,
+                    redemptionEpoch: epoch.pda,
+                    params: {
+                        lendingPositionIndex: lp.index,
+                        yieldingBank,
+                        swapSlippageBps: this.dcpSwapSlippageBps,
+                        ...(repaySteering ? { repaySteering } : {}),
+                    },
+                });
+            }
+            catch (err) {
+                lastError = errorMessage(err);
+                log?.(`DCP LP[${lp.index}] plan build failed: ${lastError}`);
+                for (const detail of errorDiagnostics(err)) {
+                    log?.(`DCP LP[${lp.index}] plan build ${detail}`);
+                }
+                continue;
+            }
+            log?.(`DCP LP[${lp.index}] attempt ${attemptLabel}: plan built ` +
+                `(${plan.instructions.length} ix, ${plan.lookupTables?.length ?? 0} LUT(s)); sending transaction.`);
+            try {
+                await this.client.sendTransaction(signer, plan);
+                this.client.clearAllCache();
+                log?.(`DCP LP[${lp.index}] done.`);
+                return true;
+            }
+            catch (err) {
+                lastError = errorMessage(err);
+                log?.(`DCP LP[${lp.index}] send failed: ${lastError}`);
+                for (const detail of errorDiagnostics(err)) {
+                    log?.(`DCP LP[${lp.index}] send ${detail}`);
+                }
+            }
+        }
+        log?.(`DCP LP[${lp.index}] exhausted retries — continuing.`);
+        fundingErrors.dcp.push({ lpIndex: lp.index, message: lastError });
+        return false;
+    }
+    // ── Private: top-up withdrawals ───────────────────────────────────────────
+    /**
+     * Withdraws collateral from lending positions into unlent reserves, crediting
+     * the redemption epoch. Stops as soon as the epoch is fully funded.
+     */
+    async withdrawFromLps(signer, epoch, decimals, lps, fundingErrors, log) {
+        for (const lp of lps) {
+            const current = await this.refreshEpoch(epoch);
+            if (this.isFullyFunded(current))
+                break;
+            // Re-fetch the LP so post-DCP debt/collateral (and thus utilization) are
+            // current — the caller's snapshot predates any DCPs run this funding pass.
+            const token = await this.client.account.fetchToken(epoch.tokenPda, { fresh: true });
+            const freshLp = token.usedLendingPositions.find((p) => p.index === lp.index);
+            if (!freshLp)
+                continue;
+            const remainingDeficit = current.grossCollateralClaim - current.fundedCollateral;
+            const lpCollateral = (0, common_1.toBigInt)(freshLp.data.accounting.collateral);
+            // For partial withdrawals, overshoot slightly so Kamino rounding never
+            // leaves the epoch a few lamports short of fully funded.
+            const overshoot = (remainingDeficit * BigInt(WITHDRAWAL_OVERSHOOT_BPS)) / 10000n;
+            const withOvershoot = remainingDeficit + overshoot;
+            const requested = withOvershoot < lpCollateral
+                ? withOvershoot
+                : remainingDeficit < lpCollateral
+                    ? remainingDeficit
+                    : lpCollateral;
+            // Cap at what the post-withdraw utilization checks (Kamino max LTV and
+            // on-chain is_utilization_rate_at_or_below_target) allow with the LP's
+            // remaining debt.
+            const maxWithdraw = this.maxDirectWithdrawal(freshLp);
+            if (maxWithdraw === 0n) {
+                log?.(`LP[${lp.index}]: skipped — no utilization headroom for a direct withdrawal.`);
+                continue;
+            }
+            const amount = requested < maxWithdraw ? requested : maxWithdraw;
+            if (amount < requested) {
+                log?.(`LP[${lp.index}]: capping withdrawal at utilization headroom (${(0, common_1.toUiAmount)(maxWithdraw, decimals)}).`);
+            }
+            const drainAll = amount >= lpCollateral;
+            const fundsFully = amount >= remainingDeficit;
+            const uiAmount = drainAll ? "all" : (0, common_1.toUiAmount)(amount, decimals);
+            log?.(`LP[${lp.index}]: withdrawing ${drainAll ? "all" : uiAmount}...`);
+            try {
+                const plan = await this.client.tx.topUpUnlentReserves.getTx({
+                    token: epoch.tokenPda,
+                    params: {
+                        lendingPositionIndex: lp.index,
+                        uiAmount,
+                        redemptionEpoch: epoch.pda,
+                    },
+                });
+                if (!drainAll && fundsFully) {
+                    // Bundle Funding → Processing in the same tx. On-chain the status
+                    // instruction validates funded_collateral >= gross_collateral_claim,
+                    // so the whole tx rolls back atomically if the withdrawal fell short.
+                    const statusIx = await this.client.tx.setRedemptionEpochStatus.getIx({
+                        token: epoch.tokenPda,
+                        redemptionEpoch: epoch.pda,
+                        params: { status: general_1.REDEMPTION_EPOCH_STATUS_PROCESSING },
+                    });
+                    plan.instructions.push(statusIx);
+                }
+                await this.client.sendTransaction(signer, plan);
+                this.client.clearAllCache();
+                if (fundsFully)
+                    break;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                log?.(`LP[${lp.index}] withdraw failed: ${message}`);
+                fundingErrors.withdraw.push({ lpIndex: lp.index, message });
+            }
+        }
+    }
+    // ── Private: utilities ────────────────────────────────────────────────────
+    isFullyFunded(epoch) {
+        return epoch.fundedCollateral >= epoch.grossCollateralClaim;
+    }
+    deficitUi(epoch, decimals) {
+        return (0, common_1.toUiAmount)(epoch.grossCollateralClaim - epoch.fundedCollateral, decimals);
+    }
+    fundResult(epoch, errors) {
+        return {
+            funded: this.isFullyFunded(epoch),
+            fundedCollateral: epoch.fundedCollateral,
+            grossCollateralClaim: epoch.grossCollateralClaim,
+            realizedUnwindLoss: epoch.realizedUnwindLoss,
+            errors,
+        };
+    }
+    async resolveYieldingBanks(token) {
+        const cached = this.yieldingBankCache.get(token.address);
+        if (cached)
+            return cached;
+        const seen = new Set();
+        const banks = [];
+        for (const carry of token.activeCarryPositions) {
+            const bankPda = await token.deriveYieldingBankAddressForDebtCarryIndex(carry.index, this.client.pda);
+            if (!seen.has(bankPda)) {
+                seen.add(bankPda);
+                banks.push(bankPda);
+            }
+        }
+        this.yieldingBankCache.set(token.address, banks);
+        return banks;
+    }
+}
+exports.RedemptionService = RedemptionService;