@kestrelfi/lyc-sdk 1.0.1

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefreshTokenStateBuilder = void 0;
+const base_1 = require("./base");
+const common_1 = require("common");
+const token_1 = require("@solana-program/token");
+const refreshYieldingBankBuilder_1 = require("./refreshYieldingBankBuilder");
+class RefreshTokenStateBuilder extends base_1.LongYieldCarrySingleInstructionBuilderService {
+    async getIx(args) {
+        const { prerequisiteCpis, accountRefs, remainingAccounts } = await this.getRefreshTokenStateParams(args.token);
+        return this.program.methods
+            .refreshTokenState({
+            prerequisiteCpis,
+            accountRefs,
+        })
+            .accountsPartial({
+            signer: args.signer,
+            token: args.token,
+            collateralOracle: args.collateralOracle,
+            secondaryCollateralOracle: args.secondaryCollateralOracle ?? null,
+            collateralTokenAccount: args.collateralTokenAccount,
+            collateralTokenProgram: args.collateralTokenProgram ?? token_1.TOKEN_PROGRAM_ADDRESS,
+        })
+            .remainingAccounts(remainingAccounts.map(common_1.toWeb3AccountMeta))
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async getTx(args) {
+        const ixs = [];
+        const tokenAccount = await this.account.fetchToken(args.token);
+        const uniqueBanks = new Set();
+        for (const { data: carry } of tokenAccount.activeCarryPositions) {
+            const [yieldingBank] = await this.pda.deriveYieldingBankPda((0, common_1.fromWeb3Pk)(carry.yieldingBaseMint), carry.yieldingBankId);
+            uniqueBanks.add(yieldingBank);
+        }
+        for (const yieldingBank of uniqueBanks) {
+            const refreshYieldingBankPlan = await new refreshYieldingBankBuilder_1.RefreshYieldingBankBuilder(this.context).getTx({
+                signer: args.signer,
+                yieldingBank,
+            });
+            ixs.push(...refreshYieldingBankPlan.instructions);
+        }
+        ixs.push(await this.getIx(args));
+        return {
+            instructions: ixs,
+            lookupTables: this.getTxLookupTables(args.token),
+        };
+    }
+    async getRefreshTokenStateParams(token) {
+        const tokenData = await this.account.fetchToken(token);
+        const refreshAccounts = await this.account.getTokenRefreshAccounts(token);
+        const prerequisiteCpis = [];
+        const refreshTargetsByPlatform = new Map();
+        for (const { data: position } of tokenData.activeLendingPositions) {
+            const platform = this.lendingPlatformClients.getPlatformForPosition(position);
+            if (platform === common_1.LendingPlatform.None) {
+                continue;
+            }
+            const pool = (0, common_1.fromWeb3Pk)(position.pool);
+            const userAccount = (0, common_1.fromWeb3Pk)(position.protocolUserAcc);
+            const collateralReserve = (0, common_1.fromWeb3Pk)(position.collateralReserve);
+            const debtReserve = (0, common_1.fromWeb3Pk)(position.debtReserve);
+            const platformTargets = refreshTargetsByPlatform.get(platform) ?? new Map();
+            const targetKey = `${pool}:${userAccount}`;
+            if (platformTargets.has(targetKey)) {
+                continue;
+            }
+            platformTargets.set(targetKey, {
+                pool,
+                userAccount,
+                collateralReserves: [collateralReserve],
+                debtReserves: [debtReserve],
+            });
+            refreshTargetsByPlatform.set(platform, platformTargets);
+        }
+        for (const [platform, platformTargets] of refreshTargetsByPlatform) {
+            const lpClient = this.lendingPlatformClients.getByPlatform(platform);
+            const positionPrerequisiteCpis = await lpClient.ix.getPrerequisiteCpisForRefresh([
+                ...platformTargets.values(),
+            ]);
+            prerequisiteCpis.push(...positionPrerequisiteCpis);
+        }
+        // Compute account indices. refreshAccounts is ordered as:
+        //   [userAcc, collateralReserve, debtOracle] × numActiveLPs, then [yieldingBank] × numActiveCarry
+        // initialAccounts are prepended to the pool at stable positions 0..N-1 by createCpiRefs,
+        // so indices are the same whether or not prereq CPIs are present.
+        const numActiveLPs = tokenData.activeLendingPositions.length;
+        const lendingPositions = tokenData.activeLendingPositions.map((_, i) => ({
+            userAccount: i * 3,
+            collateralReserve: i * 3 + 1,
+            debtOracle: i * 3 + 2,
+        }));
+        const carryPositions = Buffer.from(tokenData.activeCarryPositions.map((_, i) => numActiveLPs * 3 + i));
+        const accountRefs = { lendingPositions, carryPositions };
+        if (!prerequisiteCpis.length) {
+            return {
+                prerequisiteCpis: null,
+                accountRefs,
+                remainingAccounts: refreshAccounts,
+            };
+        }
+        const { accounts: remainingAccounts, refs: prerequisiteCpiRefs } = (0, common_1.createCpiRefs)(prerequisiteCpis, {
+            initialAccounts: refreshAccounts,
+        });
+        return {
+            prerequisiteCpis: prerequisiteCpiRefs,
+            accountRefs,
+            remainingAccounts,
+        };
+    }
+}
+exports.RefreshTokenStateBuilder = RefreshTokenStateBuilder;

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

@@ -0,0 +1,9 @@
+import type { LongYieldCarryTransactionPlan } from "../types";
+import type { LongYieldCarryBuilderContext } from "../types/builders";
+import type { RefreshTokensBuilderTxArgs } from "./args";
+export declare class RefreshTokensBuilder {
+    private readonly context;
+    constructor(context: LongYieldCarryBuilderContext);
+    getTx(args: RefreshTokensBuilderTxArgs): Promise<LongYieldCarryTransactionPlan>;
+    private getYieldingBanksToRefresh;
+}

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefreshTokensBuilder = void 0;
+const common_1 = require("common");
+const utils_1 = require("../../utils");
+const refreshTokenStateBuilder_1 = require("./refreshTokenStateBuilder");
+const refreshYieldingBankBuilder_1 = require("./refreshYieldingBankBuilder");
+class RefreshTokensBuilder {
+    constructor(context) {
+        this.context = context;
+    }
+    async getTx(args) {
+        const tokens = await this.context.account.fetchTokens(args.params.tokens);
+        const instructions = [];
+        const ybAddresses = await this.getYieldingBanksToRefresh(tokens, args.params.alwaysRefreshYieldingBanks ?? false);
+        const refreshYieldingBankBuilder = new refreshYieldingBankBuilder_1.RefreshYieldingBankBuilder(this.context);
+        const refreshTokenStateBuilder = new refreshTokenStateBuilder_1.RefreshTokenStateBuilder(this.context);
+        for (const yieldingBank of ybAddresses) {
+            const ybPlan = await refreshYieldingBankBuilder.getTx({
+                signer: args.signer,
+                yieldingBank,
+            });
+            instructions.push(...ybPlan.instructions);
+        }
+        for (const token of tokens) {
+            instructions.push(await refreshTokenStateBuilder.getIx({
+                signer: args.signer,
+                token: token.address,
+                collateralOracle: (0, common_1.fromWeb3Pk)(token.data.collateral.oracle),
+                secondaryCollateralOracle: (0, common_1.fromWeb3Pk)(token.data.collateral.secondaryOracle),
+                collateralTokenAccount: await (0, common_1.getAtaAddress)(token.collateralMint, token.address, (0, common_1.resolveTokenProgram)(token.data.collateral.tokenProgram)),
+                collateralTokenProgram: (0, common_1.resolveTokenProgram)(token.data.collateral.tokenProgram),
+            }));
+        }
+        return {
+            instructions,
+            lookupTables: (0, utils_1.mergeLycLookupTables)(this.context.environment, args.params.tokens),
+        };
+    }
+    async getYieldingBanksToRefresh(tokens, alwaysRefreshYieldingBanks) {
+        const uniqueYbAddresses = [];
+        const seen = new Set();
+        for (const token of tokens) {
+            for (const { data: carry } of token.activeCarryPositions) {
+                const [yieldingBank] = await this.context.pda.deriveYieldingBankPda((0, common_1.fromWeb3Pk)(carry.yieldingBaseMint), carry.yieldingBankId);
+                if (!seen.has(yieldingBank)) {
+                    seen.add(yieldingBank);
+                    uniqueYbAddresses.push(yieldingBank);
+                }
+            }
+        }
+        if (alwaysRefreshYieldingBanks || uniqueYbAddresses.length === 0) {
+            return uniqueYbAddresses;
+        }
+        const banks = await this.context.account.fetchYieldingBanks(uniqueYbAddresses);
+        return banks.filter((bank) => bank.isStale).map((bank) => bank.address);
+    }
+}
+exports.RefreshTokensBuilder = RefreshTokensBuilder;

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

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

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefreshYieldingBankBuilder = void 0;
+const base_1 = require("./base");
+const common_1 = require("common");
+class RefreshYieldingBankBuilder extends base_1.LongYieldCarryBuilderBase {
+    async getIx(args) {
+        const oracleAccounts = await this.account.getYieldingBankRefreshAccounts(args.yieldingBank, undefined, args.externalLiquiditySources);
+        return this.program.methods
+            .refreshYieldingBank()
+            .accountsPartial({
+            signer: args.signer,
+            yieldingBank: args.yieldingBank,
+        })
+            .remainingAccounts(oracleAccounts.map(common_1.toWeb3AccountMeta))
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async getTx(args) {
+        const { externalLiquiditySources } = await this.externalLiquidityResolver.resolveYieldingBankRefreshExternalLiquidity(this.account, args.yieldingBank);
+        const ix = await this.getIx({
+            signer: args.signer,
+            yieldingBank: args.yieldingBank,
+            externalLiquiditySources,
+        });
+        return { instructions: [ix], lookupTables: this.getTxLookupTables() };
+    }
+}
+exports.RefreshYieldingBankBuilder = RefreshYieldingBankBuilder;

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResetTokenBurnRateLimitBuilder = void 0;
+const common_1 = require("common");
+const base_1 = require("./base");
+class ResetTokenBurnRateLimitBuilder extends base_1.LongYieldCarrySingleInstructionBuilderService {
+    async getIx(args) {
+        const tokenData = await this.account.fetchToken(args.token);
+        return this.program.methods
+            .resetTokenBurnRateLimit()
+            .accountsPartial({ admin: this.resolveTokenAdmin(tokenData.data), token: args.token })
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async buildLookupTables(args) {
+        return this.getTxLookupTables(args.token);
+    }
+}
+exports.ResetTokenBurnRateLimitBuilder = ResetTokenBurnRateLimitBuilder;

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

@@ -0,0 +1,11 @@
+import type { Address, Instruction } from "@solana/kit";
+import { LongYieldCarrySingleInstructionBuilderService } from "./base";
+import type { SetTokenCircuitBreakerIxArgs, SetTokenCircuitBreakerTxArgs } from "./args";
+export declare class SetTokenCircuitBreakerBuilder extends LongYieldCarrySingleInstructionBuilderService<SetTokenCircuitBreakerIxArgs, SetTokenCircuitBreakerTxArgs> {
+    protected deriveIxArgs(txArgs: SetTokenCircuitBreakerTxArgs): Promise<SetTokenCircuitBreakerIxArgs>;
+    getIx(args: SetTokenCircuitBreakerIxArgs): Promise<Instruction>;
+    protected buildLookupTables(args: SetTokenCircuitBreakerIxArgs): Promise<readonly Address[]>;
+    protected buildPlanExtras(args: SetTokenCircuitBreakerIxArgs): Promise<{
+        postSuccessCacheInvalidations: import("common").TransactionCacheInvalidation[];
+    }>;
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetTokenCircuitBreakerBuilder = void 0;
+const common_1 = require("common");
+const utils_1 = require("../../utils");
+const base_1 = require("./base");
+class SetTokenCircuitBreakerBuilder extends base_1.LongYieldCarrySingleInstructionBuilderService {
+    async deriveIxArgs(txArgs) {
+        return {
+            authority: txArgs.authority,
+            token: txArgs.token,
+            active: txArgs.active,
+        };
+    }
+    async getIx(args) {
+        return this.program.methods
+            .setTokenCircuitBreaker(args.active)
+            .accountsPartial({ authority: args.authority, token: args.token })
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async buildLookupTables(args) {
+        return this.getTxLookupTables(args.token);
+    }
+    async buildPlanExtras(args) {
+        return {
+            postSuccessCacheInvalidations: [(0, utils_1.getTokenCacheInvalidation)(args.token)],
+        };
+    }
+}
+exports.SetTokenCircuitBreakerBuilder = SetTokenCircuitBreakerBuilder;

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

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

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetYieldingBankCircuitBreakerBuilder = void 0;
+const common_1 = require("common");
+const base_1 = require("./base");
+class SetYieldingBankCircuitBreakerBuilder extends base_1.LongYieldCarrySingleInstructionBuilderService {
+    async deriveIxArgs(txArgs) {
+        return {
+            authority: txArgs.authority,
+            yieldingBank: txArgs.yieldingBank,
+            active: txArgs.active,
+        };
+    }
+    async getIx(args) {
+        return this.program.methods
+            .setYieldingBankCircuitBreaker(args.active)
+            .accountsPartial({
+            authority: args.authority,
+            yieldingBank: args.yieldingBank,
+        })
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async buildLookupTables() {
+        return this.getTxLookupTables();
+    }
+}
+exports.SetYieldingBankCircuitBreakerBuilder = SetYieldingBankCircuitBreakerBuilder;

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

@@ -0,0 +1,10 @@
+import type { Address, Instruction } from "@solana/kit";
+import { LongYieldCarrySingleInstructionBuilderService } from "./base";
+import type { UpdateLendingPositionConfigIxArgs } from "./args";
+export declare class UpdateLendingPositionConfigBuilder extends LongYieldCarrySingleInstructionBuilderService<UpdateLendingPositionConfigIxArgs> {
+    getIx(args: UpdateLendingPositionConfigIxArgs): Promise<Instruction>;
+    protected buildLookupTables(args: UpdateLendingPositionConfigIxArgs): Promise<readonly Address[]>;
+    protected buildPlanExtras(args: UpdateLendingPositionConfigIxArgs): Promise<{
+        postSuccessCacheInvalidations: import("common").TransactionCacheInvalidation[];
+    }>;
+}

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateLendingPositionConfigBuilder = void 0;
+const common_1 = require("common");
+const utils_1 = require("../../utils");
+const base_1 = require("./base");
+class UpdateLendingPositionConfigBuilder extends base_1.LongYieldCarrySingleInstructionBuilderService {
+    async getIx(args) {
+        const tokenData = await this.account.fetchToken(args.token);
+        return this.program.methods
+            .updateLendingPositionConfig({
+            lendingPositionIndex: args.params.lendingPositionIndex,
+            targetUtilizationRateBps: args.params.targetUtilizationRateBps,
+            maxDeviationAboveTargetUtilBps: args.params.maxDeviationAboveTargetUtilBps,
+            maxDeviationBelowTargetUtilBps: args.params.maxDeviationBelowTargetUtilBps,
+        })
+            .accountsPartial({ manager: this.resolveTokenManager(tokenData.data), token: args.token })
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async buildLookupTables(args) {
+        return this.getTxLookupTables(args.token);
+    }
+    async buildPlanExtras(args) {
+        return {
+            postSuccessCacheInvalidations: [(0, utils_1.getTokenCacheInvalidation)(args.token)],
+        };
+    }
+}
+exports.UpdateLendingPositionConfigBuilder = UpdateLendingPositionConfigBuilder;

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

@@ -0,0 +1,11 @@
+import type { Address, Instruction } from "@solana/kit";
+import { LongYieldCarrySingleInstructionBuilderService } from "./base";
+import type { UpdateTokenConfigurationIxArgs } from "./args";
+export declare class UpdateTokenConfigurationBuilder extends LongYieldCarrySingleInstructionBuilderService<UpdateTokenConfigurationIxArgs> {
+    /**
+     * Builds an update signed by the token admin by default. Callers may pass the
+     * token manager through the compatibility-named `admin` argument for fee-only updates.
+     */
+    getIx(args: UpdateTokenConfigurationIxArgs): Promise<Instruction>;
+    protected buildLookupTables(args: UpdateTokenConfigurationIxArgs): Promise<readonly Address[]>;
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateTokenConfigurationBuilder = void 0;
+const common_1 = require("common");
+const base_1 = require("./base");
+class UpdateTokenConfigurationBuilder extends base_1.LongYieldCarrySingleInstructionBuilderService {
+    /**
+     * Builds an update signed by the token admin by default. Callers may pass the
+     * token manager through the compatibility-named `admin` argument for fee-only updates.
+     */
+    async getIx(args) {
+        const tokenData = await this.account.fetchToken(args.token);
+        return this.program.methods
+            .updateTokenConfiguration({
+            performanceFeeBps: args.params.performanceFeeBps,
+            mintingFeeBps: args.params.mintingFeeBps,
+            burningFeeBps: args.params.burningFeeBps,
+            protocolMintBurnPctBps: args.params.protocolMintBurnPctBps,
+            curatorMintBurnPctBps: args.params.curatorMintBurnPctBps,
+            curatorPerfPctBps: args.params.curatorPerfPctBps,
+            // Omit to preserve the current on-chain value (the program always
+            // rewrites drip config on this instruction).
+            feeDripMaxApyBps: args.params.feeDripMaxApyBps ?? tokenData.data.fees.feeDripMaxApyBps,
+            feeDripDurationSecs: args.params.feeDripDurationSecs ?? tokenData.data.fees.feeDripDurationSecs,
+            burnRateLimit: args.params.burnRateLimit
+                ? {
+                    maxAmount: args.params.burnRateLimit.maxAmount,
+                    windowDurationSecs: args.params.burnRateLimit.windowDurationSecs,
+                }
+                : null,
+            depositLimit: args.params.depositLimit !== undefined ? args.params.depositLimit : null,
+        })
+            .accountsPartial({
+            admin: args.admin ?? this.resolveTokenAdmin(tokenData.data),
+            token: args.token,
+            managerRole: args.managerRole ?? null,
+            feesRole: args.feesRole ?? null,
+            cbControllerRole: args.cbControllerRole ?? null,
+        })
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async buildLookupTables(args) {
+        return this.getTxLookupTables(args.token);
+    }
+}
+exports.UpdateTokenConfigurationBuilder = UpdateTokenConfigurationBuilder;

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

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

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateTokenMetadataBuilder = void 0;
+const common_1 = require("common");
+const base_1 = require("./base");
+class UpdateTokenMetadataBuilder extends base_1.LongYieldCarrySingleInstructionBuilderService {
+    async getIx(args) {
+        const tokenData = await this.account.fetchToken(args.token);
+        return this.program.methods
+            .updateTokenMetadata(args.params.ixRefs)
+            .accountsPartial({
+            admin: this.resolveTokenAdmin(tokenData.data),
+            token: args.token,
+            mint: args.mint,
+        })
+            .remainingAccounts(args.params.remainingAccounts.map(common_1.toWeb3AccountMeta))
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async buildLookupTables(args) {
+        return this.getTxLookupTables(args.token);
+    }
+}
+exports.UpdateTokenMetadataBuilder = UpdateTokenMetadataBuilder;

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

@@ -0,0 +1,10 @@
+import type { Address, Instruction } from "@solana/kit";
+import { LongYieldCarrySingleInstructionBuilderService } from "./base";
+import type { UpdateYieldingBankConfigIxArgs } from "./args";
+export declare class UpdateYieldingBankConfigBuilder extends LongYieldCarrySingleInstructionBuilderService<UpdateYieldingBankConfigIxArgs> {
+    getIx(args: UpdateYieldingBankConfigIxArgs): Promise<Instruction>;
+    protected buildLookupTables(): Promise<readonly Address[]>;
+    protected buildPlanExtras(args: UpdateYieldingBankConfigIxArgs): Promise<{
+        postSuccessCacheInvalidations: import("common").TransactionCacheInvalidation[];
+    }>;
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateYieldingBankConfigBuilder = void 0;
+const common_1 = require("common");
+const utils_1 = require("../../utils");
+const base_1 = require("./base");
+class UpdateYieldingBankConfigBuilder extends base_1.LongYieldCarrySingleInstructionBuilderService {
+    async getIx(args) {
+        const bankData = await this.account.fetchYieldingBank(args.yieldingBank);
+        return this.program.methods
+            .updateYieldingBankConfig({})
+            .accountsPartial({
+            admin: args.admin ?? this.resolveYieldingBankAdmin(bankData.data),
+            yieldingBank: args.yieldingBank,
+            defaultRedemptionMint: args.params.defaultRedemptionMint,
+            managerRole: args.managerRole ?? null,
+            cbControllerRole: args.cbControllerRole ?? null,
+        })
+            .instruction()
+            .then(common_1.toKitInstruction);
+    }
+    async buildLookupTables() {
+        return this.getTxLookupTables();
+    }
+    async buildPlanExtras(args) {
+        return {
+            postSuccessCacheInvalidations: [(0, utils_1.getYieldingBankCacheInvalidation)(args.yieldingBank)],
+        };
+    }
+}
+exports.UpdateYieldingBankConfigBuilder = UpdateYieldingBankConfigBuilder;

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

@@ -0,0 +1,4 @@
+import type { Address, Instruction } from "@solana/kit";
+import type { LongYieldCarryBuilderContext } from "../types/builders";
+import type { LYCToken } from "../../models/lycToken";
+export declare function getRefreshTokenInstructionsIfStale(context: LongYieldCarryBuilderContext, signer: Address, tokenData: LYCToken): Promise<Instruction[]>;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRefreshTokenInstructionsIfStale = getRefreshTokenInstructionsIfStale;
+const general_1 = require("../../constants/general");
+const refreshTokensBuilder_1 = require("./refreshTokensBuilder");
+async function getRefreshTokenInstructionsIfStale(context, signer, tokenData) {
+    const lastRefreshed = tokenData.data.accounting.lastRefreshedTs.toNumber();
+    const nowSecs = Math.floor(Date.now() / 1000);
+    if (nowSecs - lastRefreshed <= general_1.TOKEN_STALENESS_THRESHOLD_SECS) {
+        return [];
+    }
+    return new refreshTokensBuilder_1.RefreshTokensBuilder(context)
+        .getTx({
+        signer,
+        params: {
+            tokens: [tokenData.address],
+        },
+    })
+        .then((plan) => [...plan.instructions]);
+}