@kestrelfi/lyc-sdk 1.0.1

package/dist/sdks/long-yield-carry/src/client/account.js

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountClient = exports.IGNORED_LYC_TOKEN_ADDRESSES = exports.REDEMPTION_EPOCH_CACHE_CATEGORY = exports.YIELDING_BANK_CACHE_CATEGORY = exports.LYC_TOKEN_CACHE_CATEGORY = void 0;
+const kit_1 = require("@solana/kit");
+const web3_js_1 = require("@solana/web3.js");
+const lycToken_1 = require("../models/lycToken");
+const yieldingBank_1 = require("../models/yieldingBank");
+const common_1 = require("common");
+const ix_1 = require("../utils/ix");
+/** DataCache category for LYC `Token` accounts (used when clearing cache after writes). */
+exports.LYC_TOKEN_CACHE_CATEGORY = "token";
+exports.YIELDING_BANK_CACHE_CATEGORY = "yieldingBank";
+exports.REDEMPTION_EPOCH_CACHE_CATEGORY = "redemptionEpoch";
+exports.IGNORED_LYC_TOKEN_ADDRESSES = new Set([
+    "GphwC2jwG3mcM8FYFFm5j8A4jNw3i7Hhic4poLbnoKpu", // jupSOL - need proper oracle implementation to fix this (TODO)
+]);
+/**
+ * Account fetchers for the long_yield_carry program.
+ *
+ * Extends {@link BaseAccountClient} for shared DataCache + `splAtaExists`, then adds LYC-specific
+ * deserialization and helpers (Token, YieldingBank, carry-trade metas).
+ */
+class AccountClient extends common_1.BaseAccountClient {
+    constructor(program, pda, rpc) {
+        super(rpc, {
+            categoryTtlMs: {
+                [exports.LYC_TOKEN_CACHE_CATEGORY]: 60000 * 5,
+                [exports.YIELDING_BANK_CACHE_CATEGORY]: 60000 * 10,
+                [exports.REDEMPTION_EPOCH_CACHE_CATEGORY]: 30000,
+            },
+        });
+        this.program = program;
+        this.pda = pda;
+    }
+    /** Fetch and deserialize a Token account by its PDA address. */
+    async fetchToken(token, opts) {
+        if (opts?.fresh) {
+            this.dataCache.clearCacheEntry(exports.LYC_TOKEN_CACHE_CATEGORY, token);
+        }
+        const { data } = await this.dataCache.getDataOrThrow(() => this.program.account.token.fetch((0, common_1.toWeb3Pk)(token)), exports.LYC_TOKEN_CACHE_CATEGORY, token);
+        return new lycToken_1.LYCToken(token, data);
+    }
+    /** Fetch and deserialize multiple Token accounts by their PDA addresses. */
+    async fetchTokens(tokens) {
+        const { data } = await this.dataCache.getDataBatch(() => this.program.account.token.fetchMultiple(tokens.map(common_1.toWeb3Pk)), exports.LYC_TOKEN_CACHE_CATEGORY, tokens);
+        return data.map((x, i) => new lycToken_1.LYCToken(tokens[i], x));
+    }
+    /**
+     * Fetch all Token accounts owned by the program.
+     *
+     * Pass `{ fresh: true }` to clear the cached `"all"` entry before reading,
+     * forcing a fresh `getProgramAccounts` call. The returned data is
+     * re-cached so subsequent callers benefit from the same refresh.
+     */
+    async fetchAllTokens(opts) {
+        if (opts?.fresh) {
+            this.dataCache.clearCacheEntry(exports.LYC_TOKEN_CACHE_CATEGORY, "all");
+        }
+        const { data } = await this.dataCache.getDataOrThrow(() => this.program.account.token.all(), exports.LYC_TOKEN_CACHE_CATEGORY, "all");
+        return data
+            .map((acc) => new lycToken_1.LYCToken((0, kit_1.address)(acc.publicKey.toBase58()), acc.account))
+            .filter((token) => !exports.IGNORED_LYC_TOKEN_ADDRESSES.has(token.address) &&
+            !exports.IGNORED_LYC_TOKEN_ADDRESSES.has(token.mint));
+    }
+    /** Fetch and deserialize a YieldingBank account by its PDA address. */
+    async fetchYieldingBank(bank) {
+        const { data } = await this.dataCache.getDataOrThrow(() => this.program.account.yieldingBank.fetch((0, common_1.toWeb3Pk)(bank)), exports.YIELDING_BANK_CACHE_CATEGORY, bank);
+        return new yieldingBank_1.LYCYieldingBank(bank, data);
+    }
+    /** Fetch and deserialize multiple YieldingBank accounts by their PDA addresses. */
+    async fetchYieldingBanks(banks) {
+        const { data } = await this.dataCache.getDataBatch(() => this.program.account.yieldingBank.fetchMultiple(banks.map(common_1.toWeb3Pk)), exports.YIELDING_BANK_CACHE_CATEGORY, banks);
+        return data.map((x, i) => new yieldingBank_1.LYCYieldingBank(banks[i], x));
+    }
+    /** Fetch all YieldingBank accounts owned by the program. */
+    async fetchAllYieldingBanks() {
+        const { data } = await this.dataCache.getDataOrThrow(() => this.program.account.yieldingBank.all(), exports.YIELDING_BANK_CACHE_CATEGORY, "all");
+        return data.map((acc) => new yieldingBank_1.LYCYieldingBank((0, kit_1.address)(acc.publicKey.toBase58()), acc.account));
+    }
+    /** Fetch and deserialize a RedemptionEpoch account by its PDA address. */
+    async fetchRedemptionEpoch(epochPda, opts) {
+        if (opts?.fresh) {
+            this.dataCache.clearCacheEntry(exports.REDEMPTION_EPOCH_CACHE_CATEGORY, epochPda);
+        }
+        const { data } = await this.dataCache.getDataOrThrow(() => this.program.account.redemptionEpoch.fetch((0, common_1.toWeb3Pk)(epochPda)), exports.REDEMPTION_EPOCH_CACHE_CATEGORY, epochPda);
+        return this.toRedemptionEpochSnapshot(epochPda, data);
+    }
+    /** Fetch all RedemptionEpoch accounts owned by the program. */
+    async fetchAllRedemptionEpochs(opts) {
+        if (opts?.fresh) {
+            this.dataCache.clearCacheEntry(exports.REDEMPTION_EPOCH_CACHE_CATEGORY, "all");
+        }
+        const { data } = await this.dataCache.getDataOrThrow(() => this.program.account.redemptionEpoch.all(), exports.REDEMPTION_EPOCH_CACHE_CATEGORY, "all");
+        return data
+            .filter((acc) => acc?.publicKey && acc?.account)
+            .map((acc) => this.toRedemptionEpochSnapshot((0, kit_1.address)(acc.publicKey.toBase58()), acc.account));
+    }
+    /**
+     * Fetch all LYC yToken holdings for a wallet.
+     *
+     * Reads the user's ATA per LYC token directly via `getMultipleAccounts` —
+     * cost scales with the LYC token count (typically <10), not the wallet's
+     * total token-account count, which can be in the hundreds for active users.
+     *
+     * USD valuation: only when `opts.priceMap` supplies a positive USD price for
+     * the collateral mint and `token.price` (NAV) is positive:
+     *   `valueUsd = uiBalance × token.price × priceMap[collateralMint]`.
+     * If the caller does not supply a usable collateral price, `valueUsd` is
+     * omitted — we do not infer USD from on-chain `tvlUsd` / `totalSupply`, since
+     * those can lag risk-asset markets by tens of minutes.
+     *
+     * Tokens with no user ATA or a zero balance are filtered out unless
+     * `opts.includeEmpty` is set.
+     *
+     * Pass `opts.tokens` when the caller already has a list of tokens (e.g. a
+     * backend service with its own shorter-lived tokens cache) to skip the
+     * internal `fetchAllTokens` call and its 5-minute SDK cache.
+     */
+    async fetchUserHoldings(owner, opts) {
+        const tokens = opts?.tokens ?? (await this.fetchAllTokens());
+        if (tokens.length === 0)
+            return [];
+        // Derive the user's ATA per LYC token mint up front so we can fetch them
+        // all in a single round trip rather than enumerating the wallet's full
+        // token-account set.
+        const ataByMint = new Map();
+        const ataAddresses = [];
+        for (const token of tokens) {
+            const tokenProgram = (0, common_1.resolveTokenProgram)(token.data.config.tokenProgram);
+            const ata = await (0, common_1.getAtaAddress)(token.mint, owner, tokenProgram);
+            ataByMint.set(token.mint, ata);
+            ataAddresses.push(ata);
+        }
+        const balanceByAta = await (0, common_1.fetchSplTokenAccountAmounts)(this.rpc, ataAddresses);
+        const holdings = [];
+        for (const token of tokens) {
+            const tokenAccount = ataByMint.get(token.mint);
+            const balance = balanceByAta.get(tokenAccount) ?? BigInt(0);
+            if (balance === BigInt(0) && !opts?.includeEmpty)
+                continue;
+            const uiBalance = (0, common_1.toUiAmount)(balance, token.decimals);
+            const collateralPrice = opts?.priceMap?.[token.collateralMint];
+            let valueUsd;
+            if (collateralPrice !== undefined && collateralPrice > 0 && token.price > 0) {
+                valueUsd = uiBalance * token.price * collateralPrice;
+            }
+            holdings.push({
+                token,
+                tokenAccount,
+                balance,
+                uiBalance,
+                valueUsd,
+            });
+        }
+        return holdings;
+    }
+    /** Fetch all Token and YieldingBank accounts in parallel. */
+    async fetchAllTokensAndYieldingBanks() {
+        const [tokens, yieldingBanks] = await Promise.all([
+            this.fetchAllTokens(),
+            this.fetchAllYieldingBanks(),
+        ]);
+        return { tokens, yieldingBanks };
+    }
+    /**
+     * Build the ordered remaining-accounts list required by refresh_yielding_bank
+     * (and embedded within rebalance_yielding_bank):
+     *
+     *   1. base_asset: [token_account, oracle, external_liquidity...] (if active)
+     *   2. Per active asset holding (in slot order): [token_account, oracle, external_liquidity...]
+     *      The token_account is the mint's ATA owned by the bank PDA; the program
+     *      reads its raw balance to sync asset.amount on every refresh.
+     *   3. One user account per active external yielding position (in slot order)
+     *
+     * If `newAllocation` is provided, its [token_account, oracle, external_liquidity...]
+     * tuple is injected at the first inactive slot, matching where `apply_allocation`
+     * will register it.
+     */
+    async getYieldingBankRefreshAccounts(bank, newAllocation, externalLiquiditySources = []) {
+        const bankData = await this.fetchYieldingBank(bank);
+        const pushAssetAccounts = async (mint, tokenProgramAddr, externalLiquidityType, oracle, accounts) => {
+            const ata = await (0, common_1.getAtaAddress)(mint, bank, tokenProgramAddr);
+            accounts.push((0, common_1.toCustomAccountMeta)(ata, false, { owner: bank, tokenProgram: tokenProgramAddr, mint }));
+            accounts.push((0, common_1.toCustomAccountMeta)(oracle));
+            if ((0, common_1.ExternalLiquidityTypeToEnum)(externalLiquidityType) !== common_1.ExternalLiquidityType.None) {
+                const sources = externalLiquiditySources
+                    .filter((source) => source.mint === mint)
+                    .map((source) => source.account);
+                accounts.push(...sources.map((source) => (0, common_1.toCustomAccountMeta)(source)));
+            }
+        };
+        const assetAccounts = [];
+        // base_asset first
+        const baseAsset = bankData.baseAsset;
+        if (!baseAsset.mint.equals(web3_js_1.PublicKey.default)) {
+            await pushAssetAccounts((0, common_1.fromWeb3Pk)(baseAsset.mint), (0, common_1.resolveTokenProgram)(baseAsset.tokenProgram), baseAsset.externalLiquidity, (0, common_1.fromWeb3Pk)(baseAsset.oracle), assetAccounts);
+        }
+        // Per active asset holding: [token_account, oracle].
+        // The first inactive slot gets the newAllocation pair (if provided).
+        let newAssetInserted = false;
+        for (const asset of bankData.assets) {
+            if (!asset.mint.equals(web3_js_1.PublicKey.default)) {
+                await pushAssetAccounts((0, common_1.fromWeb3Pk)(asset.mint), (0, common_1.resolveTokenProgram)(asset.tokenProgram), asset.externalLiquidity, (0, common_1.fromWeb3Pk)(asset.oracle), assetAccounts);
+            }
+            else if (newAllocation?.assetHolding && !newAssetInserted) {
+                const { mint, oracle, externalLiquidityType } = newAllocation.assetHolding;
+                const mintInfo = await this.rpc.getAccountInfo(mint, { encoding: "base64" }).send();
+                const mintOwner = mintInfo.value.owner;
+                await pushAssetAccounts(mint, mintOwner, externalLiquidityType, oracle, assetAccounts);
+                newAssetInserted = true;
+            }
+        }
+        // External position accounts — active slots only (lendingPlatform != None).
+        // Per position: [protocol_user_acc, collateral_reserve].
+        // The new allocation's accounts are inserted at the first inactive slot.
+        const extAccounts = [];
+        let newExtInserted = false;
+        for (const pos of bankData.externalYieldingPositions) {
+            if (!("none" in pos.lendingPlatform)) {
+                extAccounts.push((0, common_1.toCustomAccountMeta)((0, common_1.fromWeb3Pk)(pos.protocolUserAcc)));
+                extAccounts.push((0, common_1.toCustomAccountMeta)((0, common_1.fromWeb3Pk)(pos.collateralReserve)));
+            }
+            else if (newAllocation?.externalPosition && !newExtInserted) {
+                extAccounts.push((0, common_1.toCustomAccountMeta)(newAllocation.externalPosition.protocolUserAcc));
+                extAccounts.push((0, common_1.toCustomAccountMeta)(newAllocation.externalPosition.collateralReserve));
+                newExtInserted = true;
+            }
+        }
+        return [...assetAccounts, ...extAccounts];
+    }
+    /**
+     * Build the carry-trade remaining accounts for increase/decrease carry
+     * position instructions.
+     *
+     * Fetches the token's lending position at `lendingPositionIndex`, derives
+     * the debt ATAs, and returns the ordered account metas that
+     * `parse_carry_trade_accounts` expects on the Rust side.
+     *
+     * Returns the fixed carry-trade account prefix, including the instructions
+     * sysvar in slot 8 so CPI refs are derived against the on-chain layout.
+     *
+     * @param lendingPositionUserAccount - Override for the protocol user account.
+     *   Defaults to the value stored in the on-chain lending position.
+     */
+    async getCarryTradeAccounts(token, yieldingBank, lendingPositionIndex, lendingPositionUserAccount) {
+        const tokenData = await this.fetchToken(token);
+        const position = tokenData.data.lendingPositions[lendingPositionIndex];
+        const debt = position.accounting.debt;
+        const debtMint = (0, common_1.fromWeb3Pk)(debt.mint);
+        const debtTokenProgram = (0, common_1.resolveTokenProgram)(debt.tokenProgram);
+        const tokenLpDebtTa = await (0, common_1.getAtaAddress)(debtMint, token, debtTokenProgram);
+        const yieldingBankTa = await (0, common_1.getAtaAddress)(debtMint, yieldingBank, debtTokenProgram);
+        return (0, ix_1.buildCarryTradeAccountMetas)(token, yieldingBank, tokenLpDebtTa, yieldingBankTa, lendingPositionUserAccount ?? (0, common_1.fromWeb3Pk)(position.protocolUserAcc), (0, common_1.fromWeb3Pk)(position.collateralReserve), (0, common_1.fromWeb3Pk)(position.accounting.debt.oracle), debtMint, debtTokenProgram);
+    }
+    /**
+     * Derive the account set needed to refresh a single token lending position.
+     *
+     * This pulls the protocol user account, collateral reserve, and debt oracle
+     * from the selected lending position so callers can pass the exact accounts
+     * required by refresh-oriented instructions. Optional overrides let tests or
+     * advanced callers substitute explicit addresses when needed.
+     */
+    getTokenLendingPositionRefreshAccounts(tokenData, lendingPositionIndex, overrides) {
+        const position = tokenData.lendingPositions[lendingPositionIndex];
+        if (!position) {
+            throw new Error(`Invalid lending position index: ${lendingPositionIndex}`);
+        }
+        return {
+            userAccount: overrides?.userAccount ?? (0, common_1.fromWeb3Pk)(position.protocolUserAcc),
+            collateralReserve: overrides?.collateralReserve ?? (0, common_1.fromWeb3Pk)(position.collateralReserve),
+            debtOracle: overrides?.debtOracle ?? (0, common_1.fromWeb3Pk)(position.accounting.debt.oracle),
+        };
+    }
+    /**
+     * Build the fixed initial-accounts prefix for `rebalance_token`.
+     *
+     * The Rust handler reads these positionally from the front of
+     * `remaining_accounts` (see `RebalanceTokenAccounts::parse`). Returning the
+     * prefix as `initialAccounts` to `createMultiCpiRefs` lets every CPI in the
+     * flash-rebalance bundle deduplicate against these slots, shrinking the
+     * transaction's account list compared to declaring them as named ix
+     * accounts that would force separate copies in the message header.
+     */
+    async getRebalanceTokenInitialAccounts(token, yieldingBank, lpIndex, destinationDebtOracle, overrides) {
+        const tokenData = await this.fetchToken(token);
+        const position = tokenData.data.lendingPositions[lpIndex];
+        if (!position) {
+            throw new Error(`Invalid lending position index: ${lpIndex}`);
+        }
+        const sourceDebtMint = (0, common_1.fromWeb3Pk)(position.accounting.debt.mint);
+        const sourceDebtTokenProgram = (0, common_1.resolveTokenProgram)(position.accounting.debt.tokenProgram);
+        const yieldingBankSourceDebtAta = await (0, common_1.getAtaAddress)(sourceDebtMint, yieldingBank, sourceDebtTokenProgram);
+        const lp = this.getTokenLendingPositionRefreshAccounts(tokenData.data, lpIndex, overrides);
+        return (0, ix_1.buildRebalanceTokenInitialAccounts)({
+            token,
+            yieldingBank,
+            sourceDebtMint,
+            sourceDebtTokenProgram,
+            yieldingBankSourceDebtAta,
+            lpUserAccount: lp.userAccount,
+            sourceDebtOracle: lp.debtOracle,
+            destinationDebtOracle,
+        });
+    }
+    /**
+     * Build the initial account pool seed for refresh_token_state.
+     *
+     * These accounts are placed at the front of the deduplicated remaining_accounts
+     * pool (positions 0..N-1), so the index-based TokenRefreshRefs computed by
+     * the builder remain stable whether or not prereq CPIs introduce additional accounts.
+     *
+     * Order:
+     *   1. Per active lending position (in slot order): protocol_user_acc, collateral_reserve, debt_oracle
+     *   2. One YieldingBank PDA per active carry position (in slot order)
+     */
+    async getTokenRefreshAccounts(token) {
+        const tokenData = await this.fetchToken(token);
+        const accounts = [];
+        for (const position of tokenData.data.lendingPositions) {
+            if ((0, common_1.lendingPlatformToEnum)(position.platform) === common_1.LendingPlatform.None)
+                continue;
+            accounts.push((0, common_1.toCustomAccountMeta)((0, common_1.fromWeb3Pk)(position.protocolUserAcc)));
+            accounts.push((0, common_1.toCustomAccountMeta)((0, common_1.fromWeb3Pk)(position.collateralReserve)));
+            accounts.push((0, common_1.toCustomAccountMeta)((0, common_1.fromWeb3Pk)(position.accounting.debt.oracle)));
+        }
+        for (const { data: carry } of tokenData.activeCarryPositions) {
+            const baseMint = (0, common_1.fromWeb3Pk)(carry.yieldingBaseMint);
+            const [bankPda] = await this.pda.deriveYieldingBankPda(baseMint, carry.yieldingBankId);
+            accounts.push((0, common_1.toCustomAccountMeta)(bankPda));
+        }
+        return accounts;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    toRedemptionEpochSnapshot(pda, data) {
+        return {
+            pda,
+            tokenPda: data.header.token.toBase58(),
+            epochId: BigInt(data.header.id.toString()),
+            payer: data.header.payer.toBase58(),
+            status: data.header.status,
+            requestCount: Number(data.sequencing.requestCount.toString()),
+            processedRequestCount: Number(data.sequencing.processedRequestCount.toString()),
+            grossCollateralClaim: (0, common_1.toBigInt)(data.accounting.grossCollateralClaim),
+            realizedUnwindLoss: (0, common_1.toBigInt)(data.accounting.realizedUnwindLoss),
+            fundedCollateral: (0, common_1.toBigInt)(data.accounting.fundedCollateral),
+        };
+    }
+}
+exports.AccountClient = AccountClient;

package/dist/sdks/long-yield-carry/src/client/builders/args.d.ts

@@ -0,0 +1,299 @@
+import type { BN } from "@anchor-lang/core";
+import type { Address } from "@solana/kit";
+import type { LendingPlatform } from "common";
+import type { BurnTokenIxParams, BurnTokenTxParams, ClaimIncentivesTxParams, CollectInterestTxParams, ClaimIncentivesParams, CollectInterestParams, CreateCpiPlanParams, CreateTokenLendingPositionAccounts, CreateTokenLendingPositionParams, CreateTokenParams, CreateYieldingBankParams, DecreaseCarryPositionParams, DecreaseCarryPositionTxParams, DepositUnlentCollateralParams, DepositUnlentCollateralTxParams, IncreaseCarryPositionParams, IncreaseCarryPositionTxParams, MintTokenTxParams, RebalanceTokenParams, RebalanceTokenTxParams, RebalanceYieldingBankParams, RebalanceYieldingBankTxParams, RecollateralizeLossParams, RecollateralizeLossTxParams, RefreshTokensTxParams, UpdateLendingPositionConfigParams, UpdateTokenConfigurationParams, UpdateTokenMetadataParams, UpdateYieldingBankConfigParams, SetRedemptionEpochStatusParams, TopUpUnlentReservesParams, TopUpUnlentReservesTxParams, ProcessAsyncBurnTxParams, YieldingBankAllocationConfig, YieldingBankExternalLiquiditySource } from "../types";
+export interface CreateTokenIxArgs {
+    mint: Address;
+    collateralMint: Address;
+    params: CreateTokenParams;
+    tokenProgram?: Address;
+    collateralTokenProgram?: Address;
+    /** Curator signer. Must be in the on-chain `WHITELISTED_CURATORS` list.
+     *  Defaults to the builder's admin wallet. */
+    curator?: Address;
+    /** Optional per-token admin override. Omit to use the feature-gated program default. */
+    adminRole?: Address;
+    /** Optional per-token manager override. Omit to use the program default. */
+    managerRole?: Address;
+    /** Optional per-token curator-fees wallet override. Omit to use the program default. */
+    feesRole?: Address;
+    /** Optional per-token circuit-breaker controller override. Omit to use the program default. */
+    cbControllerRole?: Address;
+}
+export interface CreateCpiPlanIxArgs {
+    cpiPlan: Address;
+    manager: Address;
+    params: CreateCpiPlanParams;
+}
+export interface UpdateTokenMetadataIxArgs {
+    token: Address;
+    mint: Address;
+    params: UpdateTokenMetadataParams;
+}
+export interface CreateTokenLendingPositionIxArgs {
+    token: Address;
+    params: CreateTokenLendingPositionParams;
+    /**
+     * Accounts that describe the new lending position — their pubkeys are
+     * stored on the position and their on-chain state is read by the final
+     * refresh.
+     */
+    accounts: CreateTokenLendingPositionAccounts;
+}
+export interface CreateTokenLendingPositionTxArgs {
+    /** Token PDA that will own the new lending position. */
+    token: Address;
+    /**
+     * Debt mint address. Decimals, token program, and oracle metadata are
+     * derived from the mint registry / oracle service.
+     */
+    debtMint: Address;
+    /** Debt reserve address. Looked up by `debtMint` against the pool when omitted. */
+    debtReserve?: Address;
+    /**
+     * Lending-protocol user-account ID used when the obligation must be
+     * created. Ignored when the protocol user account already exists.
+     * Defaults to 0. For Kamino this is the obligation sub-account index.
+     */
+    userAccountId?: number;
+    /**
+     * Lending pool. When omitted, resolved automatically from the token's
+     * collateral mint via {@link resolveDefaultPool}. 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;
+    /** Optional txId reused across composed plans in the same transaction. */
+    txId?: string;
+}
+export interface CreateYieldingBankIxArgs {
+    baseMint: Address;
+    params: CreateYieldingBankParams;
+    baseMintTokenProgram?: Address;
+    /** Curator signer. Must be in on-chain `WHITELISTED_CURATORS`. Defaults to builder admin. */
+    curator?: Address;
+    /** Optional admin override. Omit to use the program default. */
+    adminRole?: Address;
+    /** Optional manager override. Omit to use the program default. */
+    managerRole?: Address;
+    /** Optional circuit-breaker controller override. Omit to use the program default. */
+    cbControllerRole?: Address;
+}
+export interface RefreshYieldingBankIxArgs {
+    signer: Address;
+    yieldingBank: Address;
+    externalLiquiditySources?: YieldingBankExternalLiquiditySource[];
+}
+export interface RefreshYieldingBankTxArgs {
+    signer: Address;
+    yieldingBank: Address;
+}
+export interface CreateYieldingBankAllocationIxArgs {
+    yieldingBank: Address;
+    config: YieldingBankAllocationConfig;
+}
+export interface RebalanceYieldingBankIxArgs {
+    yieldingBank: Address;
+    params: RebalanceYieldingBankParams;
+}
+export interface RebalanceYieldingBankTxArgs {
+    yieldingBank: Address;
+    params: RebalanceYieldingBankTxParams;
+}
+export interface RefreshTokenStateIxArgs {
+    signer: Address;
+    token: Address;
+    collateralOracle: Address;
+    /** Optional secondary oracle account, required only for composite oracle
+     * types. For `PythSplStake` collateral this is the SPL stake pool account. */
+    secondaryCollateralOracle?: Address;
+    collateralTokenAccount: Address;
+    collateralTokenProgram: Address;
+}
+export interface RefreshTokensBuilderTxArgs {
+    signer: Address;
+    params: RefreshTokensTxParams;
+}
+export interface IncreaseCarryPositionIxArgs {
+    token: Address;
+    params: IncreaseCarryPositionParams;
+}
+export interface IncreaseCarryPositionTxArgs {
+    manager: Address;
+    token: Address;
+    params: IncreaseCarryPositionTxParams;
+}
+export interface RebalanceTokenIxArgs {
+    token: Address;
+    params: RebalanceTokenParams;
+}
+export interface RebalanceTokenTxArgs {
+    token: Address;
+    params: RebalanceTokenTxParams;
+}
+export interface RecollateralizeLossIxArgs {
+    token: Address;
+    params: RecollateralizeLossParams;
+}
+export interface RecollateralizeLossTxArgs {
+    token: Address;
+    params: RecollateralizeLossTxParams;
+}
+export interface DecreaseCarryPositionIxArgs {
+    signer: Address;
+    params: DecreaseCarryPositionParams;
+}
+export interface DecreaseCarryPositionTxArgs {
+    signer: Address;
+    token: Address;
+    params: DecreaseCarryPositionTxParams;
+    /** When set, the DCP loss is attributed to this epoch instead of socialised into the price. */
+    redemptionEpoch?: Address;
+}
+export interface UpdateLendingPositionConfigIxArgs {
+    token: Address;
+    params: UpdateLendingPositionConfigParams;
+}
+export interface DepositUnlentCollateralIxArgs {
+    token: Address;
+    params: DepositUnlentCollateralParams;
+}
+export interface SetTokenCircuitBreakerIxArgs {
+    authority: Address;
+    token: Address;
+    active: boolean;
+}
+export interface SetTokenCircuitBreakerTxArgs {
+    authority: Address;
+    token: Address;
+    active: boolean;
+}
+export interface MintTokenIxArgs {
+    signer: Address;
+    token: Address;
+    depositAmount: BN;
+}
+export interface MintTokenTxArgs {
+    signer: Address;
+    token: Address;
+    params: MintTokenTxParams;
+}
+export interface BurnTokenIxArgs {
+    signer: Address;
+    token: Address;
+    params: BurnTokenIxParams;
+    /** Pays rent for async-path accounts; must sign the transaction. Defaults to signer. */
+    payer?: Address;
+}
+export interface BurnTokenTxArgs {
+    signer: Address;
+    token: Address;
+    params: BurnTokenTxParams;
+    /** Pays rent for async-path accounts; must sign the transaction. Defaults to signer. */
+    payer?: Address;
+}
+export interface SetRedemptionEpochStatusIxArgs {
+    token: Address;
+    redemptionEpoch: Address;
+    params: SetRedemptionEpochStatusParams;
+}
+export interface TopUpUnlentReservesIxArgs {
+    token: Address;
+    params: TopUpUnlentReservesParams;
+}
+export interface TopUpUnlentReservesTxArgs {
+    token: Address;
+    params: TopUpUnlentReservesTxParams;
+}
+export interface CreditUnlentToRedemptionEpochIxArgs {
+    token: Address;
+    redemptionEpoch: Address;
+}
+export interface ProcessAsyncBurnIxArgs {
+    token: Address;
+    redemptionEpoch: Address;
+    request: Address;
+}
+export interface ProcessAsyncBurnTxArgs {
+    token: Address;
+    params: ProcessAsyncBurnTxParams;
+}
+export interface ClaimIncentivesIxArgs {
+    token: Address;
+    params: ClaimIncentivesParams;
+}
+export interface ClaimIncentivesTxArgs {
+    token: Address;
+    params: ClaimIncentivesTxParams;
+}
+export interface CollectInterestIxArgs {
+    token: Address;
+    yieldingBank: Address;
+    params: CollectInterestParams;
+}
+export interface CollectInterestTxArgs {
+    manager: Address;
+    token: Address;
+    params: CollectInterestTxParams;
+}
+export interface SetYieldingBankCircuitBreakerIxArgs {
+    authority: Address;
+    yieldingBank: Address;
+    active: boolean;
+}
+export interface SetYieldingBankCircuitBreakerTxArgs {
+    authority: Address;
+    yieldingBank: Address;
+    active: boolean;
+}
+export interface UpdateYieldingBankConfigIxArgs {
+    yieldingBank: Address;
+    params: UpdateYieldingBankConfigParams;
+    /** Optional admin signer override. */
+    admin?: Address;
+    /** Optional new manager. Omit for no change. */
+    managerRole?: Address;
+    /** Optional new circuit-breaker controller. Omit for no change. */
+    cbControllerRole?: Address;
+}
+export interface ResetTokenBurnRateLimitIxArgs {
+    token: Address;
+}
+export interface UpdateTokenConfigurationIxArgs {
+    token: Address;
+    params: UpdateTokenConfigurationParams;
+    /**
+     * Optional authority signer. The token admin may update all configuration;
+     * the token manager may update fee fields only. Defaults to the token admin.
+     */
+    admin?: Address;
+    /** Optional new manager. Omit for no change. */
+    managerRole?: Address;
+    /** Optional new curator-fees wallet. Omit for no change. */
+    feesRole?: Address;
+    /** Optional new circuit-breaker controller. Omit for no change. */
+    cbControllerRole?: Address;
+}
+export interface CollectFeesIxArgs {
+    token: Address;
+    /**
+     * Signer collecting the fees. Must be either the token's `roles.curator`
+     * (drains `pending_curator_fees` into the curator fee wallet) or the
+     * program-wide `PROTOCOL_ADMIN` (drains `pending_protocol_fees` into the
+     * protocol fee wallet). The fee bucket and destination wallet are both
+     * derived from whichever role this signer matches.
+     */
+    authority: Address;
+}
+export interface DepositUnlentCollateralTxArgs {
+    manager: Address;
+    token: Address;
+    params: DepositUnlentCollateralTxParams;
+}

package/dist/sdks/long-yield-carry/src/client/builders/args.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sdks/long-yield-carry/src/client/builders/asyncBurnBuilder.d.ts

@@ -0,0 +1,20 @@
+import type { Instruction } from "@solana/kit";
+import type { CreditUnlentToRedemptionEpochIxArgs, ProcessAsyncBurnIxArgs, ProcessAsyncBurnTxArgs, SetRedemptionEpochStatusIxArgs, TopUpUnlentReservesIxArgs, TopUpUnlentReservesTxArgs } from "./args";
+import type { LongYieldCarryTransactionPlan } from "../types";
+import { LongYieldCarryBuilderBase } from "./base";
+export declare class SetRedemptionEpochStatusBuilder extends LongYieldCarryBuilderBase<SetRedemptionEpochStatusIxArgs, SetRedemptionEpochStatusIxArgs> {
+    getTx(args: SetRedemptionEpochStatusIxArgs): Promise<LongYieldCarryTransactionPlan>;
+    getIx(args: SetRedemptionEpochStatusIxArgs): Promise<Instruction>;
+}
+export declare class TopUpUnlentReservesBuilder extends LongYieldCarryBuilderBase<TopUpUnlentReservesIxArgs, TopUpUnlentReservesTxArgs> {
+    getTx(args: TopUpUnlentReservesTxArgs): Promise<LongYieldCarryTransactionPlan>;
+    getIx(args: TopUpUnlentReservesIxArgs): Promise<Instruction>;
+}
+export declare class CreditUnlentToRedemptionEpochBuilder extends LongYieldCarryBuilderBase<CreditUnlentToRedemptionEpochIxArgs, CreditUnlentToRedemptionEpochIxArgs> {
+    getTx(args: CreditUnlentToRedemptionEpochIxArgs): Promise<LongYieldCarryTransactionPlan>;
+    getIx(args: CreditUnlentToRedemptionEpochIxArgs): Promise<Instruction>;
+}
+export declare class ProcessAsyncBurnBuilder extends LongYieldCarryBuilderBase<ProcessAsyncBurnIxArgs, ProcessAsyncBurnTxArgs> {
+    getTx(args: ProcessAsyncBurnTxArgs): Promise<LongYieldCarryTransactionPlan>;
+    getIx(args: ProcessAsyncBurnIxArgs): Promise<Instruction>;
+}