@kestrelfi/lyc-sdk 1.0.1 → 1.0.3

package/dist/sdks/long-yield-carry/src/services/lendingPosition/lendingPositionService.js

@@ -1,229 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LendingPositionService = void 0;
-const common_1 = require("common");
-const errors_1 = require("../../errors");
-const utils_1 = require("../../utils");
-const allocation_1 = require("../allocation");
-const carryAllocationConfig_1 = require("../carry/carryAllocationConfig");
-/**
- * Shared logic for choosing and interacting with a token's lending positions
- * based on allocation optimality. Used by {@link RedemptionService} (to
- * prioritize which positions to unwind) and by deposit scripts / backend
- * services (to deposit into the best position).
- */
-class LendingPositionService {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Returns the lending position whose debt mint matches the current optimal
-     * allocation. If no position matches the optimal mint, returns the position
-     * with the most collateral as a fallback.
-     *
-     * Returns `null` only when the token has no active lending positions.
-     */
-    async findOptimalLendingPosition(token, log) {
-        const usedLps = token.usedLendingPositions;
-        if (usedLps.length === 0) {
-            const activeLps = token.activeLendingPositions;
-            if (activeLps.length === 0)
-                return null;
-            // Freshly created slots have zero collateral until the first deposit.
-            log?.("No collateral on any LP yet — using first active slot");
-            return this.toLpResult(activeLps[0], true);
-        }
-        if (usedLps.length === 1) {
-            return this.toLpResult(usedLps[0], true);
-        }
-        const optimalMint = await this.findOptimalDebtMint(token, log);
-        if (optimalMint) {
-            const match = usedLps.find((lp) => (0, common_1.fromWeb3Pk)(lp.data.accounting.debt.mint) === optimalMint.mint);
-            if (match) {
-                log?.(`Using optimal LP[${match.index}] (debt: ${optimalMint.symbol})`);
-                return this.toLpResult(match, true);
-            }
-            log?.(`No LP matches optimal debt mint ${optimalMint.symbol} — using largest LP`);
-        }
-        const largest = this.largestLp(usedLps);
-        return this.toLpResult(largest, false);
-    }
-    /**
-     * Sorts lending positions so non-optimal debt mints come first. Useful for
-     * choosing which positions to unwind during redemptions — non-optimal
-     * positions are unwound first to preserve the best-yielding ones.
-     *
-     * Returns the original order if there's only one LP or the optimal mint
-     * lookup fails.
-     */
-    async sortByOptimality(token, lps, log) {
-        if (lps.length <= 1)
-            return lps;
-        const optimalMint = await this.findOptimalDebtMint(token, log);
-        if (!optimalMint)
-            return lps;
-        log?.(`Optimal debt mint: ${optimalMint.symbol} — prioritizing non-optimal LPs for unwind`);
-        const nonOptimal = lps.filter((lp) => (0, common_1.fromWeb3Pk)(lp.data.accounting.debt.mint) !== optimalMint.mint);
-        const optimal = lps.filter((lp) => (0, common_1.fromWeb3Pk)(lp.data.accounting.debt.mint) === optimalMint.mint);
-        return [...nonOptimal, ...optimal];
-    }
-    /**
-     * Opens the first Kamino lending position on a token that has none yet.
-     *
-     * Mirrors `scripts/createTokenLendingPosition.ts` and the create-LP branch in
-     * `TokenRebalanceWorker`: resolve pool + optimal debt mint, compute carry
-     * allocation config, send `createTokenLendingPosition`, then refetch the token.
-     *
-     * Kamino-specific: the flow resolves the default Kamino pool, fetches Kamino
-     * reserves, and uses {@link AllocationService} over Kamino reserve data. It is
-     * named accordingly until a second lending platform actually needs bootstrap
-     * support (avoid speculative platform abstraction with a single implementation).
-     *
-     * No-op when the token already has at least one active lending position slot.
-     *
-     * @throws {LendingPositionBootstrapError} when the token cannot be bootstrapped
-     *   because of a permanent configuration gap (collateral mint not in any pool,
-     *   no preset, no viable debt mint / reserve). Callers should treat this as a
-     *   skip rather than a retryable failure.
-     */
-    async ensureInitialKaminoLendingPosition(options) {
-        const { manager, lutManager, token, sendPlan, log } = options;
-        if (token.activeLendingPositions.length > 0) {
-            return token;
-        }
-        log?.("No lending positions — creating initial LP");
-        let pool;
-        try {
-            pool = (0, utils_1.resolveDefaultPool)(token.collateralMint);
-        }
-        catch (err) {
-            throw new errors_1.LendingPositionBootstrapError(`Cannot resolve a default pool for ${token.label} (${token.collateralMint}): ${err instanceof Error ? err.message : String(err)}`);
-        }
-        const kamino = this.client.getLendingPlatformClientByPlatform(common_1.LendingPlatform.Kamino);
-        const collateralReserve = await kamino.data.fetchReserveByMint(pool, token.collateralMint);
-        if (!collateralReserve) {
-            throw new errors_1.LendingPositionBootstrapError(`No Kamino reserve found for collateral ${token.label} (${token.collateralMint}) in pool ${pool}`);
-        }
-        const yieldingBanks = await this.client.account.fetchAllYieldingBanks();
-        const allocationService = new allocation_1.AllocationService(kamino.data, { logger: log, yieldingBanks });
-        const optimalDebt = await allocationService.findOptimalDebtMint(pool, collateralReserve, token);
-        if (!optimalDebt) {
-            throw new errors_1.LendingPositionBootstrapError(`No viable debt mint found for ${token.label} on pool ${pool}`);
-        }
-        log?.(`Selected debt mint ${optimalDebt.symbol} (borrow APY ${(optimalDebt.borrowApy * 100).toFixed(3)}%)`);
-        const debtReserve = await kamino.data.fetchReserveByMint(pool, optimalDebt.mint);
-        if (!debtReserve) {
-            throw new errors_1.LendingPositionBootstrapError(`No Kamino reserve found for debt mint ${optimalDebt.symbol} (${optimalDebt.mint})`);
-        }
-        let config;
-        try {
-            config = (0, carryAllocationConfig_1.computeConfigForCollateral)({
-                collateralMint: token.collateralMint,
-                collateralReserve,
-                debtReserve,
-            });
-        }
-        catch (err) {
-            throw new errors_1.LendingPositionBootstrapError(`No carry allocation config for ${token.label} (${token.collateralMint}): ${err instanceof Error ? err.message : String(err)}`);
-        }
-        const userAccountId = await (0, utils_1.getAvailableTokenLendingUserAccountId)({
-            lendingClient: kamino,
-            token,
-            pool,
-        });
-        const label = `create-initial-lp-${token.label}-${optimalDebt.symbol}`;
-        const plan = await this.client.tx.createTokenLendingPosition.getTx({
-            token: token.address,
-            debtMint: optimalDebt.mint,
-            userAccountId,
-            pool,
-            ...config,
-        });
-        await sendPlan(plan, label);
-        log?.(`Sent createTokenLendingPosition (${plan.instructions.length} ix)`);
-        this.client.clearAllCache();
-        const freshToken = await this.client.account.fetchToken(token.address, { fresh: true });
-        if (lutManager) {
-            try {
-                await (0, utils_1.updateTokenLutIfNeeded)(lutManager, this.client.rpc, this.client, freshToken);
-                log?.("Updated per-token LUT after initial lending position");
-            }
-            catch (err) {
-                log?.(`updateTokenLutIfNeeded failed: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-        if (freshToken.activeLendingPositions.length === 0) {
-            throw new Error(`Initial lending position creation completed but ${token.label} still has no active LPs`);
-        }
-        return freshToken;
-    }
-    /**
-     * Deposits unlent collateral into the optimal lending position. Refreshes
-     * the token state first, then deposits all unlent collateral into the
-     * position returned by {@link findOptimalLendingPosition}.
-     */
-    async depositToOptimalPosition(signer, token, log) {
-        const optimal = await this.findOptimalLendingPosition(token, log);
-        if (!optimal) {
-            throw new Error(`Token ${token.address} has no used lending positions to deposit into`);
-        }
-        log?.(`Depositing unlent collateral into LP[${optimal.lp.index}] (debt: ${optimal.debtSymbol})...`);
-        const refreshPlan = await this.client.tx.refreshTokens.getTx({
-            signer: signer.address,
-            params: { tokens: [token.address] },
-        });
-        await this.client.sendTransaction(signer, refreshPlan);
-        this.client.clearAllCache();
-        const depositPlan = await this.client.tx.depositUnlentCollateral.getTx({
-            manager: signer.address,
-            token: token.address,
-            params: {
-                lendingPositionIndex: optimal.lp.index,
-                depositAll: true,
-            },
-        });
-        const sig = await this.client.sendTransaction(signer, depositPlan);
-        this.client.clearAllCache();
-        log?.(`Deposit done: ${sig}`);
-        return {
-            signature: sig,
-            lendingPositionIndex: optimal.lp.index,
-            debtSymbol: optimal.debtSymbol,
-        };
-    }
-    // ── Private ─────────────────────────────────────────────────────────────
-    /**
-     * Queries `AllocationService.findOptimalDebtMint` for the token's
-     * pool + collateral pair. Returns null on any failure (missing reserve, etc.).
-     */
-    async findOptimalDebtMint(token, log) {
-        try {
-            const firstLp = token.usedLendingPositions[0]?.data;
-            if (!firstLp)
-                return null;
-            const pool = (0, common_1.fromWeb3Pk)(firstLp.pool);
-            const kaminoData = this.client.getLendingPlatformClientByPlatform(common_1.LendingPlatform.Kamino).data;
-            const collateralReserve = await kaminoData.fetchReserve(pool, (0, common_1.fromWeb3Pk)(firstLp.collateralReserve));
-            if (!collateralReserve)
-                return null;
-            const yieldingBanks = await this.client.account.fetchAllYieldingBanks();
-            const allocationService = new allocation_1.AllocationService(kaminoData, { yieldingBanks });
-            return await allocationService.findOptimalDebtMint(pool, collateralReserve, token);
-        }
-        catch (err) {
-            log?.(`Optimal debt mint lookup failed: ${err instanceof Error ? err.message : err}`);
-            return null;
-        }
-    }
-    largestLp(lps) {
-        return lps.reduce((best, lp) => (0, common_1.toBigInt)(lp.data.accounting.collateral) > (0, common_1.toBigInt)(best.data.accounting.collateral)
-            ? lp
-            : best);
-    }
-    toLpResult(lp, isOptimal) {
-        const debtMint = (0, common_1.fromWeb3Pk)(lp.data.accounting.debt.mint);
-        const debtSymbol = common_1.mints.get(debtMint)?.symbol ?? debtMint.slice(0, 6);
-        return { lp, debtMint, debtSymbol, isOptimal };
-    }
-}
-exports.LendingPositionService = LendingPositionService;

package/dist/sdks/long-yield-carry/src/services/rebalance/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./token";
-export * from "./yieldingBank";

package/dist/sdks/long-yield-carry/src/services/rebalance/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./token"), exports);
-__exportStar(require("./yieldingBank"), exports);

package/dist/sdks/long-yield-carry/src/services/rebalance/token/index.d.ts

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

package/dist/sdks/long-yield-carry/src/services/rebalance/token/index.js

@@ -1,17 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./tokenRebalanceService"), exports);

package/dist/sdks/long-yield-carry/src/services/rebalance/token/tokenRebalanceService.d.ts

@@ -1,51 +0,0 @@
-import type { Address } from "@solana/kit";
-import type { LYCToken } from "../../../models/lycToken";
-import type { LongYieldCarryTransactionPlan } from "../../../client/types";
-import type { DebtReallocation } from "../../allocation/types";
-import type { LongYieldCarryClient } from "../../../client/client";
-export type RebalancePlanResult = {
-    outcome: "skipped";
-    reason: string;
-} | {
-    outcome: "plan";
-    plan: LongYieldCarryTransactionPlan;
-    label: string;
-};
-/**
- * Shared logic for building a token rebalance plan from a {@link DebtReallocation}.
- * Callers are responsible for sending the returned plan (and any post-send steps such as
- * excess-rent reclaim).
- */
-export interface TokenRebalanceServiceOptions {
-    /**
-     * Maximum acceptable execution cost (route fees + price impact) of the
-     * rebalance swap quote vs the oracle-fair cross rate, in bps. Candidates
-     * quoting worse are skipped — that cost is permanently lost value.
-     * Unset = no limit.
-     */
-    maxSwapCostBps?: number;
-    /**
-     * Maximum acceptable market basis between the two debt stables, in bps
-     * either direction. Bounds how much mark-to-market difference the $1-pinned
-     * books absorb per conversion, and blocks rebalancing through a depegging
-     * stable. Unset = no limit.
-     */
-    maxMarketBasisBps?: number;
-}
-export declare class TokenRebalanceService {
-    private readonly client;
-    private readonly options;
-    constructor(client: LongYieldCarryClient, options?: TokenRebalanceServiceOptions);
-    /**
-     * Validates a reallocation and builds the rebalance transaction plan.
-     * If the primary targets fail due to insufficient borrow/swap capacity
-     * ({@link ExactInQuoteExceedsMaxInputError}), retries with each fallback
-     * option in order before giving up.
-     *
-     * Returns `{ outcome: "skipped" }` for benign no-ops (inactive token, no active LP for the
-     * reallocation index, no targets). Throws on unexpected errors from the builder.
-     */
-    buildPlan(token: LYCToken, realloc: DebtReallocation): Promise<RebalancePlanResult>;
-    /** Convenience: fetch a fresh token then call {@link buildPlan}. */
-    fetchAndBuildPlan(tokenAddress: Address, realloc: DebtReallocation): Promise<RebalancePlanResult>;
-}

package/dist/sdks/long-yield-carry/src/services/rebalance/token/tokenRebalanceService.js

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenRebalanceService = void 0;
-const jupiter_helpers_1 = require("jupiter-helpers");
-const lending_platforms_1 = require("lending-platforms");
-const errors_1 = require("../../../errors");
-const general_1 = require("../../../constants/general");
-const common_1 = require("common");
-class TokenRebalanceService {
-    constructor(client, options = {}) {
-        this.client = client;
-        this.options = options;
-    }
-    /**
-     * Validates a reallocation and builds the rebalance transaction plan.
-     * If the primary targets fail due to insufficient borrow/swap capacity
-     * ({@link ExactInQuoteExceedsMaxInputError}), retries with each fallback
-     * option in order before giving up.
-     *
-     * Returns `{ outcome: "skipped" }` for benign no-ops (inactive token, no active LP for the
-     * reallocation index, no targets). Throws on unexpected errors from the builder.
-     */
-    async buildPlan(token, realloc) {
-        if (!token.isActive) {
-            return { outcome: "skipped", reason: "token inactive (circuit breaker)" };
-        }
-        const lpIndex = realloc.lendingPositionIndex;
-        const lp = token.activeLendingPositions.find((p) => p.index === lpIndex);
-        if (!lp) {
-            return { outcome: "skipped", reason: `no active lending position at index ${lpIndex}` };
-        }
-        // Rate limit: the program rejects a rebalance on a position touched within
-        // REBALANCE_TOKEN_RATE_LIMIT_SECS (RebalanceRateLimited). Skip client-side
-        // so we don't build a transaction that would revert on-chain.
-        const lastUpdatedTs = Number(lp.data.lastUpdatedTs.toString());
-        const nowSecs = Math.floor(Date.now() / 1000);
-        const elapsed = nowSecs - lastUpdatedTs;
-        if (lastUpdatedTs > 0 && elapsed < general_1.REBALANCE_TOKEN_RATE_LIMIT_SECS) {
-            const hoursLeft = ((general_1.REBALANCE_TOKEN_RATE_LIMIT_SECS - elapsed) / 3600).toFixed(1);
-            const reason = `lp${lpIndex} rebalanced ${(elapsed / 3600).toFixed(1)}h ago; ` +
-                `rate limit is ${general_1.REBALANCE_TOKEN_RATE_LIMIT_SECS / 3600}h (${hoursLeft}h remaining)`;
-            console.log(`Skip token ${token.address.slice(0, 8)}…: ${reason}`);
-            return { outcome: "skipped", reason };
-        }
-        const label = `rebalance-token-${token.address.slice(0, 8)}-lp${lpIndex}`;
-        const allOptions = [realloc.targets, ...(realloc.fallbackTargets ?? [])];
-        for (const targets of allOptions) {
-            const targetMint = targets[0]?.mint;
-            if (!targetMint)
-                continue;
-            try {
-                const plan = await this.client.tx.rebalanceToken.getTx({
-                    token: token.address,
-                    params: {
-                        lpIndex,
-                        destinationDebtMint: targetMint,
-                        uiAmount: "all",
-                        maxSwapCostBps: this.options.maxSwapCostBps,
-                        maxMarketBasisBps: this.options.maxMarketBasisBps,
-                    },
-                });
-                return { outcome: "plan", plan, label };
-            }
-            catch (err) {
-                if (err instanceof errors_1.NoOpTransactionError) {
-                    return { outcome: "skipped", reason: err.message };
-                }
-                if (err instanceof lending_platforms_1.FlashRebalanceSwapCostExceededError) {
-                    const symbol = common_1.mints.get(targetMint)?.symbol ?? targetMint.slice(0, 6);
-                    console.log(`Skip ${symbol}: swap ${err.reason} over ${err.limitBps} bps limit ` +
-                        `(execution cost ${err.executionCostBps.toFixed(2)} bps, ` +
-                        `market basis ${err.marketBasisBps.toFixed(2)} bps); trying next candidate`);
-                    continue;
-                }
-                if (err instanceof jupiter_helpers_1.ExactInQuoteExceedsMaxInputError) {
-                    const symbol = common_1.mints.get(targetMint)?.symbol ?? targetMint.slice(0, 6);
-                    console.log(`Skip ${symbol}: borrow capacity (${err.maxInputAmount}) < swap input (${err.inputAmount}); trying next candidate`);
-                    continue;
-                }
-                if (err instanceof Error && err.message.includes("no available borrow capacity")) {
-                    const symbol = common_1.mints.get(targetMint)?.symbol ?? targetMint.slice(0, 6);
-                    console.log(`Skip ${symbol}: no available borrow capacity; trying next candidate`);
-                    continue;
-                }
-                throw err;
-            }
-        }
-        return {
-            outcome: "skipped",
-            reason: "all candidates exhausted — insufficient borrow/swap capacity or swap cost above limit for each",
-        };
-    }
-    /** Convenience: fetch a fresh token then call {@link buildPlan}. */
-    async fetchAndBuildPlan(tokenAddress, realloc) {
-        const token = await this.client.account.fetchToken(tokenAddress, { fresh: true });
-        return this.buildPlan(token, realloc);
-    }
-}
-exports.TokenRebalanceService = TokenRebalanceService;

package/dist/sdks/long-yield-carry/src/services/rebalance/yieldingBank/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./types";
-export * from "./strategy";
-export { RebalancePlanner } from "./planner";

package/dist/sdks/long-yield-carry/src/services/rebalance/yieldingBank/index.js

@@ -1,21 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RebalancePlanner = void 0;
-__exportStar(require("./types"), exports);
-__exportStar(require("./strategy"), exports);
-var planner_1 = require("./planner");
-Object.defineProperty(exports, "RebalancePlanner", { enumerable: true, get: function () { return planner_1.RebalancePlanner; } });

package/dist/sdks/long-yield-carry/src/services/rebalance/yieldingBank/planner.d.ts

@@ -1,68 +0,0 @@
-import type { LYCYieldingBank } from "../../../models";
-import type { AllocationStrategy } from "./strategy";
-import type { YieldingBankRebalancePlan } from "./types";
-/**
- * Computes the swaps needed to move a yielding bank from its current
- * asset distribution to a target allocation.
- *
- * The planner is stateless and performs no RPC — it operates entirely on
- * the in-memory bank model and the strategy's target. This makes it
- * straightforward to unit-test.
- *
- * ## How it works
- *
- * 1. The {@link AllocationStrategy} produces a {@link TargetAllocation}
- *    (e.g. 25% USD*, 75% USD*-J).
- * 2. The planner classifies every bank holding as either a **target**
- *    (a mint the strategy manages) or an **idle source** (everything
- *    else — the base asset, plus any non-target stablecoins that
- *    arrived from borrows in other denominations).
- * 3. Each idle source with a non-trivial balance gets its own
- *    {@link YieldingBankRebalancePlan} that deploys its capital
- *    proportionally across the targets according to their weights.
- * 4. If existing target holdings are imbalanced relative to their
- *    weights (overweight / underweight), a separate rebalance plan
- *    routes through the base mint. The resulting swaps are sorted
- *    sells-first so freed base-mint liquidity is available for
- *    subsequent buy swaps.
- *
- * All swaps route through the bank's base mint as the common
- * intermediate, matching how the on-chain `rebalance_yielding_bank`
- * instruction processes CPI swaps.
- */
-export declare class RebalancePlanner {
-    private readonly strategy;
-    constructor(strategy: AllocationStrategy);
-    /**
-     * Plan the rebalance for a single yielding bank.
-     * Returns an empty array if no action is needed.
-     *
-     * Each element is an independent plan that can be sent as its own
-     * transaction. Separate plans are produced for:
-     * - Each idle source (base asset, or non-target stablecoins)
-     * - Target-to-target rebalancing (selling overweight, buying underweight)
-     */
-    plan(bank: LYCYieldingBank): YieldingBankRebalancePlan[];
-    /**
-     * Returns every holding on the bank that is NOT a strategy target.
-     * This includes the base asset and any non-target asset slots with
-     * a positive balance (e.g. a stablecoin that arrived from a
-     * non-base-mint borrow).
-     */
-    private discoverIdleSources;
-    /** Snapshot only the holdings that ARE strategy targets. */
-    private snapshotTargetHoldings;
-    /**
-     * Build a plan that deploys a single idle source proportionally
-     * across the strategy's targets according to their weights.
-     */
-    private buildDeploymentPlan;
-    /**
-     * Build a plan that rebalances between existing target holdings when
-     * they've drifted from the strategy's desired weights. Overweight
-     * targets are sold back to the base mint; underweight targets are
-     * bought with the freed base.
-     */
-    private buildTargetRebalancePlan;
-    private findCurrentAmount;
-}