@kestrelfi/lyc-sdk 1.0.1

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

@@ -0,0 +1,30 @@
+import type { Address, Instruction } from "@solana/kit";
+import type { DecreaseCarryPositionTxBuilderParams, DecreaseCarryPositionTxParams, LongYieldCarryTransactionPlan } from "../types";
+import type { LongYieldCarryBuilderContext } from "../types/builders";
+import { LongYieldCarryBuilderBase } from "./base";
+import type { DecreaseCarryPositionIxArgs, DecreaseCarryPositionTxArgs } from "./args";
+import { type ResolvedDecreaseCarryCpiPlan } from "../../utils";
+export type { ResolvedDecreaseCarryCpiPlan } from "../../utils";
+/**
+ * Options for {@link DecreaseCarryPositionBuilder.buildTx}. Supports pre-merged CPI accounts
+ * and custom heap size.
+ */
+export type DecreaseCarryPositionBuildTxOptions = {
+    includePreInstructions: boolean;
+    /** Defaults to {@link MAX_HEAP_FRAME_BYTES}. */
+    heapFrameBytes?: number;
+    /**
+     * When set, skips internal {@link resolveDecreaseCarryCpiPlan}(plan). Use when remaining
+     * accounts already include additional CPI account slots (e.g. lending withdraw merged for burn).
+     */
+    resolvedCpiPlan?: ResolvedDecreaseCarryCpiPlan;
+    /** When set, the DCP loss is attributed to this epoch instead of socialised into the price. */
+    redemptionEpoch?: Address;
+};
+export declare class DecreaseCarryPositionBuilder extends LongYieldCarryBuilderBase<DecreaseCarryPositionIxArgs, DecreaseCarryPositionTxArgs> {
+    constructor(context: LongYieldCarryBuilderContext);
+    getIx(args: DecreaseCarryPositionIxArgs): Promise<Instruction>;
+    getTx(args: DecreaseCarryPositionTxArgs): Promise<LongYieldCarryTransactionPlan>;
+    buildTx(signer: Address, token: Address, params: DecreaseCarryPositionTxParams, options: DecreaseCarryPositionBuildTxOptions): Promise<LongYieldCarryTransactionPlan>;
+    buildPlan(signer: Address, token: Address, params: DecreaseCarryPositionTxBuilderParams): Promise<import("../types").DecreaseCarryPositionPlan>;
+}

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecreaseCarryPositionBuilder = void 0;
+const base_1 = require("./base");
+const lending_platforms_1 = require("lending-platforms");
+const common_1 = require("common");
+const decreaseCarryPosition_1 = require("../plans/decreaseCarryPosition");
+const general_1 = require("../../constants/general");
+const utils_1 = require("../../utils");
+class DecreaseCarryPositionBuilder extends base_1.LongYieldCarryBuilderBase {
+    constructor(context) {
+        super(context);
+    }
+    async getIx(args) {
+        return this.program.methods
+            .decreaseCarryPosition({
+            prerequisiteCpis: args.params.prerequisiteCpis ?? null,
+            targetUtilizationRateBps: args.params.targetUtilizationRateBps ?? null,
+            ybIxRefs: args.params.ybIxRefs ?? null,
+            tokenIxRefs: args.params.tokenIxRefs,
+            lendingPositionIndex: args.params.lendingPositionIndex,
+            repayAmount: args.params.repayAmount ?? null,
+            sourceAssetHoldingIndex: args.params.sourceAssetHoldingIndex ?? null,
+        })
+            .accountsPartial({
+            signer: args.signer,
+            redemptionEpoch: args.params.redemptionEpoch ?? null,
+        })
+            .remainingAccounts(args.params.remainingAccounts.map(common_1.toWeb3AccountMeta))
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async getTx(args) {
+        return this.buildTx(args.signer, args.token, args.params, {
+            includePreInstructions: true,
+            redemptionEpoch: args.redemptionEpoch,
+        });
+    }
+    async buildTx(signer, token, params, options) {
+        const plan = "plan" in params ? params.plan : await this.buildPlan(signer, token, params);
+        const tokenData = await this.account.fetchToken(token);
+        const position = tokenData.data.lendingPositions[plan.lendingPositionIndex];
+        const instructions = [];
+        if (options.includePreInstructions) {
+            instructions.push(...plan.preInstructions);
+        }
+        const { accounts: remainingAccounts, prerequisiteCpis, tokenIxRefs, ybIxRefs, lookupTables, } = options.resolvedCpiPlan ?? (0, utils_1.resolveDecreaseCarryCpiPlan)(plan);
+        const { instructions: ataCreationIxs, postSuccessCacheInvalidations: ataPostSuccess } = await (0, common_1.getCreateAtaInstructions)(this.rpc, signer, remainingAccounts);
+        instructions.push(...ataCreationIxs);
+        const decreaseCarryIx = await this.getIx({
+            signer,
+            params: {
+                prerequisiteCpis,
+                targetUtilizationRateBps: plan.targetUtilizationRateBps,
+                ybIxRefs,
+                tokenIxRefs,
+                lendingPositionIndex: plan.lendingPositionIndex,
+                ...(plan.omitOnChainRepayAmount ? {} : { repayAmount: plan.repayAmount }),
+                sourceAssetHoldingIndex: plan.sourceAssetHoldingIndex,
+                redemptionEpoch: options.redemptionEpoch,
+                remainingAccounts,
+            },
+        });
+        if (options.includePreInstructions) {
+            // Heap configuration applies only to its transaction, so keep it
+            // adjacent to and indivisible from the CPI-heavy instruction. Earlier
+            // refresh and ATA setup instructions remain available to the splitter.
+            instructions.push((0, common_1.requestHeapFrameIx)(options.heapFrameBytes ?? general_1.MAX_HEAP_FRAME_BYTES), decreaseCarryIx);
+        }
+        else {
+            instructions.push(decreaseCarryIx);
+        }
+        const postSuccessCacheInvalidations = [
+            (0, utils_1.getTokenCacheInvalidation)(token),
+            (0, utils_1.getYieldingBankCacheInvalidation)(plan.yieldingBank),
+            (0, lending_platforms_1.getLendingUserAccountCacheInvalidation)((0, common_1.fromWeb3Pk)(position.protocolUserAcc)),
+            ...ataPostSuccess,
+        ];
+        return {
+            instructions,
+            lookupTables: this.getTxLookupTables(token, lookupTables ?? []),
+            segmentLengths: options.includePreInstructions
+                ? [...instructions.slice(0, -2).map(() => 1), 2]
+                : undefined,
+            postSuccessCacheInvalidations,
+        };
+    }
+    async buildPlan(signer, token, params) {
+        const tokenData = await this.account.fetchToken(token);
+        const position = tokenData.data.lendingPositions[params.lendingPositionIndex];
+        const lpClient = this.getLendingPlatformClient(position);
+        return (0, decreaseCarryPosition_1.buildDecreaseCarryPositionPlan)(this.account, this.swap, signer, token, {
+            ...params,
+            lendingIx: lpClient.ix,
+            environment: this.context.environment,
+        });
+    }
+}
+exports.DecreaseCarryPositionBuilder = DecreaseCarryPositionBuilder;

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

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

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DepositUnlentCollateralBuilder = void 0;
+const base_1 = require("./base");
+const common_1 = require("common");
+class DepositUnlentCollateralBuilder extends base_1.LongYieldCarryBuilderBase {
+    async getIx(args) {
+        const tokenData = await this.account.fetchToken(args.token);
+        const position = tokenData.data.lendingPositions[args.params.lendingPositionIndex];
+        const collateralMint = (0, common_1.fromWeb3Pk)(tokenData.data.collateral.mint);
+        const collateralTokenProgram = (0, common_1.resolveTokenProgram)(tokenData.data.collateral.tokenProgram);
+        return this.program.methods
+            .depositUnlentCollateral(args.params.ixRefs, args.params.lendingPositionIndex)
+            .accountsPartial({
+            manager: this.resolveTokenManager(tokenData.data),
+            token: args.token,
+            collateralMint,
+            collateralTokenProgram,
+            lendingPositionUserAccount: position ? (0, common_1.fromWeb3Pk)(position.protocolUserAcc) : args.token,
+            lendingPositionCollateralReserve: position
+                ? (0, common_1.fromWeb3Pk)(position.collateralReserve)
+                : args.token,
+        })
+            .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: args.params.depositAll });
+        const position = tokenData.data.lendingPositions[args.params.lendingPositionIndex];
+        const uiAmount = args.params.depositAll
+            ? (0, common_1.toUiAmount)(tokenData.data.collateral.unlentAmount, tokenData.data.collateral.decimals)
+            : args.params.uiAmount;
+        if (args.params.depositAll && uiAmount === 0) {
+            throw new Error(`depositAll: unlentAmount is 0 on token ${args.token} (raw: ${tokenData.data.collateral.unlentAmount})`);
+        }
+        const txId = args.params.txId ??
+            `deposit-unlent-collateral-${Date.now()}-${position.protocolUserAcc.toBase58()}`;
+        const manager = this.resolveTokenManager(tokenData.data);
+        const cpiBundle = await this.getLendingOperationCpiData(args.token, manager, position, txId, "deposit", uiAmount);
+        const { accounts: remainingAccounts, refs: ixRefs, lookupTables, } = (0, common_1.createCpiRefs)(cpiBundle.allCpis);
+        const lpClient = this.getLendingPlatformClient(position);
+        const preInstructions = await lpClient.ix.getPreInstructions(txId);
+        const { instructions: ataCreationIxs, postSuccessCacheInvalidations } = await (0, common_1.getCreateAtaInstructions)(this.rpc, args.manager, remainingAccounts);
+        const depositIx = await this.getIx({
+            token: args.token,
+            params: {
+                ixRefs,
+                lendingPositionIndex: args.params.lendingPositionIndex,
+                remainingAccounts,
+            },
+        });
+        return {
+            instructions: [...preInstructions, ...ataCreationIxs, depositIx],
+            lookupTables: this.getTxLookupTables(args.token, lookupTables ?? []),
+            postSuccessCacheInvalidations: [
+                ...cpiBundle.postSuccessCacheInvalidations,
+                ...postSuccessCacheInvalidations,
+            ],
+            txId,
+        };
+    }
+}
+exports.DepositUnlentCollateralBuilder = DepositUnlentCollateralBuilder;

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

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

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncreaseCarryPositionBuilder = void 0;
+const base_1 = require("./base");
+const common_1 = require("common");
+const errors_1 = require("../../errors");
+const utils_1 = require("../../utils");
+const lending_platforms_1 = require("lending-platforms");
+const refreshYieldingBankBuilder_1 = require("./refreshYieldingBankBuilder");
+class IncreaseCarryPositionBuilder extends base_1.LongYieldCarryBuilderBase {
+    async getIx(args) {
+        const tokenData = await this.account.fetchToken(args.token);
+        return this.program.methods
+            .increaseCarryPosition({
+            prerequisiteCpis: args.params.prerequisiteCpis ?? null,
+            ixRefs: args.params.ixRefs,
+            lendingPositionIndex: args.params.lendingPositionIndex,
+        })
+            .accountsPartial({ manager: this.resolveTokenManager(tokenData.data) })
+            .remainingAccounts(args.params.remainingAccounts.map(common_1.toWeb3AccountMeta))
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async getTx(args) {
+        if (!Number.isFinite(args.params.uiAmount) || args.params.uiAmount <= 0) {
+            throw new errors_1.NoOpTransactionError(`Invalid uiAmount for increase carry position: ${args.params.uiAmount} (must be a positive finite number)`);
+        }
+        const tokenData = await this.account.fetchToken(args.token);
+        const position = tokenData.data.lendingPositions[args.params.lendingPositionIndex];
+        const carryTradeAccounts = await this.account.getCarryTradeAccounts(args.token, args.params.yieldingBank, args.params.lendingPositionIndex);
+        const txId = args.params.txId ?? `increase-carry-${Date.now()}-${position.protocolUserAcc.toBase58()}`;
+        const lpClient = this.getLendingPlatformClient(position);
+        const manager = this.resolveTokenManager(tokenData.data);
+        const { prerequisiteCpis, cpis, postSuccessCacheInvalidations } = await this.getLendingOperationCpiData(args.token, manager, position, txId, "borrow", args.params.uiAmount);
+        const { accounts: remainingAccounts, refsGroups, lookupTables, } = (0, common_1.createMultiCpiRefs)(prerequisiteCpis.length ? [prerequisiteCpis, cpis] : [cpis], {
+            initialAccounts: carryTradeAccounts,
+        });
+        const prerequisiteCpiRefs = prerequisiteCpis.length ? refsGroups[0] : undefined;
+        const ixRefs = refsGroups[prerequisiteCpis.length ? 1 : 0];
+        const preInstructions = await lpClient.ix.getPreInstructions(txId);
+        const { instructions: ataCreationIxs, postSuccessCacheInvalidations: ataCreationCacheInv } = await (0, common_1.getCreateAtaInstructions)(this.rpc, args.manager, remainingAccounts);
+        const refreshYieldingBankPlan = await new refreshYieldingBankBuilder_1.RefreshYieldingBankBuilder(this.context).getTx({
+            signer: args.manager,
+            yieldingBank: args.params.yieldingBank,
+        });
+        return {
+            instructions: [
+                ...preInstructions,
+                ...ataCreationIxs,
+                ...refreshYieldingBankPlan.instructions,
+                await this.getIx({
+                    token: args.token,
+                    params: {
+                        prerequisiteCpis: prerequisiteCpiRefs,
+                        ixRefs,
+                        lendingPositionIndex: args.params.lendingPositionIndex,
+                        remainingAccounts,
+                    },
+                }),
+            ],
+            lookupTables: this.getTxLookupTables(args.token, lookupTables ?? []),
+            postSuccessCacheInvalidations: [
+                (0, utils_1.getTokenCacheInvalidation)(args.token),
+                (0, utils_1.getYieldingBankCacheInvalidation)(args.params.yieldingBank),
+                (0, lending_platforms_1.getLendingUserAccountCacheInvalidation)((0, common_1.fromWeb3Pk)(position.protocolUserAcc)),
+                ...postSuccessCacheInvalidations,
+                ...ataCreationCacheInv,
+            ],
+            txId,
+        };
+    }
+}
+exports.IncreaseCarryPositionBuilder = IncreaseCarryPositionBuilder;

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

@@ -0,0 +1,28 @@
+export { CreditUnlentToRedemptionEpochBuilder, ProcessAsyncBurnBuilder, SetRedemptionEpochStatusBuilder, TopUpUnlentReservesBuilder, } from "./asyncBurnBuilder";
+export { getRefreshTokenInstructionsIfStale } from "./utils";
+export { BurnTokenBuilder, type BundledBurnPlan } from "./burnTokenBuilder";
+export { ClaimIncentivesBuilder } from "./claimIncentivesBuilder";
+export { CollectFeesBuilder } from "./collectFeesBuilder";
+export { CollectInterestBuilder } from "./collectInterestBuilder";
+export { CreateCpiPlanBuilder } from "./createCpiPlanBuilder";
+export { CreateTokenBuilder } from "./createTokenBuilder";
+export { CreateTokenLendingPositionBuilder } from "./createTokenLendingPositionBuilder";
+export { CreateYieldingBankAllocationBuilder } from "./createYieldingBankAllocationBuilder";
+export { CreateYieldingBankBuilder } from "./createYieldingBankBuilder";
+export { DecreaseCarryPositionBuilder, type DecreaseCarryPositionBuildTxOptions, type ResolvedDecreaseCarryCpiPlan, } from "./decreaseCarryPositionBuilder";
+export { DepositUnlentCollateralBuilder } from "./depositUnlentCollateralBuilder";
+export { IncreaseCarryPositionBuilder } from "./increaseCarryPositionBuilder";
+export { MintTokenBuilder } from "./mintTokenBuilder";
+export { RebalanceTokenBuilder } from "./rebalanceTokenBuilder";
+export { RebalanceYieldingBankBuilder } from "./rebalanceYieldingBankBuilder";
+export { RecollateralizeLossBuilder } from "./recollateralizeLossBuilder";
+export { RefreshTokenStateBuilder } from "./refreshTokenStateBuilder";
+export { RefreshTokensBuilder } from "./refreshTokensBuilder";
+export { RefreshYieldingBankBuilder } from "./refreshYieldingBankBuilder";
+export { ResetTokenBurnRateLimitBuilder } from "./resetTokenBurnRateLimitBuilder";
+export { SetTokenCircuitBreakerBuilder } from "./setTokenCircuitBreakerBuilder";
+export { SetYieldingBankCircuitBreakerBuilder } from "./setYieldingBankCircuitBreakerBuilder";
+export { UpdateLendingPositionConfigBuilder } from "./updateLendingPositionConfigBuilder";
+export { UpdateTokenConfigurationBuilder } from "./updateTokenConfigurationBuilder";
+export { UpdateTokenMetadataBuilder } from "./updateTokenMetadataBuilder";
+export { UpdateYieldingBankConfigBuilder } from "./updateYieldingBankConfigBuilder";

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateYieldingBankConfigBuilder = exports.UpdateTokenMetadataBuilder = exports.UpdateTokenConfigurationBuilder = exports.UpdateLendingPositionConfigBuilder = exports.SetYieldingBankCircuitBreakerBuilder = exports.SetTokenCircuitBreakerBuilder = exports.ResetTokenBurnRateLimitBuilder = exports.RefreshYieldingBankBuilder = exports.RefreshTokensBuilder = exports.RefreshTokenStateBuilder = exports.RecollateralizeLossBuilder = exports.RebalanceYieldingBankBuilder = exports.RebalanceTokenBuilder = exports.MintTokenBuilder = exports.IncreaseCarryPositionBuilder = exports.DepositUnlentCollateralBuilder = exports.DecreaseCarryPositionBuilder = exports.CreateYieldingBankBuilder = exports.CreateYieldingBankAllocationBuilder = exports.CreateTokenLendingPositionBuilder = exports.CreateTokenBuilder = exports.CreateCpiPlanBuilder = exports.CollectInterestBuilder = exports.CollectFeesBuilder = exports.ClaimIncentivesBuilder = exports.BurnTokenBuilder = exports.getRefreshTokenInstructionsIfStale = exports.TopUpUnlentReservesBuilder = exports.SetRedemptionEpochStatusBuilder = exports.ProcessAsyncBurnBuilder = exports.CreditUnlentToRedemptionEpochBuilder = void 0;
+var asyncBurnBuilder_1 = require("./asyncBurnBuilder");
+Object.defineProperty(exports, "CreditUnlentToRedemptionEpochBuilder", { enumerable: true, get: function () { return asyncBurnBuilder_1.CreditUnlentToRedemptionEpochBuilder; } });
+Object.defineProperty(exports, "ProcessAsyncBurnBuilder", { enumerable: true, get: function () { return asyncBurnBuilder_1.ProcessAsyncBurnBuilder; } });
+Object.defineProperty(exports, "SetRedemptionEpochStatusBuilder", { enumerable: true, get: function () { return asyncBurnBuilder_1.SetRedemptionEpochStatusBuilder; } });
+Object.defineProperty(exports, "TopUpUnlentReservesBuilder", { enumerable: true, get: function () { return asyncBurnBuilder_1.TopUpUnlentReservesBuilder; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "getRefreshTokenInstructionsIfStale", { enumerable: true, get: function () { return utils_1.getRefreshTokenInstructionsIfStale; } });
+var burnTokenBuilder_1 = require("./burnTokenBuilder");
+Object.defineProperty(exports, "BurnTokenBuilder", { enumerable: true, get: function () { return burnTokenBuilder_1.BurnTokenBuilder; } });
+var claimIncentivesBuilder_1 = require("./claimIncentivesBuilder");
+Object.defineProperty(exports, "ClaimIncentivesBuilder", { enumerable: true, get: function () { return claimIncentivesBuilder_1.ClaimIncentivesBuilder; } });
+var collectFeesBuilder_1 = require("./collectFeesBuilder");
+Object.defineProperty(exports, "CollectFeesBuilder", { enumerable: true, get: function () { return collectFeesBuilder_1.CollectFeesBuilder; } });
+var collectInterestBuilder_1 = require("./collectInterestBuilder");
+Object.defineProperty(exports, "CollectInterestBuilder", { enumerable: true, get: function () { return collectInterestBuilder_1.CollectInterestBuilder; } });
+var createCpiPlanBuilder_1 = require("./createCpiPlanBuilder");
+Object.defineProperty(exports, "CreateCpiPlanBuilder", { enumerable: true, get: function () { return createCpiPlanBuilder_1.CreateCpiPlanBuilder; } });
+var createTokenBuilder_1 = require("./createTokenBuilder");
+Object.defineProperty(exports, "CreateTokenBuilder", { enumerable: true, get: function () { return createTokenBuilder_1.CreateTokenBuilder; } });
+var createTokenLendingPositionBuilder_1 = require("./createTokenLendingPositionBuilder");
+Object.defineProperty(exports, "CreateTokenLendingPositionBuilder", { enumerable: true, get: function () { return createTokenLendingPositionBuilder_1.CreateTokenLendingPositionBuilder; } });
+var createYieldingBankAllocationBuilder_1 = require("./createYieldingBankAllocationBuilder");
+Object.defineProperty(exports, "CreateYieldingBankAllocationBuilder", { enumerable: true, get: function () { return createYieldingBankAllocationBuilder_1.CreateYieldingBankAllocationBuilder; } });
+var createYieldingBankBuilder_1 = require("./createYieldingBankBuilder");
+Object.defineProperty(exports, "CreateYieldingBankBuilder", { enumerable: true, get: function () { return createYieldingBankBuilder_1.CreateYieldingBankBuilder; } });
+var decreaseCarryPositionBuilder_1 = require("./decreaseCarryPositionBuilder");
+Object.defineProperty(exports, "DecreaseCarryPositionBuilder", { enumerable: true, get: function () { return decreaseCarryPositionBuilder_1.DecreaseCarryPositionBuilder; } });
+var depositUnlentCollateralBuilder_1 = require("./depositUnlentCollateralBuilder");
+Object.defineProperty(exports, "DepositUnlentCollateralBuilder", { enumerable: true, get: function () { return depositUnlentCollateralBuilder_1.DepositUnlentCollateralBuilder; } });
+var increaseCarryPositionBuilder_1 = require("./increaseCarryPositionBuilder");
+Object.defineProperty(exports, "IncreaseCarryPositionBuilder", { enumerable: true, get: function () { return increaseCarryPositionBuilder_1.IncreaseCarryPositionBuilder; } });
+var mintTokenBuilder_1 = require("./mintTokenBuilder");
+Object.defineProperty(exports, "MintTokenBuilder", { enumerable: true, get: function () { return mintTokenBuilder_1.MintTokenBuilder; } });
+var rebalanceTokenBuilder_1 = require("./rebalanceTokenBuilder");
+Object.defineProperty(exports, "RebalanceTokenBuilder", { enumerable: true, get: function () { return rebalanceTokenBuilder_1.RebalanceTokenBuilder; } });
+var rebalanceYieldingBankBuilder_1 = require("./rebalanceYieldingBankBuilder");
+Object.defineProperty(exports, "RebalanceYieldingBankBuilder", { enumerable: true, get: function () { return rebalanceYieldingBankBuilder_1.RebalanceYieldingBankBuilder; } });
+var recollateralizeLossBuilder_1 = require("./recollateralizeLossBuilder");
+Object.defineProperty(exports, "RecollateralizeLossBuilder", { enumerable: true, get: function () { return recollateralizeLossBuilder_1.RecollateralizeLossBuilder; } });
+var refreshTokenStateBuilder_1 = require("./refreshTokenStateBuilder");
+Object.defineProperty(exports, "RefreshTokenStateBuilder", { enumerable: true, get: function () { return refreshTokenStateBuilder_1.RefreshTokenStateBuilder; } });
+var refreshTokensBuilder_1 = require("./refreshTokensBuilder");
+Object.defineProperty(exports, "RefreshTokensBuilder", { enumerable: true, get: function () { return refreshTokensBuilder_1.RefreshTokensBuilder; } });
+var refreshYieldingBankBuilder_1 = require("./refreshYieldingBankBuilder");
+Object.defineProperty(exports, "RefreshYieldingBankBuilder", { enumerable: true, get: function () { return refreshYieldingBankBuilder_1.RefreshYieldingBankBuilder; } });
+var resetTokenBurnRateLimitBuilder_1 = require("./resetTokenBurnRateLimitBuilder");
+Object.defineProperty(exports, "ResetTokenBurnRateLimitBuilder", { enumerable: true, get: function () { return resetTokenBurnRateLimitBuilder_1.ResetTokenBurnRateLimitBuilder; } });
+var setTokenCircuitBreakerBuilder_1 = require("./setTokenCircuitBreakerBuilder");
+Object.defineProperty(exports, "SetTokenCircuitBreakerBuilder", { enumerable: true, get: function () { return setTokenCircuitBreakerBuilder_1.SetTokenCircuitBreakerBuilder; } });
+var setYieldingBankCircuitBreakerBuilder_1 = require("./setYieldingBankCircuitBreakerBuilder");
+Object.defineProperty(exports, "SetYieldingBankCircuitBreakerBuilder", { enumerable: true, get: function () { return setYieldingBankCircuitBreakerBuilder_1.SetYieldingBankCircuitBreakerBuilder; } });
+var updateLendingPositionConfigBuilder_1 = require("./updateLendingPositionConfigBuilder");
+Object.defineProperty(exports, "UpdateLendingPositionConfigBuilder", { enumerable: true, get: function () { return updateLendingPositionConfigBuilder_1.UpdateLendingPositionConfigBuilder; } });
+var updateTokenConfigurationBuilder_1 = require("./updateTokenConfigurationBuilder");
+Object.defineProperty(exports, "UpdateTokenConfigurationBuilder", { enumerable: true, get: function () { return updateTokenConfigurationBuilder_1.UpdateTokenConfigurationBuilder; } });
+var updateTokenMetadataBuilder_1 = require("./updateTokenMetadataBuilder");
+Object.defineProperty(exports, "UpdateTokenMetadataBuilder", { enumerable: true, get: function () { return updateTokenMetadataBuilder_1.UpdateTokenMetadataBuilder; } });
+var updateYieldingBankConfigBuilder_1 = require("./updateYieldingBankConfigBuilder");
+Object.defineProperty(exports, "UpdateYieldingBankConfigBuilder", { enumerable: true, get: function () { return updateYieldingBankConfigBuilder_1.UpdateYieldingBankConfigBuilder; } });

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

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

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MintTokenBuilder = void 0;
+const core_1 = require("@anchor-lang/core");
+const base_1 = require("./base");
+const common_1 = require("common");
+const general_1 = require("../../constants/general");
+const utils_1 = require("./utils");
+/** Reserve kept in the wallet when depositing "all" SOL (covers tx fees + rent). */
+const SOL_RESERVE_LAMPORTS = 10000000; // 0.01 SOL
+class MintTokenBuilder 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 userCollateralAccount = await (0, common_1.getAtaAddress)(collateralMint, args.signer, collateralTokenProgram);
+        const userTokenAccount = await (0, common_1.getAtaAddress)(mint, args.signer, tokenProgram);
+        const collateralTokenAccount = await (0, common_1.getAtaAddress)(collateralMint, args.token, collateralTokenProgram);
+        return this.program.methods
+            .mintToken(args.depositAmount)
+            .accountsPartial({
+            signer: args.signer,
+            token: args.token,
+            mint,
+            collateralMint,
+            userCollateralAccount,
+            userTokenAccount,
+            collateralTokenAccount,
+            tokenProgram,
+            collateralTokenProgram,
+        })
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async getTx(args) {
+        const isAll = args.params.depositAmount === "all";
+        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 instructions = [];
+        const postSuccessCacheInvalidations = [];
+        instructions.push(...(await (0, utils_1.getRefreshTokenInstructionsIfStale)(this.context, args.signer, tokenData)));
+        // Resolve the deposit amount. For native SOL + "all", we query the wallet
+        // balance and reserve 0.01 SOL for tx fees, then wrap that concrete amount.
+        // For non-SOL + "all", use the on-chain sentinel so the program reads the
+        // ATA balance at execution time.
+        const solMint = common_1.mints.get("SOL");
+        const isSolCollateral = solMint != null && collateralMint === solMint.address;
+        let depositAmount;
+        if (isAll && isSolCollateral) {
+            const { value: balanceLamports } = await this.rpc.getBalance(args.signer).send();
+            const available = BigInt(balanceLamports.toString()) - BigInt(SOL_RESERVE_LAMPORTS);
+            if (available <= 0n) {
+                throw new Error(`Insufficient SOL balance: need more than ${SOL_RESERVE_LAMPORTS / 1e9} SOL reserved for fees`);
+            }
+            depositAmount = new core_1.BN(available.toString());
+        }
+        else if (isAll) {
+            depositAmount = general_1.AMOUNT_ALL_SENTINEL;
+        }
+        else {
+            depositAmount = args.params.depositAmount;
+        }
+        if (!isAll || isSolCollateral) {
+            const wrap = await this.getWrapSolInstructionsIfMintIsSol(args.signer, collateralMint, depositAmount);
+            if (wrap.instructions) {
+                instructions.push(...wrap.instructions);
+            }
+            if (wrap.postSuccessCacheInvalidations) {
+                postSuccessCacheInvalidations.push(...wrap.postSuccessCacheInvalidations);
+            }
+        }
+        const createAtaOptions = { accountClient: this.account };
+        const yTokenAta = await (0, common_1.getCreateAtaIxIfNeeded)(this.rpc, args.signer, mint, args.signer, tokenProgram, createAtaOptions);
+        if (yTokenAta.instruction) {
+            instructions.push(yTokenAta.instruction);
+        }
+        postSuccessCacheInvalidations.push(...yTokenAta.postSuccessCacheInvalidations);
+        instructions.push(await this.getIx({
+            signer: args.signer,
+            token: args.token,
+            depositAmount,
+        }));
+        postSuccessCacheInvalidations.push({ client: "lycToken", tokenPda: args.token });
+        return {
+            instructions,
+            lookupTables: this.getTxLookupTables(args.token),
+            postSuccessCacheInvalidations,
+        };
+    }
+}
+exports.MintTokenBuilder = MintTokenBuilder;

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

@@ -0,0 +1,11 @@
+import type { Instruction } from "@solana/kit";
+import type { LongYieldCarryTransactionPlan } from "../types";
+import { LongYieldCarryBuilderBase } from "./base";
+import type { RebalanceTokenIxArgs, RebalanceTokenTxArgs } from "./args";
+export declare class RebalanceTokenBuilder extends LongYieldCarryBuilderBase<RebalanceTokenIxArgs, RebalanceTokenTxArgs> {
+    getIx(args: RebalanceTokenIxArgs): Promise<Instruction>;
+    getTx(args: RebalanceTokenTxArgs): Promise<LongYieldCarryTransactionPlan>;
+    private maxPostRebalanceUtilizationBps;
+    private buildFlashRebalanceOrSkip;
+    private collectFlashCpiGroups;
+}