@kestrelfi/lyc-sdk 1.0.1

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

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessAsyncBurnBuilder = exports.CreditUnlentToRedemptionEpochBuilder = exports.TopUpUnlentReservesBuilder = exports.SetRedemptionEpochStatusBuilder = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const common_1 = require("common");
+const base_1 = require("./base");
+class SetRedemptionEpochStatusBuilder extends base_1.LongYieldCarryBuilderBase {
+    async getTx(args) {
+        return { instructions: [await this.getIx(args)], lookupTables: [] };
+    }
+    async getIx(args) {
+        const tokenData = await this.account.fetchToken(args.token);
+        const manager = this.resolveTokenManager(tokenData.data);
+        const epochData = await this.program.account.redemptionEpoch.fetch(args.redemptionEpoch);
+        const epochRentRecipient = epochData.header.payer.equals(web3_js_1.PublicKey.default)
+            ? manager
+            : epochData.header.payer.toBase58();
+        return this.program.methods
+            .setRedemptionEpochStatus({ status: args.params.status })
+            .accountsPartial({
+            manager,
+            token: args.token,
+            redemptionEpoch: args.redemptionEpoch,
+            epochRentRecipient,
+        })
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+}
+exports.SetRedemptionEpochStatusBuilder = SetRedemptionEpochStatusBuilder;
+class TopUpUnlentReservesBuilder extends base_1.LongYieldCarryBuilderBase {
+    async getTx(args) {
+        const tokenData = await this.account.fetchToken(args.token, { fresh: true });
+        const position = tokenData.data.lendingPositions[args.params.lendingPositionIndex];
+        const manager = this.resolveTokenManager(tokenData.data);
+        const txId = args.params.txId ??
+            `top-up-unlent-reserves-${Date.now()}-${position.protocolUserAcc.toBase58()}`;
+        const cpiBundle = await this.getLendingOperationCpiData(args.token, manager, position, txId, "withdraw", args.params.uiAmount);
+        const prerequisiteCpiRefs = (0, common_1.createCpiRefs)(cpiBundle.prerequisiteCpis);
+        const { accounts: remainingAccounts, refs: ixRefs, lookupTables, } = (0, common_1.createCpiRefs)(cpiBundle.cpis, { initialAccounts: prerequisiteCpiRefs.accounts });
+        const lpClient = this.getLendingPlatformClient(position);
+        const preInstructions = await lpClient.ix.getPreInstructions(txId);
+        const { instructions: ataCreationIxs, postSuccessCacheInvalidations } = await (0, common_1.getCreateAtaInstructions)(this.rpc, manager, remainingAccounts);
+        const redemptionEpoch = args.params.redemptionEpoch ?? undefined;
+        const topUpIx = await this.getIx({
+            token: args.token,
+            params: {
+                prerequisiteCpis: prerequisiteCpiRefs.refs,
+                ixRefs,
+                lendingPositionIndex: args.params.lendingPositionIndex,
+                remainingAccounts,
+                redemptionEpoch,
+            },
+        });
+        return {
+            instructions: [...preInstructions, ...ataCreationIxs, topUpIx],
+            lookupTables: this.getTxLookupTables(args.token, [
+                ...(lookupTables ?? []),
+                ...(prerequisiteCpiRefs.lookupTables ?? []),
+            ]),
+            postSuccessCacheInvalidations: [
+                ...cpiBundle.postSuccessCacheInvalidations,
+                ...postSuccessCacheInvalidations,
+            ],
+            txId,
+        };
+    }
+    async getIx(args) {
+        const tokenData = await this.account.fetchToken(args.token);
+        const position = tokenData.data.lendingPositions[args.params.lendingPositionIndex];
+        const collateralTokenProgram = (0, common_1.resolveTokenProgram)(tokenData.data.collateral.tokenProgram);
+        return this.program.methods
+            .topUpUnlentReserves({
+            prerequisiteCpis: args.params.prerequisiteCpis,
+            ixRefs: args.params.ixRefs,
+            lendingPositionIndex: args.params.lendingPositionIndex,
+        })
+            .accountsPartial({
+            manager: this.resolveTokenManager(tokenData.data),
+            token: args.token,
+            redemptionEpoch: args.params.redemptionEpoch ?? null,
+            collateralMint: tokenData.collateralMint,
+            collateralTokenProgram,
+            lendingPositionUserAccount: (0, common_1.fromWeb3Pk)(position.protocolUserAcc),
+            lendingPositionCollateralReserve: (0, common_1.fromWeb3Pk)(position.collateralReserve),
+        })
+            .remainingAccounts(args.params.remainingAccounts.map(common_1.toWeb3AccountMeta))
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+}
+exports.TopUpUnlentReservesBuilder = TopUpUnlentReservesBuilder;
+class CreditUnlentToRedemptionEpochBuilder extends base_1.LongYieldCarryBuilderBase {
+    async getTx(args) {
+        return { instructions: [await this.getIx(args)], lookupTables: [] };
+    }
+    async getIx(args) {
+        const tokenData = await this.account.fetchToken(args.token);
+        const collateralTokenProgram = (0, common_1.resolveTokenProgram)(tokenData.data.collateral.tokenProgram);
+        const collateralTokenAccount = await (0, common_1.getAtaAddress)(tokenData.collateralMint, args.token, collateralTokenProgram);
+        return this.program.methods
+            .creditUnlentToRedemptionEpoch()
+            .accountsPartial({
+            manager: this.resolveTokenManager(tokenData.data),
+            token: args.token,
+            redemptionEpoch: args.redemptionEpoch,
+            collateralMint: tokenData.collateralMint,
+            collateralTokenAccount,
+            collateralTokenProgram,
+        })
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+}
+exports.CreditUnlentToRedemptionEpochBuilder = CreditUnlentToRedemptionEpochBuilder;
+class ProcessAsyncBurnBuilder extends base_1.LongYieldCarryBuilderBase {
+    async getTx(args) {
+        const epochId = BigInt(args.params.epochId.toString());
+        const sequence = BigInt(args.params.sequence.toString());
+        const [redemptionEpoch] = await this.pda.deriveRedemptionEpochPda(args.token, epochId);
+        const [request] = await this.pda.deriveAsyncBurnRequestPda(args.token, epochId, sequence);
+        const tokenData = await this.account.fetchToken(args.token);
+        const manager = this.resolveTokenManager(tokenData.data);
+        const requestData = await this.program.account.asyncBurnRequest.fetch(request);
+        const collateralTokenProgram = (0, common_1.resolveTokenProgram)(tokenData.data.collateral.tokenProgram);
+        const user = requestData.header.user.toBase58();
+        const isNativeSolCollateral = tokenData.collateralMint === common_1.mints.get("SOL")?.address;
+        const instructions = [];
+        const postSuccessCacheInvalidations = [];
+        if (isNativeSolCollateral) {
+            const requestCollateralAccount = await (0, common_1.getAtaAddress)(tokenData.collateralMint, request, collateralTokenProgram);
+            const createRequestCollateralAta = await (0, common_1.getCreateAtaIxIfNeeded)(this.rpc, manager, tokenData.collateralMint, request, collateralTokenProgram, { accountClient: this.account });
+            if (createRequestCollateralAta.instruction) {
+                instructions.push(createRequestCollateralAta.instruction);
+                postSuccessCacheInvalidations.push(...(createRequestCollateralAta.postSuccessCacheInvalidations ?? []));
+            }
+        }
+        else {
+            const userCollateralAccount = await (0, common_1.getAtaAddress)(tokenData.collateralMint, user, collateralTokenProgram);
+            const createUserCollateralAta = await (0, common_1.getCreateAtaIxIfNeeded)(this.rpc, manager, tokenData.collateralMint, user, collateralTokenProgram, { accountClient: this.account });
+            if (createUserCollateralAta.instruction) {
+                instructions.push(createUserCollateralAta.instruction);
+                postSuccessCacheInvalidations.push(...(createUserCollateralAta.postSuccessCacheInvalidations ?? []));
+            }
+        }
+        instructions.push(await this.getIx({ token: args.token, redemptionEpoch, request }));
+        return {
+            instructions,
+            lookupTables: this.getTxLookupTables(args.token),
+            postSuccessCacheInvalidations,
+            debug: {
+                processAsyncBurn: {
+                    epochId,
+                    sequence,
+                    request,
+                    user,
+                    collateralDelivery: isNativeSolCollateral ? "nativeSol" : "tokenAta",
+                    userCollateralAccount: isNativeSolCollateral
+                        ? undefined
+                        : await (0, common_1.getAtaAddress)(tokenData.collateralMint, user, collateralTokenProgram),
+                    requestCollateralAccount: isNativeSolCollateral
+                        ? await (0, common_1.getAtaAddress)(tokenData.collateralMint, request, collateralTokenProgram)
+                        : undefined,
+                },
+            },
+        };
+    }
+    async getIx(args) {
+        const tokenData = await this.account.fetchToken(args.token);
+        const manager = this.resolveTokenManager(tokenData.data);
+        const tokenProgram = (0, common_1.resolveTokenProgram)(tokenData.data.config.tokenProgram);
+        const collateralTokenProgram = (0, common_1.resolveTokenProgram)(tokenData.data.collateral.tokenProgram);
+        const requestData = await this.program.account.asyncBurnRequest.fetch(args.request);
+        const user = requestData.header.user.toBase58();
+        const payer = requestData.header.payer.toBase58();
+        const epochData = await this.program.account.redemptionEpoch.fetch(args.redemptionEpoch);
+        const epochRentRecipient = epochData.header.payer.equals(web3_js_1.PublicKey.default)
+            ? manager
+            : epochData.header.payer.toBase58();
+        const isNativeSolCollateral = tokenData.collateralMint === common_1.mints.get("SOL")?.address;
+        const requestTokenAccount = await (0, common_1.getAtaAddress)(tokenData.mint, args.request, tokenProgram);
+        const userCollateralAccount = isNativeSolCollateral
+            ? null
+            : await (0, common_1.getAtaAddress)(tokenData.collateralMint, user, collateralTokenProgram);
+        const requestCollateralAccount = isNativeSolCollateral
+            ? await (0, common_1.getAtaAddress)(tokenData.collateralMint, args.request, collateralTokenProgram)
+            : null;
+        const collateralTokenAccount = await (0, common_1.getAtaAddress)(tokenData.collateralMint, args.token, collateralTokenProgram);
+        return this.program.methods
+            .processAsyncBurn()
+            .accountsPartial({
+            manager,
+            payer,
+            token: args.token,
+            redemptionEpoch: args.redemptionEpoch,
+            request: args.request,
+            user,
+            mint: tokenData.mint,
+            requestTokenAccount,
+            collateralMint: tokenData.collateralMint,
+            userCollateralAccount,
+            requestCollateralAccount,
+            collateralTokenAccount,
+            epochRentRecipient,
+            tokenProgram,
+            collateralTokenProgram,
+        })
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+}
+exports.ProcessAsyncBurnBuilder = ProcessAsyncBurnBuilder;

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

@@ -0,0 +1,77 @@
+import type { Address, Instruction } from "@solana/kit";
+import type { BN } from "@anchor-lang/core";
+import { BaseIXBuilderService } from "common";
+import type { LendingOperationCpiBundle } from "lending-platforms";
+import type { TokenAccountData, TokenLendingPositionData } from "../../models/lycToken";
+import type { YieldingBankAccountData } from "../../models/yieldingBank";
+import type { LongYieldCarryBuilderContext } from "../types/builders";
+import type { LongYieldCarryTransactionPlan } from "../types";
+export declare abstract class LongYieldCarryBuilderBase<TIxArgs, TTxArgs = TIxArgs, TTxResult = LongYieldCarryTransactionPlan> extends BaseIXBuilderService<LongYieldCarryBuilderContext, TIxArgs, TTxArgs, TTxResult> {
+    protected get rpc(): import("@solana/kit").Rpc<import("@solana/kit").RequestAirdropApi & import("@solana/kit").GetAccountInfoApi & import("@solana/kit").GetBalanceApi & import("@solana/kit").GetBlockApi & import("@solana/kit").GetBlockCommitmentApi & import("@solana/kit").GetBlockHeightApi & import("@solana/kit").GetBlockProductionApi & import("@solana/kit").GetBlocksApi & import("@solana/kit").GetBlocksWithLimitApi & import("@solana/kit").GetBlockTimeApi & import("@solana/kit").GetClusterNodesApi & import("@solana/kit").GetEpochInfoApi & import("@solana/kit").GetEpochScheduleApi & import("@solana/kit").GetFeeForMessageApi & import("@solana/kit").GetFirstAvailableBlockApi & import("@solana/kit").GetGenesisHashApi & import("@solana/kit").GetHealthApi & import("@solana/kit").GetHighestSnapshotSlotApi & import("@solana/kit").GetIdentityApi & import("@solana/kit").GetInflationGovernorApi & import("@solana/kit").GetInflationRateApi & import("@solana/kit").GetInflationRewardApi & import("@solana/kit").GetLargestAccountsApi & import("@solana/kit").GetLatestBlockhashApi & import("@solana/kit").GetLeaderScheduleApi & import("@solana/kit").GetMaxRetransmitSlotApi & import("@solana/kit").GetMaxShredInsertSlotApi & import("@solana/kit").GetMinimumBalanceForRentExemptionApi & import("@solana/kit").GetMultipleAccountsApi & import("@solana/kit").GetProgramAccountsApi & import("@solana/kit").GetRecentPerformanceSamplesApi & import("@solana/kit").GetRecentPrioritizationFeesApi & import("@solana/kit").GetSignaturesForAddressApi & import("@solana/kit").GetSignatureStatusesApi & import("@solana/kit").GetSlotApi & import("@solana/kit").GetSlotLeaderApi & import("@solana/kit").GetSlotLeadersApi & import("@solana/kit").GetStakeMinimumDelegationApi & import("@solana/kit").GetSupplyApi & import("@solana/kit").GetTokenAccountBalanceApi & import("@solana/kit").GetTokenAccountsByDelegateApi & import("@solana/kit").GetTokenAccountsByOwnerApi & import("@solana/kit").GetTokenLargestAccountsApi & import("@solana/kit").GetTokenSupplyApi & import("@solana/kit").GetTransactionApi & import("@solana/kit").GetTransactionCountApi & import("@solana/kit").GetVersionApi & import("@solana/kit").GetVoteAccountsApi & import("@solana/kit").IsBlockhashValidApi & import("@solana/kit").MinimumLedgerSlotApi & import("@solana/kit").SendTransactionApi & import("@solana/kit").SimulateTransactionApi>;
+    protected get program(): import("@anchor-lang/core").Program<import("../../idl/long_yield_carry").LongYieldCarry>;
+    protected get account(): import("../account").AccountClient;
+    protected get pda(): import("../pda").PdaClient;
+    protected get swap(): import("common").SwapClient<unknown>;
+    protected get externalLiquidityResolver(): import("../externalLiquidityResolver").LongYieldCarryExternalLiquidityResolver;
+    protected get environment(): import("common").Environment;
+    protected get lendingPlatformClients(): import("..").LendingPlatformClientRegistry;
+    /**
+     * Environment-level manager fallback. Use {@link resolveTokenManager} /
+     * {@link resolveYieldingBankManager} whenever a specific token/bank's role
+     * might override the default.
+     */
+    private get manager();
+    /**
+     * Environment-level circuit-breaker-controller fallback. Use
+     * {@link resolveTokenCbController} / {@link resolveYieldingBankCbController}
+     * whenever a specific token/bank's role might override the default.
+     */
+    private get circuitBreakerController();
+    /**
+     * Program-level admin. Also doubles as the environment-level fallback for
+     * `TokenRoles::admin()` / `YieldingBankRoles::admin()` when their stored role
+     * is unset — both Rust fallbacks resolve to this same pubkey by design.
+     */
+    private get protocolAdmin();
+    /**
+     * Program-level fee wallet. Also doubles as the fallback for
+     * `TokenRoles::curator_fee_wallet()` when a token's `roles.fees` is unset —
+     * the Rust `curator_fee_wallet()` getter delegates to `protocol_fee_wallet()`.
+     */
+    protected get protocolFeeWallet(): Address;
+    /** Program ID for this environment — used as the "no-change"/"use-default" sentinel on role accounts. */
+    protected get programId(): Address;
+    /**
+     * Return the on-chain role key if it's set, otherwise the environment
+     * fallback. Mirrors the Rust role getter pattern (`if self.role != default()
+     * { self.role } else { <env default> }`).
+     */
+    private resolveStoredOrFallback;
+    protected resolveTokenAdmin(tokenData: TokenAccountData): Address;
+    protected resolveTokenManager(tokenData: TokenAccountData): Address;
+    protected resolveTokenCuratorFeeWallet(tokenData: TokenAccountData): Address;
+    protected resolveTokenCbController(tokenData: TokenAccountData): Address;
+    /**
+     * Optional composite collateral oracle (e.g. SPL stake pool for PythSplStake).
+     * Anchor optional accounts must be passed as `null` when unset.
+     */
+    protected resolveOptionalSecondaryCollateralOracle(collateral: TokenAccountData["collateral"]): Address | null;
+    protected resolveYieldingBankAdmin(bankData: YieldingBankAccountData): Address;
+    protected resolveYieldingBankManager(bankData: YieldingBankAccountData): Address;
+    protected resolveYieldingBankCbController(bankData: YieldingBankAccountData): Address;
+    protected getTxLookupTables(tokenPda?: Address | readonly Address[], existingLookupTables?: readonly Address[]): Address[];
+    protected getLendingPlatformClient(position: TokenLendingPositionData): import("lending-platforms").LendingPlatformClientBase<import("lending-platforms").LendingPlatformData>;
+    protected getCreateUserCollateralAtaIxIfNeeded(owner: Address, collateralMint: Address, collateralTokenProgram: Address): Promise<import("common").CreateAtaIxIfNeededResult>;
+    protected getWrapSolInstructionsIfMintIsSol(owner: Address, mint: Address, lamports: BN): Promise<{
+        instructions?: Instruction[];
+        postSuccessCacheInvalidations?: LongYieldCarryTransactionPlan["postSuccessCacheInvalidations"];
+    }>;
+    protected getLendingOperationCpiData(token: Address, manager: Address, position: TokenLendingPositionData, txId: string, operation: "deposit" | "withdraw" | "borrow" | "repay", uiAmount?: number | "all"): Promise<LendingOperationCpiBundle>;
+}
+export declare abstract class LongYieldCarrySingleInstructionBuilderService<TIxArgs, TTxArgs = TIxArgs, TTxPlan extends LongYieldCarryTransactionPlan = LongYieldCarryTransactionPlan> extends LongYieldCarryBuilderBase<TIxArgs, TTxArgs, TTxPlan> {
+    protected deriveIxArgs(txArgs: TTxArgs): Promise<TIxArgs>;
+    protected buildPreambleInstructions(_args: TIxArgs, _txArgs: TTxArgs): Promise<Instruction[]>;
+    protected buildLookupTables(_args: TIxArgs, _txArgs: TTxArgs): Promise<readonly Address[] | undefined>;
+    protected buildPlanExtras(_args: TIxArgs, _txArgs: TTxArgs): Promise<Omit<TTxPlan, "instructions" | "lookupTables"> | undefined>;
+    getTx(txArgs: TTxArgs): Promise<TTxPlan>;
+}

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

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LongYieldCarrySingleInstructionBuilderService = exports.LongYieldCarryBuilderBase = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const common_1 = require("common");
+const utils_1 = require("../../utils");
+const general_1 = require("../../constants/general");
+class LongYieldCarryBuilderBase extends common_1.BaseIXBuilderService {
+    get rpc() {
+        return this.context.rpc;
+    }
+    get program() {
+        return this.context.program;
+    }
+    get account() {
+        return this.context.account;
+    }
+    get pda() {
+        return this.context.pda;
+    }
+    get swap() {
+        return this.context.swap;
+    }
+    get externalLiquidityResolver() {
+        return this.context.externalLiquidityResolver;
+    }
+    get environment() {
+        return this.context.environment;
+    }
+    get lendingPlatformClients() {
+        return this.context.lendingPlatformClients;
+    }
+    /**
+     * Environment-level manager fallback. Use {@link resolveTokenManager} /
+     * {@link resolveYieldingBankManager} whenever a specific token/bank's role
+     * might override the default.
+     */
+    get manager() {
+        return general_1.MANAGER[this.environment];
+    }
+    /**
+     * Environment-level circuit-breaker-controller fallback. Use
+     * {@link resolveTokenCbController} / {@link resolveYieldingBankCbController}
+     * whenever a specific token/bank's role might override the default.
+     */
+    get circuitBreakerController() {
+        return general_1.CIRCUIT_BREAKER_CONTROLLER[this.environment];
+    }
+    /**
+     * Program-level admin. Also doubles as the environment-level fallback for
+     * `TokenRoles::admin()` / `YieldingBankRoles::admin()` when their stored role
+     * is unset — both Rust fallbacks resolve to this same pubkey by design.
+     */
+    get protocolAdmin() {
+        return general_1.PROTOCOL_ADMIN[this.environment];
+    }
+    /**
+     * Program-level fee wallet. Also doubles as the fallback for
+     * `TokenRoles::curator_fee_wallet()` when a token's `roles.fees` is unset —
+     * the Rust `curator_fee_wallet()` getter delegates to `protocol_fee_wallet()`.
+     */
+    get protocolFeeWallet() {
+        return general_1.PROTOCOL_FEE_WALLET[this.environment];
+    }
+    /** Program ID for this environment — used as the "no-change"/"use-default" sentinel on role accounts. */
+    get programId() {
+        return general_1.PROGRAM_ID[this.environment];
+    }
+    /**
+     * Return the on-chain role key if it's set, otherwise the environment
+     * fallback. Mirrors the Rust role getter pattern (`if self.role != default()
+     * { self.role } else { <env default> }`).
+     */
+    resolveStoredOrFallback(stored, fallback) {
+        return stored.equals(web3_js_1.PublicKey.default) ? fallback : (0, common_1.fromWeb3Pk)(stored);
+    }
+    resolveTokenAdmin(tokenData) {
+        return this.resolveStoredOrFallback(tokenData.roles.admin, this.protocolAdmin);
+    }
+    resolveTokenManager(tokenData) {
+        return this.resolveStoredOrFallback(tokenData.roles.manager, this.manager);
+    }
+    resolveTokenCuratorFeeWallet(tokenData) {
+        return this.resolveStoredOrFallback(tokenData.roles.fees, this.protocolFeeWallet);
+    }
+    resolveTokenCbController(tokenData) {
+        return this.resolveStoredOrFallback(tokenData.roles.cbController, this.circuitBreakerController);
+    }
+    /**
+     * Optional composite collateral oracle (e.g. SPL stake pool for PythSplStake).
+     * Anchor optional accounts must be passed as `null` when unset.
+     */
+    resolveOptionalSecondaryCollateralOracle(collateral) {
+        return collateral.secondaryOracle.equals(web3_js_1.PublicKey.default)
+            ? null
+            : (0, common_1.fromWeb3Pk)(collateral.secondaryOracle);
+    }
+    resolveYieldingBankAdmin(bankData) {
+        return this.resolveStoredOrFallback(bankData.roles.admin, this.protocolAdmin);
+    }
+    resolveYieldingBankManager(bankData) {
+        return this.resolveStoredOrFallback(bankData.roles.manager, this.manager);
+    }
+    resolveYieldingBankCbController(bankData) {
+        return this.resolveStoredOrFallback(bankData.roles.cbController, this.circuitBreakerController);
+    }
+    getTxLookupTables(tokenPda, existingLookupTables) {
+        return (0, utils_1.mergeLycLookupTables)(this.context.environment, tokenPda, existingLookupTables);
+    }
+    getLendingPlatformClient(position) {
+        return this.lendingPlatformClients.getForPosition(position);
+    }
+    async getCreateUserCollateralAtaIxIfNeeded(owner, collateralMint, collateralTokenProgram) {
+        return (0, common_1.getCreateAtaIxIfNeeded)(this.rpc, owner, collateralMint, owner, collateralTokenProgram, {
+            accountClient: this.account,
+        });
+    }
+    async getWrapSolInstructionsIfMintIsSol(owner, mint, lamports) {
+        const solMint = common_1.mints.get("SOL");
+        if (!solMint || mint !== solMint.address) {
+            return {};
+        }
+        const wrap = await (0, common_1.getWrapSolInstructions)(this.rpc, owner, (0, common_1.createSignerFromAddress)(owner), lamports, { accountClient: this.account });
+        return {
+            instructions: wrap.instructions,
+            postSuccessCacheInvalidations: wrap.postSuccessCacheInvalidations,
+        };
+    }
+    async getLendingOperationCpiData(token, manager, position, txId, operation, uiAmount) {
+        const lpClient = this.getLendingPlatformClient(position);
+        const pool = (0, common_1.fromWeb3Pk)(position.pool);
+        const userAccount = (0, common_1.fromWeb3Pk)(position.protocolUserAcc);
+        const reserve = operation === "deposit" || operation === "withdraw"
+            ? (0, common_1.fromWeb3Pk)(position.collateralReserve)
+            : (0, common_1.fromWeb3Pk)(position.debtReserve);
+        const operationParams = {
+            user: token,
+            payer: manager,
+            pool,
+            reserve,
+            userAccount,
+            uiAmount,
+            txId,
+        };
+        if (operation === "deposit") {
+            return lpClient.ix.getDepositCpiBundle(operationParams);
+        }
+        if (operation === "borrow") {
+            const needsInit = !(await (0, common_1.accountExists)(this.rpc, userAccount));
+            return needsInit
+                ? lpClient.ix.getInitBorrowPositionCpiBundle(operationParams, (0, common_1.fromWeb3Pk)(position.collateralReserve))
+                : lpClient.ix.getBorrowCpiBundle(operationParams);
+        }
+        if (operation === "withdraw") {
+            return lpClient.ix.getWithdrawCpiBundle(operationParams);
+        }
+        if (uiAmount === "all") {
+            throw new Error('The "all" amount sentinel is only valid for withdrawals');
+        }
+        const repayParams = { ...operationParams, uiAmount };
+        return lpClient.ix.getRepayCpiBundle(repayParams);
+    }
+}
+exports.LongYieldCarryBuilderBase = LongYieldCarryBuilderBase;
+class LongYieldCarrySingleInstructionBuilderService extends LongYieldCarryBuilderBase {
+    async deriveIxArgs(txArgs) {
+        return txArgs;
+    }
+    async buildPreambleInstructions(_args, _txArgs) {
+        return [];
+    }
+    async buildLookupTables(_args, _txArgs) {
+        return undefined;
+    }
+    async buildPlanExtras(_args, _txArgs) {
+        return undefined;
+    }
+    async getTx(txArgs) {
+        const args = await this.deriveIxArgs(txArgs);
+        const preambleInstructions = await this.buildPreambleInstructions(args, txArgs);
+        const instruction = await this.getIx(args);
+        const lookupTables = await this.buildLookupTables(args, txArgs);
+        const extras = await this.buildPlanExtras(args, txArgs);
+        return {
+            instructions: [...preambleInstructions, instruction],
+            ...(lookupTables?.length ? { lookupTables: [...lookupTables] } : {}),
+            ...(extras ?? {}),
+        };
+    }
+}
+exports.LongYieldCarrySingleInstructionBuilderService = LongYieldCarrySingleInstructionBuilderService;

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

@@ -0,0 +1,18 @@
+import type { Instruction } from "@solana/kit";
+import type { LongYieldCarryTransactionPlan } from "../types";
+import type { BurnTokenIxArgs, BurnTokenTxArgs } from "./args";
+import { LongYieldCarryBuilderBase } from "./base";
+export interface BundledBurnPlan {
+    instructions?: Instruction[];
+    [key: string]: unknown;
+}
+export declare class BurnTokenBuilder extends LongYieldCarryBuilderBase<BurnTokenIxArgs, BurnTokenTxArgs> {
+    getIx(args: BurnTokenIxArgs): Promise<Instruction>;
+    getTx(args: BurnTokenTxArgs): Promise<LongYieldCarryTransactionPlan>;
+    buildBundledBurnPlan(..._args: unknown[]): Promise<BundledBurnPlan>;
+    private resolveAllSentinel;
+    private resolveAsyncFallbackParams;
+    private resolveNextRequestSequence;
+    private resolveAsyncAccounts;
+    private getUnwrapSolAfterBurnIfCollateralSol;
+}

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

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BurnTokenBuilder = void 0;
+const core_1 = require("@anchor-lang/core");
+const system_1 = require("@solana-program/system");
+const token_1 = require("@solana-program/token");
+const common_1 = require("common");
+const general_1 = require("../../constants/general");
+const utils_1 = require("../../utils");
+const base_1 = require("./base");
+const utils_2 = require("./utils");
+class BurnTokenBuilder extends base_1.LongYieldCarryBuilderBase {
+    async getIx(args) {
+        const tokenData = await this.account.fetchToken(args.token);
+        const mint = tokenData.mint;
+        const collateralMint = tokenData.collateralMint;
+        const tokenProgram = (0, common_1.resolveTokenProgram)(tokenData.data.config.tokenProgram);
+        const collateralTokenProgram = (0, common_1.resolveTokenProgram)(tokenData.data.collateral.tokenProgram);
+        const userTokenAccount = await (0, common_1.getAtaAddress)(mint, args.signer, tokenProgram);
+        const userCollateralAccount = await (0, common_1.getAtaAddress)(collateralMint, args.signer, collateralTokenProgram);
+        const collateralTokenAccount = await (0, common_1.getAtaAddress)(collateralMint, args.token, collateralTokenProgram);
+        const asyncAccounts = await this.resolveAsyncAccounts(args, mint, tokenProgram);
+        const burnIxArgs = asyncAccounts
+            ? {
+                async: {
+                    burnAmount: new core_1.BN(args.params.burnAmount.toString()),
+                    epochId: new core_1.BN(asyncAccounts.epochId.toString()),
+                    requestSequence: new core_1.BN(asyncAccounts.requestSequence.toString()),
+                },
+            }
+            : {
+                sync: {
+                    burnAmount: new core_1.BN(args.params.burnAmount.toString()),
+                },
+            };
+        return this.program.methods
+            .burnToken(burnIxArgs)
+            .accountsPartial({
+            signer: args.signer,
+            payer: args.payer ?? args.signer,
+            token: args.token,
+            mint,
+            userTokenAccount,
+            collateralMint,
+            userCollateralAccount,
+            collateralTokenAccount,
+            redemptionEpoch: asyncAccounts?.redemptionEpoch ?? null,
+            request: asyncAccounts?.request ?? null,
+            requestTokenAccount: asyncAccounts?.requestTokenAccount ?? null,
+            tokenProgram,
+            collateralTokenProgram,
+            associatedTokenProgram: token_1.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+            systemProgram: system_1.SYSTEM_PROGRAM_ADDRESS,
+        })
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async getTx(args) {
+        const resolved = await this.resolveAllSentinel(args);
+        const tokenData = await this.account.fetchToken(args.token, { fresh: true });
+        const collateralTokenProgram = (0, common_1.resolveTokenProgram)(tokenData.data.collateral.tokenProgram);
+        const userCollateralAtaSetup = await this.getCreateUserCollateralAtaIxIfNeeded(args.signer, tokenData.collateralMint, collateralTokenProgram);
+        const refreshInstructions = await (0, utils_2.getRefreshTokenInstructionsIfStale)(this.context, args.signer, tokenData);
+        const asyncAccounts = await this.resolveAsyncFallbackParams(args.token, {
+            epochId: args.params.epochId,
+            requestSequence: args.params.requestSequence,
+        });
+        const instructions = [...refreshInstructions];
+        if (userCollateralAtaSetup.instruction) {
+            instructions.push(userCollateralAtaSetup.instruction);
+        }
+        instructions.push(await this.getIx({
+            signer: args.signer,
+            payer: args.payer,
+            token: args.token,
+            params: {
+                burnAmount: resolved.ixBurnAmount,
+                asyncFallback: asyncAccounts,
+            },
+        }));
+        const unwrapSolIx = await this.getUnwrapSolAfterBurnIfCollateralSol(args.signer, tokenData);
+        if (unwrapSolIx) {
+            instructions.push(unwrapSolIx);
+        }
+        const postSuccessCacheInvalidations = [
+            ...(userCollateralAtaSetup.postSuccessCacheInvalidations ?? []),
+            (0, utils_1.getTokenCacheInvalidation)(args.token),
+        ];
+        if (unwrapSolIx) {
+            const userCollateralAta = await (0, common_1.getAtaAddress)(tokenData.collateralMint, args.signer, collateralTokenProgram);
+            postSuccessCacheInvalidations.push({ client: "splAta", ata: userCollateralAta });
+        }
+        return {
+            instructions,
+            lookupTables: this.getTxLookupTables(args.token),
+            postSuccessCacheInvalidations,
+        };
+    }
+    async buildBundledBurnPlan(..._args) {
+        throw new Error("Managed burn unwind plans were removed; use async burn funding instead.");
+    }
+    async resolveAllSentinel(args) {
+        if (args.params.burnAmount !== "all") {
+            const amount = args.params.burnAmount;
+            return {
+                ...args,
+                params: { ...args.params, burnAmount: amount },
+                ixBurnAmount: new core_1.BN(amount.toString()),
+            };
+        }
+        const tokenData = await this.account.fetchToken(args.token);
+        const userTokenAta = await (0, common_1.getAtaAddress)(tokenData.mint, args.signer, (0, common_1.resolveTokenProgram)(tokenData.data.config.tokenProgram));
+        const balances = await (0, common_1.fetchSplTokenAccountAmounts)(this.rpc, [userTokenAta]);
+        return {
+            ...args,
+            params: {
+                ...args.params,
+                burnAmount: new core_1.BN((balances.get(userTokenAta) ?? BigInt(0)).toString()),
+            },
+            ixBurnAmount: general_1.AMOUNT_ALL_SENTINEL,
+        };
+    }
+    async resolveAsyncFallbackParams(token, overrides) {
+        const epochId = overrides.epochId ?? (0, utils_1.currentEpochId)();
+        const [redemptionEpoch] = await this.pda.deriveRedemptionEpochPda(token, BigInt(epochId.toString()));
+        const requestSequence = overrides.requestSequence ?? (await this.resolveNextRequestSequence(redemptionEpoch));
+        const [request] = await this.pda.deriveAsyncBurnRequestPda(token, BigInt(epochId.toString()), BigInt(requestSequence.toString()));
+        return { epochId, requestSequence, redemptionEpoch, request };
+    }
+    async resolveNextRequestSequence(redemptionEpoch) {
+        try {
+            const epoch = await this.program.account.redemptionEpoch.fetch(redemptionEpoch);
+            return new core_1.BN(epoch.sequencing.nextRequestSequence.toString());
+        }
+        catch {
+            return new core_1.BN(0);
+        }
+    }
+    async resolveAsyncAccounts(args, mint, tokenProgram) {
+        if (!args.params.asyncFallback) {
+            return undefined;
+        }
+        const epochId = args.params.asyncFallback.epochId;
+        const requestSequence = args.params.asyncFallback.requestSequence;
+        const redemptionEpoch = args.params.asyncFallback.redemptionEpoch ??
+            (await this.pda.deriveRedemptionEpochPda(args.token, BigInt(epochId.toString())))[0];
+        const request = args.params.asyncFallback.request ??
+            (await this.pda.deriveAsyncBurnRequestPda(args.token, BigInt(epochId.toString()), BigInt(requestSequence.toString())))[0];
+        return {
+            epochId,
+            requestSequence,
+            redemptionEpoch,
+            request,
+            requestTokenAccount: await (0, common_1.getAtaAddress)(mint, request, tokenProgram),
+        };
+    }
+    async getUnwrapSolAfterBurnIfCollateralSol(signer, tokenData) {
+        const solMint = common_1.mints.get("SOL");
+        if (!solMint || tokenData.collateralMint !== solMint.address) {
+            return null;
+        }
+        return (0, common_1.getUnwrapSolInstruction)((0, common_1.createSignerFromAddress)(signer));
+    }
+}
+exports.BurnTokenBuilder = BurnTokenBuilder;