@kestrelfi/lyc-sdk 1.0.1

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

@@ -0,0 +1,9 @@
+import type { Instruction } from "@solana/kit";
+import type { LongYieldCarryTransactionPlan } from "../types";
+import { LongYieldCarryBuilderBase } from "./base";
+import type { ClaimIncentivesIxArgs, ClaimIncentivesTxArgs } from "./args";
+export declare class ClaimIncentivesBuilder extends LongYieldCarryBuilderBase<ClaimIncentivesIxArgs, ClaimIncentivesTxArgs> {
+    getIx(args: ClaimIncentivesIxArgs): Promise<Instruction>;
+    getTx(args: ClaimIncentivesTxArgs): Promise<LongYieldCarryTransactionPlan>;
+    private resolveIncentiveOracle;
+}

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

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaimIncentivesBuilder = void 0;
+const base_1 = require("./base");
+const common_1 = require("common");
+const oracle_1 = require("oracle");
+const token_1 = require("@solana-program/token");
+const utils_1 = require("../../utils");
+const refreshYieldingBankBuilder_1 = require("./refreshYieldingBankBuilder");
+class ClaimIncentivesBuilder extends base_1.LongYieldCarryBuilderBase {
+    async getIx(args) {
+        const tokenData = await this.account.fetchToken(args.token);
+        const tokenIncentiveAta = await (0, common_1.getAtaAddress)(args.params.expectedIncentiveMint, args.token, args.params.incentiveTokenProgram);
+        const yieldingBankIncentiveAta = args.params.yieldingBank
+            ? await (0, common_1.getAtaAddress)(args.params.expectedIncentiveMint, args.params.yieldingBank, args.params.incentiveTokenProgram)
+            : null;
+        const feeWallet = args.params.feeWallet ?? this.resolveTokenCuratorFeeWallet(tokenData.data);
+        const feeWalletIncentiveAta = await (0, common_1.getAtaAddress)(args.params.expectedIncentiveMint, feeWallet, args.params.incentiveTokenProgram);
+        return this.program.methods
+            .claimIncentives({
+            prerequisiteCpis: args.params.prerequisiteCpis ?? null,
+            tokenIxRefs: args.params.tokenIxRefs,
+            lendingPositionIndex: args.params.lendingPositionIndex,
+            incentiveOracleType: args.params.incentiveOracleType,
+        })
+            .accountsPartial({
+            manager: this.resolveTokenManager(tokenData.data),
+            token: args.token,
+            yieldingBank: args.params.yieldingBank ?? null,
+            expectedIncentiveMint: args.params.expectedIncentiveMint,
+            tokenIncentiveAta,
+            yieldingBankIncentiveAta: yieldingBankIncentiveAta ?? null,
+            incentiveOracle: args.params.incentiveOracle ?? null,
+            feeWallet,
+            feeWalletIncentiveAta,
+            incentiveTokenProgram: args.params.incentiveTokenProgram,
+        })
+            .remainingAccounts(args.params.remainingAccounts.map(common_1.toWeb3AccountMeta))
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async getTx(args) {
+        const tokenData = await this.account.fetchToken(args.token, { fresh: true });
+        const manager = this.resolveTokenManager(tokenData.data);
+        const position = tokenData.data.lendingPositions[args.params.lendingPositionIndex];
+        const lpClients = this.lendingPlatformClients;
+        const lpClient = this.getLendingPlatformClient(position);
+        const positionPlatform = lpClients.getPlatformForPosition(position);
+        if (positionPlatform !== common_1.LendingPlatform.Kamino) {
+            throw new Error(`Unsupported lending platform for claim_incentives: ${positionPlatform}`);
+        }
+        const yieldingBank = args.params.yieldingBank ?? (await tokenData.resolveFirstYieldingBankAddress(this.pda));
+        const debtMint = (0, common_1.fromWeb3Pk)(position.accounting.debt.mint);
+        const isDebtMintIncentive = args.params.incentiveMint === debtMint;
+        const incentiveTokenProgram = isDebtMintIncentive
+            ? (0, common_1.resolveTokenProgram)(position.accounting.debt.tokenProgram)
+            : (common_1.mints.get(args.params.incentiveMint)?.tokenProgram ?? token_1.TOKEN_PROGRAM_ADDRESS);
+        const { incentiveOracle, incentiveOracleType } = this.resolveIncentiveOracle(tokenData.data, args.params);
+        let claimAccounts = args.params.claimAccounts;
+        if (!claimAccounts) {
+            const matchingIncentives = (await lpClient.getOutstandingIncentives((0, common_1.fromWeb3Pk)(position.protocolUserAcc))).filter((incentive) => incentive.mint === args.params.incentiveMint);
+            if (matchingIncentives.length !== 1 || !matchingIncentives[0].claimAccounts) {
+                throw new Error(`Unable to resolve claim accounts for incentive mint ${args.params.incentiveMint}` +
+                    ` (found ${matchingIncentives.length} matching farm(s));` +
+                    ` pass claimAccounts explicitly to disambiguate`);
+            }
+            claimAccounts = matchingIncentives[0].claimAccounts;
+        }
+        const kaminoClient = lpClients.getByPlatform(common_1.LendingPlatform.Kamino);
+        const claimCpiData = await kaminoClient.ix.getClaimIncentiveCpiData(args.token, manager, (0, common_1.fromWeb3Pk)(position.pool), (0, common_1.fromWeb3Pk)(position.collateralReserve), (0, common_1.fromWeb3Pk)(position.protocolUserAcc), claimAccounts.farm, claimAccounts.userFarm, args.params.incentiveMint);
+        const { accounts: remainingAccounts, refsGroups, lookupTables, } = (0, common_1.createMultiCpiRefs)([claimCpiData]);
+        const tokenIxRefs = refsGroups[0];
+        const { instructions: ataCreationIxs, postSuccessCacheInvalidations } = await (0, common_1.getCreateAtaInstructions)(this.rpc, manager, remainingAccounts);
+        const { instruction: createYbAtaIx, postSuccessCacheInvalidations: ybAtaCacheInv } = await (0, common_1.getCreateAtaIxIfNeeded)(this.rpc, manager, args.params.incentiveMint, yieldingBank, incentiveTokenProgram);
+        const refreshYieldingBankPlan = await new refreshYieldingBankBuilder_1.RefreshYieldingBankBuilder(this.context).getTx({
+            signer: manager,
+            yieldingBank,
+        });
+        return {
+            instructions: [
+                ...ataCreationIxs,
+                ...(createYbAtaIx ? [createYbAtaIx] : []),
+                ...refreshYieldingBankPlan.instructions,
+                await this.getIx({
+                    token: args.token,
+                    params: {
+                        tokenIxRefs,
+                        lendingPositionIndex: args.params.lendingPositionIndex,
+                        yieldingBank,
+                        expectedIncentiveMint: args.params.incentiveMint,
+                        incentiveTokenProgram,
+                        incentiveOracle,
+                        incentiveOracleType,
+                        feeWallet: this.resolveTokenCuratorFeeWallet(tokenData.data),
+                        remainingAccounts,
+                    },
+                }),
+            ],
+            lookupTables: this.getTxLookupTables(args.token, lookupTables ?? []),
+            postSuccessCacheInvalidations: [
+                ...postSuccessCacheInvalidations,
+                ...ybAtaCacheInv,
+                (0, utils_1.getTokenCacheInvalidation)(args.token),
+                (0, utils_1.getYieldingBankCacheInvalidation)(yieldingBank),
+            ],
+        };
+    }
+    resolveIncentiveOracle(tokenData, params) {
+        for (const lp of tokenData.lendingPositions) {
+            const debtMint = (0, common_1.fromWeb3Pk)(lp.accounting.debt.mint);
+            if (debtMint !== params.incentiveMint)
+                continue;
+            return {
+                incentiveOracle: (0, common_1.fromWeb3Pk)(lp.accounting.debt.oracle),
+                incentiveOracleType: lp.accounting.debt.oracleType,
+            };
+        }
+        if (params.incentiveOracle && params.incentiveOracleType) {
+            return {
+                incentiveOracle: params.incentiveOracle,
+                incentiveOracleType: params.incentiveOracleType,
+            };
+        }
+        const symbol = common_1.mints.get(params.incentiveMint)?.symbol;
+        const pythFeed = symbol ? oracle_1.PYTH_FEEDS[symbol] : undefined;
+        if (pythFeed) {
+            return {
+                incentiveOracle: pythFeed.account,
+                incentiveOracleType: { pyth: {} },
+            };
+        }
+        throw new Error(`claim_incentives: cannot auto-resolve oracle for incentive mint ${params.incentiveMint}; pass incentiveOracle and incentiveOracleType explicitly`);
+    }
+}
+exports.ClaimIncentivesBuilder = ClaimIncentivesBuilder;

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

@@ -0,0 +1,14 @@
+import type { Address, Instruction } from "@solana/kit";
+import { LongYieldCarrySingleInstructionBuilderService } from "./base";
+import type { CollectFeesIxArgs } from "./args";
+/**
+ * Collects pending fees for either the curator or the protocol. The caller
+ * passes the `authority` signer. If it is `PROTOCOL_ADMIN`, the protocol bucket and
+ * protocol fee wallet are used (even when that address is also the token curator).
+ * Otherwise, if it is the curator only, the curator bucket and curator fee wallet are used.
+ * Throws client-side if the signer matches neither role (mirroring the on-chain check).
+ */
+export declare class CollectFeesBuilder extends LongYieldCarrySingleInstructionBuilderService<CollectFeesIxArgs> {
+    getIx(args: CollectFeesIxArgs): Promise<Instruction>;
+    protected buildLookupTables(args: CollectFeesIxArgs): Promise<readonly Address[]>;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectFeesBuilder = void 0;
+const common_1 = require("common");
+const general_1 = require("../../constants/general");
+const base_1 = require("./base");
+/**
+ * Collects pending fees for either the curator or the protocol. The caller
+ * passes the `authority` signer. If it is `PROTOCOL_ADMIN`, the protocol bucket and
+ * protocol fee wallet are used (even when that address is also the token curator).
+ * Otherwise, if it is the curator only, the curator bucket and curator fee wallet are used.
+ * Throws client-side if the signer matches neither role (mirroring the on-chain check).
+ */
+class CollectFeesBuilder extends base_1.LongYieldCarrySingleInstructionBuilderService {
+    async getIx(args) {
+        const tokenData = await this.account.fetchToken(args.token);
+        const mint = tokenData.mint;
+        const tokenProgram = (0, common_1.resolveTokenProgram)(tokenData.data.config.tokenProgram);
+        const curator = (0, common_1.fromWeb3Pk)(tokenData.data.roles.curator);
+        const protocolAdmin = general_1.PROTOCOL_ADMIN[this.environment];
+        let feeWallet;
+        if (args.authority === curator) {
+            feeWallet = this.resolveTokenCuratorFeeWallet(tokenData.data);
+        }
+        else if (args.authority === protocolAdmin) {
+            feeWallet = this.protocolFeeWallet;
+        }
+        else {
+            throw new Error(`collectFees: authority ${args.authority} is neither the token's curator ` +
+                `(${curator}) nor PROTOCOL_ADMIN (${protocolAdmin})`);
+        }
+        const feeWalletTokenAccount = await (0, common_1.getAtaAddress)(mint, feeWallet, tokenProgram);
+        return this.program.methods
+            .collectFees()
+            .accountsPartial({
+            authority: args.authority,
+            token: args.token,
+            mint,
+            feeWallet,
+            feeWalletTokenAccount,
+            tokenProgram,
+        })
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async buildLookupTables(args) {
+        return this.getTxLookupTables(args.token);
+    }
+}
+exports.CollectFeesBuilder = CollectFeesBuilder;

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

@@ -0,0 +1,8 @@
+import type { Instruction } from "@solana/kit";
+import type { LongYieldCarryTransactionPlan } from "../types";
+import { LongYieldCarryBuilderBase } from "./base";
+import type { CollectInterestIxArgs, CollectInterestTxArgs } from "./args";
+export declare class CollectInterestBuilder extends LongYieldCarryBuilderBase<CollectInterestIxArgs, CollectInterestTxArgs> {
+    getIx(args: CollectInterestIxArgs): Promise<Instruction>;
+    getTx(args: CollectInterestTxArgs): Promise<LongYieldCarryTransactionPlan>;
+}

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectInterestBuilder = void 0;
+const base_1 = require("./base");
+const collectInterest_1 = require("../plans/collectInterest");
+const collectInterest_2 = require("../routes/collectInterest");
+const common_1 = require("common");
+class CollectInterestBuilder extends base_1.LongYieldCarryBuilderBase {
+    async getIx(args) {
+        const tokenData = await this.account.fetchToken(args.token);
+        const collateralMint = (0, common_1.fromWeb3Pk)(tokenData.data.collateral.mint);
+        const collateralOracle = (0, common_1.fromWeb3Pk)(tokenData.data.collateral.oracle);
+        const secondaryCollateralOracle = this.resolveOptionalSecondaryCollateralOracle(tokenData.data.collateral);
+        const collateralTokenProgram = (0, common_1.resolveTokenProgram)(tokenData.data.collateral.tokenProgram);
+        const { redemption } = args.params;
+        const collateralTokenAccount = await (0, common_1.getAtaAddress)(collateralMint, args.token, collateralTokenProgram);
+        const ybCollateralTokenAccount = await (0, common_1.getAtaAddress)(collateralMint, args.yieldingBank, collateralTokenProgram);
+        const ybRedemptionTokenAccount = await (0, common_1.getAtaAddress)(redemption.mint, args.yieldingBank, redemption.tokenProgram);
+        const curatorFeeWallet = this.resolveTokenCuratorFeeWallet(tokenData.data);
+        const protocolFeeWallet = this.protocolFeeWallet;
+        const curatorFeeWalletCollateralAccount = await (0, common_1.getAtaAddress)(collateralMint, curatorFeeWallet, collateralTokenProgram);
+        const protocolFeeWalletCollateralAccount = await (0, common_1.getAtaAddress)(collateralMint, protocolFeeWallet, collateralTokenProgram);
+        return this.program.methods
+            .collectInterest(args.params.refs)
+            .accountsPartial({
+            manager: this.resolveTokenManager(tokenData.data),
+            token: args.token,
+            yieldingBank: args.yieldingBank,
+            collateralMint,
+            collateralOracle,
+            secondaryCollateralOracle,
+            redemptionOracle: redemption.oracle,
+            collateralTokenAccount,
+            ybCollateralTokenAccount,
+            ybRedemptionTokenAccount,
+            curatorFeeWalletCollateralAccount,
+            protocolFeeWalletCollateralAccount,
+            collateralTokenProgram,
+        })
+            .remainingAccounts(args.params.remainingAccounts.map(common_1.toWeb3AccountMeta))
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async getTx(args) {
+        const plan = await (0, collectInterest_1.buildCollectInterestPlan)(this.account, args.token, args.params);
+        (0, collectInterest_1.assertCollectInterestPlanHasPositiveRedemptions)(plan);
+        const executionPlan = await (0, collectInterest_2.buildCollectInterestRoutePlan)(this.swap, plan, args.params, args.manager);
+        const { collateral, redemption, cpiData } = executionPlan;
+        const { accounts: remainingAccounts, refs, lookupTables, } = (0, common_1.createCpiRefs)(cpiData, {
+            initialAccounts: [],
+        });
+        const tokenData = await this.account.fetchToken(args.token);
+        const { instruction: ybCollateralAtaIx, postSuccessCacheInvalidations: ybCollateralAtaCacheInv, } = await (0, common_1.getCreateAtaIxIfNeeded)(this.rpc, args.manager, collateral.mint, args.params.yieldingBank, collateral.tokenProgram);
+        const curatorFeeWallet = this.resolveTokenCuratorFeeWallet(tokenData.data);
+        const protocolFeeWallet = this.protocolFeeWallet;
+        const { instruction: curatorPerfFeeAtaIx, postSuccessCacheInvalidations: curatorPerfFeeAtaCacheInv, } = await (0, common_1.getCreateAtaIxIfNeeded)(this.rpc, args.manager, collateral.mint, curatorFeeWallet, collateral.tokenProgram);
+        const { instruction: protocolPerfFeeAtaIx, postSuccessCacheInvalidations: protocolPerfFeeAtaCacheInv, } = await (0, common_1.getCreateAtaIxIfNeeded)(this.rpc, args.manager, collateral.mint, protocolFeeWallet, collateral.tokenProgram);
+        const { instructions, postSuccessCacheInvalidations } = await (0, common_1.getCreateAtaInstructions)(this.rpc, args.manager, remainingAccounts);
+        return {
+            instructions: [
+                ...executionPlan.preInstructions,
+                ...(ybCollateralAtaIx ? [ybCollateralAtaIx] : []),
+                ...(curatorPerfFeeAtaIx ? [curatorPerfFeeAtaIx] : []),
+                ...(protocolPerfFeeAtaIx ? [protocolPerfFeeAtaIx] : []),
+                ...instructions,
+                await this.getIx({
+                    token: args.token,
+                    yieldingBank: args.params.yieldingBank,
+                    params: {
+                        redemption,
+                        refs,
+                        remainingAccounts,
+                    },
+                }),
+            ],
+            lookupTables: this.getTxLookupTables(args.token, lookupTables ?? []),
+            postSuccessCacheInvalidations: [
+                ...ybCollateralAtaCacheInv,
+                ...curatorPerfFeeAtaCacheInv,
+                ...protocolPerfFeeAtaCacheInv,
+                ...postSuccessCacheInvalidations,
+            ],
+        };
+    }
+}
+exports.CollectInterestBuilder = CollectInterestBuilder;

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

@@ -0,0 +1,6 @@
+import type { Instruction } from "@solana/kit";
+import { LongYieldCarrySingleInstructionBuilderService } from "./base";
+import type { CreateCpiPlanIxArgs } from "./args";
+export declare class CreateCpiPlanBuilder extends LongYieldCarrySingleInstructionBuilderService<CreateCpiPlanIxArgs> {
+    getIx(args: CreateCpiPlanIxArgs): Promise<Instruction>;
+}

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateCpiPlanBuilder = void 0;
+const common_1 = require("common");
+const base_1 = require("./base");
+class CreateCpiPlanBuilder extends base_1.LongYieldCarrySingleInstructionBuilderService {
+    async getIx(args) {
+        return this.program.methods
+            .createCpiPlan({
+            uniqueId: (0, common_1.toWeb3Pk)(args.params.uniqueId),
+            createdTs: args.params.createdTs,
+            refs: args.params.refs,
+        })
+            .accountsPartial({
+            manager: args.manager,
+            cpiPlan: args.cpiPlan,
+        })
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+}
+exports.CreateCpiPlanBuilder = CreateCpiPlanBuilder;

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

@@ -0,0 +1,7 @@
+import type { Address, Instruction } from "@solana/kit";
+import { LongYieldCarrySingleInstructionBuilderService } from "./base";
+import type { CreateTokenIxArgs } from "./args";
+export declare class CreateTokenBuilder extends LongYieldCarrySingleInstructionBuilderService<CreateTokenIxArgs> {
+    getIx(args: CreateTokenIxArgs): Promise<Instruction>;
+    protected buildLookupTables(): Promise<readonly Address[]>;
+}

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateTokenBuilder = void 0;
+const core_1 = require("@anchor-lang/core");
+const token_1 = require("@solana-program/token");
+const common_1 = require("common");
+const general_1 = require("../../constants/general");
+const base_1 = require("./base");
+const DEFAULT_FEE_DRIP_MAX_APY_BPS = 200;
+const DEFAULT_FEE_DRIP_DURATION_SECS = 3 * 24 * 60 * 60;
+class CreateTokenBuilder extends base_1.LongYieldCarrySingleInstructionBuilderService {
+    async getIx(args) {
+        const [tokenPda] = await this.pda.deriveTokenPda(args.mint, args.params.id);
+        const tokenProgram = args.tokenProgram ?? token_1.TOKEN_PROGRAM_ADDRESS;
+        const collateralTokenProgram = args.collateralTokenProgram ?? token_1.TOKEN_PROGRAM_ADDRESS;
+        // Keep local omission behavior unchanged for existing tests. Deployed
+        // environments default to a capped three-day release schedule.
+        const defaultFeeDripMaxApyBps = this.environment === "local" ? 0 : DEFAULT_FEE_DRIP_MAX_APY_BPS;
+        const defaultFeeDripDurationSecs = this.environment === "local" ? 0 : DEFAULT_FEE_DRIP_DURATION_SECS;
+        const collateralTokenAccount = await (0, common_1.getAtaAddress)(args.collateralMint, tokenPda, collateralTokenProgram);
+        const curator = args.curator ?? general_1.PROTOCOL_ADMIN[this.environment];
+        return this.program.methods
+            .createToken({
+            id: args.params.id,
+            interestDistribution: args.params.interestDistribution,
+            oracleConfig: {
+                oracle: (0, common_1.toWeb3Pk)(args.params.oracleConfig.oracle),
+                oracleType: args.params.oracleConfig.oracleType,
+                secondaryOracle: args.params.oracleConfig.secondaryOracle
+                    ? (0, common_1.toWeb3Pk)(args.params.oracleConfig.secondaryOracle)
+                    : null,
+            },
+            feeConfig: {
+                performanceFeeBps: args.params.feeConfig.performanceFeeBps,
+                mintingFeeBps: args.params.feeConfig.mintingFeeBps,
+                burningFeeBps: args.params.feeConfig.burningFeeBps,
+                protocolMintBurnPctBps: args.params.feeConfig.protocolMintBurnPctBps,
+                curatorMintBurnPctBps: args.params.feeConfig.curatorMintBurnPctBps,
+                curatorPerfPctBps: args.params.feeConfig.curatorPerfPctBps,
+                feeDripMaxApyBps: args.params.feeConfig.feeDripMaxApyBps ?? defaultFeeDripMaxApyBps,
+                feeDripDurationSecs: args.params.feeConfig.feeDripDurationSecs ?? new core_1.BN(defaultFeeDripDurationSecs),
+            },
+        })
+            .accountsPartial({
+            curator,
+            adminRole: args.adminRole ?? null,
+            managerRole: args.managerRole ?? null,
+            feesRole: args.feesRole ?? null,
+            cbControllerRole: args.cbControllerRole ?? null,
+            token: tokenPda,
+            mint: args.mint,
+            collateralMint: args.collateralMint,
+            collateralTokenAccount,
+            tokenProgram,
+            collateralTokenProgram,
+        })
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async buildLookupTables() {
+        return this.getTxLookupTables();
+    }
+}
+exports.CreateTokenBuilder = CreateTokenBuilder;

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

@@ -0,0 +1,10 @@
+import type { Instruction } from "@solana/kit";
+import { LongYieldCarryBuilderBase } from "./base";
+import type { CreateTokenLendingPositionIxArgs, CreateTokenLendingPositionTxArgs } from "./args";
+import type { LongYieldCarryTransactionPlan } from "../types";
+export declare class CreateTokenLendingPositionBuilder extends LongYieldCarryBuilderBase<CreateTokenLendingPositionIxArgs, CreateTokenLendingPositionTxArgs> {
+    getIx(args: CreateTokenLendingPositionIxArgs): Promise<Instruction>;
+    getTx(txArgs: CreateTokenLendingPositionTxArgs): Promise<LongYieldCarryTransactionPlan>;
+    private buildSetupCpis;
+    private buildRefreshCpis;
+}

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

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateTokenLendingPositionBuilder = void 0;
+const common_1 = require("common");
+const utils_1 = require("../../utils");
+const base_1 = require("./base");
+class CreateTokenLendingPositionBuilder extends base_1.LongYieldCarryBuilderBase {
+    async getIx(args) {
+        const tokenData = await this.account.fetchToken(args.token);
+        return this.program.methods
+            .createTokenLendingPosition({
+            lendingPlatform: args.params.lendingPlatform,
+            pool: (0, common_1.toWeb3Pk)(args.params.pool),
+            debtReserve: (0, common_1.toWeb3Pk)(args.params.debtReserve),
+            targetUtilizationRateBps: args.params.targetUtilizationRateBps,
+            maxDeviationAboveTargetUtilBps: args.params.maxDeviationAboveTargetUtilBps,
+            maxDeviationBelowTargetUtilBps: args.params.maxDeviationBelowTargetUtilBps,
+            debtMint: (0, common_1.toWeb3Pk)(args.params.debtMint),
+            debtDecimals: args.params.debtDecimals,
+            debtTokenProgram: args.params.debtTokenProgram,
+            debtOracleType: args.params.debtOracleType,
+            tokenCpis: args.params.tokenCpis ?? null,
+        })
+            .accountsPartial({
+            manager: this.resolveTokenManager(tokenData.data),
+            token: args.token,
+            lpPosition: {
+                userAccount: args.accounts.protocolUserAcc,
+                collateralReserve: args.accounts.collateralReserve,
+                debtOracle: args.accounts.debtOracle,
+            },
+        })
+            .remainingAccounts((args.params.remainingAccounts ?? []).map(common_1.toWeb3AccountMeta))
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async getTx(txArgs) {
+        const tokenData = await this.account.fetchToken(txArgs.token);
+        const manager = this.resolveTokenManager(tokenData.data);
+        const lendingPlatform = txArgs.lendingPlatform ?? common_1.LendingPlatform.Kamino;
+        const lpClient = this.lendingPlatformClients.getByPlatform(lendingPlatform);
+        const pool = txArgs.pool ?? (0, utils_1.resolveDefaultPool)(tokenData.collateralMint);
+        const duplicatePosition = tokenData.data.lendingPositions.find((p) => (0, common_1.lendingPlatformToEnum)(p.platform) !== common_1.LendingPlatform.None &&
+            (0, common_1.fromWeb3Pk)(p.pool) === pool &&
+            (0, common_1.fromWeb3Pk)(p.accounting.debt.mint) === txArgs.debtMint);
+        if (duplicatePosition) {
+            throw new Error(`Token ${txArgs.token} already has a lending position on pool ${pool} ` +
+                `with debt mint ${txArgs.debtMint}. Use updateLendingPositionConfig to ` +
+                `modify the existing position instead of creating a duplicate.`);
+        }
+        const userAccountId = txArgs.userAccountId ??
+            (await (0, utils_1.getAvailableTokenLendingUserAccountId)({
+                lendingClient: lpClient,
+                token: tokenData,
+                pool,
+                lendingPlatform,
+            }));
+        const txId = txArgs.txId ?? `create-token-lending-position-${Date.now()}`;
+        const allocation = await (0, utils_1.buildLendingPositionAllocation)({
+            lendingClient: lpClient,
+            tokenPda: txArgs.token,
+            collateralMint: tokenData.collateralMint,
+            debtMint: txArgs.debtMint,
+            debtReserve: txArgs.debtReserve,
+            userAccountId,
+            pool,
+            lendingPlatform,
+            targetUtilizationRateBps: txArgs.targetUtilizationRateBps,
+            maxDeviationAboveTargetUtilBps: txArgs.maxDeviationAboveTargetUtilBps,
+            maxDeviationBelowTargetUtilBps: txArgs.maxDeviationBelowTargetUtilBps,
+        });
+        const tokenCpisData = await this.buildSetupCpis(lpClient, allocation, txArgs.token, manager, userAccountId);
+        const { accounts: remainingAccounts, refs: tokenCpis, lookupTables, } = tokenCpisData.length
+            ? (0, common_1.createCpiRefs)(tokenCpisData)
+            : { accounts: [], refs: undefined, lookupTables: [] };
+        const preInstructions = tokenCpisData.length ? await lpClient.ix.getPreInstructions(txId) : [];
+        const { instructions: ataCreationIxs, postSuccessCacheInvalidations: ataCacheInvalidations } = tokenCpisData.length
+            ? await (0, common_1.getCreateAtaInstructions)(this.rpc, manager, remainingAccounts)
+            : { instructions: [], postSuccessCacheInvalidations: [] };
+        // Pre-create the token PDA's debt-mint ATA. Kamino's borrow CPI uses
+        // this ATA as `user_destination_liquidity` and fails with
+        // `AccountNotInitialized` (Anchor 3012) if the token has never held
+        // this mint. Creating it at LP setup means future rebalances/borrows
+        // against this LP don't have to reason about whether the ATA exists.
+        // The dedup-pool ATA pass above can drop the `isRequiredAta` flag if
+        // the same address appears in an earlier CPI without seeds, so we add
+        // an explicit idempotent create here.
+        const debtMintInfo = common_1.mints.get(txArgs.debtMint);
+        if (!debtMintInfo) {
+            throw new Error(`CreateTokenLendingPositionBuilder: debt mint ${txArgs.debtMint} not found in mint registry`);
+        }
+        const { instruction: debtAtaIx, postSuccessCacheInvalidations: debtAtaCacheInvalidations } = await (0, common_1.getCreateAtaIxIfNeeded)(this.rpc, manager, txArgs.debtMint, txArgs.token, debtMintInfo.tokenProgram);
+        const ix = await this.getIx({
+            token: txArgs.token,
+            accounts: allocation.accounts,
+            params: {
+                ...allocation.params,
+                tokenCpis,
+                remainingAccounts,
+            },
+        });
+        const cpiCacheInvalidations = tokenCpisData.flatMap((cpi) => cpi.postSuccessCacheInvalidations ?? []);
+        return {
+            instructions: [...preInstructions, ...ataCreationIxs, ...(debtAtaIx ? [debtAtaIx] : []), ix],
+            lookupTables: this.getTxLookupTables(txArgs.token, lookupTables ?? []),
+            postSuccessCacheInvalidations: [
+                (0, utils_1.getTokenCacheInvalidation)(txArgs.token),
+                ...cpiCacheInvalidations,
+                ...ataCacheInvalidations,
+                ...debtAtaCacheInvalidations,
+            ],
+            txId,
+        };
+    }
+    async buildSetupCpis(lpClient, allocation, token, manager, userAccountId) {
+        const initBundle = await lpClient.ix.getInitLendingPositionCpiData({
+            pool: allocation.pool,
+            user: token,
+            payer: manager,
+            userAccountId,
+            collateralReserve: allocation.collateralReserve,
+            debtReserve: allocation.debtReserve,
+        });
+        const refreshCpis = await this.buildRefreshCpis(lpClient, allocation);
+        return [...initBundle.allCpis, ...refreshCpis];
+    }
+    async buildRefreshCpis(lpClient, allocation) {
+        return lpClient.ix.getPrerequisiteCpisForRefresh([
+            {
+                pool: allocation.pool,
+                userAccount: allocation.protocolUserAccount,
+                collateralReserves: [allocation.collateralReserve],
+                debtReserves: [allocation.debtReserve],
+            },
+        ]);
+    }
+}
+exports.CreateTokenLendingPositionBuilder = CreateTokenLendingPositionBuilder;

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

@@ -0,0 +1,7 @@
+import type { Address, Instruction } from "@solana/kit";
+import { LongYieldCarrySingleInstructionBuilderService } from "./base";
+import type { CreateYieldingBankAllocationIxArgs } from "./args";
+export declare class CreateYieldingBankAllocationBuilder extends LongYieldCarrySingleInstructionBuilderService<CreateYieldingBankAllocationIxArgs> {
+    getIx(args: CreateYieldingBankAllocationIxArgs): Promise<Instruction>;
+    protected buildLookupTables(): Promise<readonly Address[]>;
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateYieldingBankAllocationBuilder = void 0;
+const common_1 = require("common");
+const ix_1 = require("../../utils/ix");
+const base_1 = require("./base");
+class CreateYieldingBankAllocationBuilder extends base_1.LongYieldCarrySingleInstructionBuilderService {
+    async getIx(args) {
+        const allocationMint = args.config.assetHolding?.mint;
+        if (!allocationMint) {
+            throw new Error("createYieldingBankAllocation requires config.assetHolding.mint " +
+                "to populate the allocation_mint account");
+        }
+        const bankData = await this.account.fetchYieldingBank(args.yieldingBank);
+        return this.program.methods
+            .createYieldingBankAllocation((0, ix_1.toAnchorAllocationConfig)(args.config))
+            .accountsPartial({
+            manager: this.resolveYieldingBankManager(bankData.data),
+            yieldingBank: args.yieldingBank,
+            allocationMint,
+        })
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async buildLookupTables() {
+        return this.getTxLookupTables();
+    }
+}
+exports.CreateYieldingBankAllocationBuilder = CreateYieldingBankAllocationBuilder;

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

@@ -0,0 +1,7 @@
+import type { Address, Instruction } from "@solana/kit";
+import { LongYieldCarrySingleInstructionBuilderService } from "./base";
+import type { CreateYieldingBankIxArgs } from "./args";
+export declare class CreateYieldingBankBuilder extends LongYieldCarrySingleInstructionBuilderService<CreateYieldingBankIxArgs> {
+    getIx(args: CreateYieldingBankIxArgs): Promise<Instruction>;
+    protected buildLookupTables(): Promise<readonly Address[]>;
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateYieldingBankBuilder = void 0;
+const token_1 = require("@solana-program/token");
+const common_1 = require("common");
+const general_1 = require("../../constants/general");
+const base_1 = require("./base");
+class CreateYieldingBankBuilder extends base_1.LongYieldCarrySingleInstructionBuilderService {
+    async getIx(args) {
+        const [yieldingBankPda] = await this.pda.deriveYieldingBankPda(args.baseMint, args.params.id);
+        return this.program.methods
+            .createYieldingBank({
+            id: args.params.id,
+            oracleConfig: {
+                oracle: (0, common_1.toWeb3Pk)(args.params.oracleConfig.oracle),
+                oracleType: args.params.oracleConfig.oracleType,
+                secondaryOracle: args.params.oracleConfig.secondaryOracle
+                    ? (0, common_1.toWeb3Pk)(args.params.oracleConfig.secondaryOracle)
+                    : null,
+            },
+        })
+            .accountsPartial({
+            curator: args.curator ?? general_1.PROTOCOL_ADMIN[this.environment],
+            adminRole: args.adminRole ?? null,
+            managerRole: args.managerRole ?? null,
+            cbControllerRole: args.cbControllerRole ?? null,
+            baseMint: args.baseMint,
+            defaultRedemptionMint: args.params.defaultRedemptionMint,
+            yieldingBank: yieldingBankPda,
+            baseMintTokenProgram: args.baseMintTokenProgram ?? token_1.TOKEN_PROGRAM_ADDRESS,
+        })
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async buildLookupTables() {
+        return this.getTxLookupTables();
+    }
+}
+exports.CreateYieldingBankBuilder = CreateYieldingBankBuilder;