@kestrelfi/lyc-sdk 1.0.1

package/src/client/builders/setTokenCircuitBreakerBuilder.ts

@@ -0,0 +1,40 @@
+import type { Address, Instruction } from "@solana/kit";
+import { toKitInstruction } from "common";
+import { getTokenCacheInvalidation } from "../../utils";
+import { LongYieldCarrySingleInstructionBuilderService } from "./base";
+import type { SetTokenCircuitBreakerIxArgs, SetTokenCircuitBreakerTxArgs } from "./args";
+
+export class SetTokenCircuitBreakerBuilder extends LongYieldCarrySingleInstructionBuilderService<
+  SetTokenCircuitBreakerIxArgs,
+  SetTokenCircuitBreakerTxArgs
+> {
+  protected async deriveIxArgs(
+    txArgs: SetTokenCircuitBreakerTxArgs
+  ): Promise<SetTokenCircuitBreakerIxArgs> {
+    return {
+      authority: txArgs.authority,
+      token: txArgs.token,
+      active: txArgs.active,
+    };
+  }
+
+  async getIx(args: SetTokenCircuitBreakerIxArgs): Promise<Instruction> {
+    return this.program.methods
+      .setTokenCircuitBreaker(args.active)
+      .accountsPartial({ authority: args.authority, token: args.token })
+      .instruction()
+      .then(toKitInstruction);
+  }
+
+  protected async buildLookupTables(
+    args: SetTokenCircuitBreakerIxArgs
+  ): Promise<readonly Address[]> {
+    return this.getTxLookupTables(args.token);
+  }
+
+  protected async buildPlanExtras(args: SetTokenCircuitBreakerIxArgs) {
+    return {
+      postSuccessCacheInvalidations: [getTokenCacheInvalidation(args.token)],
+    };
+  }
+}

package/src/client/builders/setYieldingBankCircuitBreakerBuilder.ts

@@ -0,0 +1,37 @@
+import type { Address, Instruction } from "@solana/kit";
+import { toKitInstruction } from "common";
+import { LongYieldCarrySingleInstructionBuilderService } from "./base";
+import type {
+  SetYieldingBankCircuitBreakerIxArgs,
+  SetYieldingBankCircuitBreakerTxArgs,
+} from "./args";
+
+export class SetYieldingBankCircuitBreakerBuilder extends LongYieldCarrySingleInstructionBuilderService<
+  SetYieldingBankCircuitBreakerIxArgs,
+  SetYieldingBankCircuitBreakerTxArgs
+> {
+  protected async deriveIxArgs(
+    txArgs: SetYieldingBankCircuitBreakerTxArgs
+  ): Promise<SetYieldingBankCircuitBreakerIxArgs> {
+    return {
+      authority: txArgs.authority,
+      yieldingBank: txArgs.yieldingBank,
+      active: txArgs.active,
+    };
+  }
+
+  async getIx(args: SetYieldingBankCircuitBreakerIxArgs): Promise<Instruction> {
+    return this.program.methods
+      .setYieldingBankCircuitBreaker(args.active)
+      .accountsPartial({
+        authority: args.authority,
+        yieldingBank: args.yieldingBank,
+      })
+      .instruction()
+      .then(toKitInstruction);
+  }
+
+  protected async buildLookupTables(): Promise<readonly Address[]> {
+    return this.getTxLookupTables();
+  }
+}

package/src/client/builders/updateLendingPositionConfigBuilder.ts

@@ -0,0 +1,33 @@
+import type { Address, Instruction } from "@solana/kit";
+import { toKitInstruction } from "common";
+import { getTokenCacheInvalidation } from "../../utils";
+import { LongYieldCarrySingleInstructionBuilderService } from "./base";
+import type { UpdateLendingPositionConfigIxArgs } from "./args";
+
+export class UpdateLendingPositionConfigBuilder extends LongYieldCarrySingleInstructionBuilderService<UpdateLendingPositionConfigIxArgs> {
+  async getIx(args: UpdateLendingPositionConfigIxArgs): Promise<Instruction> {
+    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(toKitInstruction);
+  }
+
+  protected async buildLookupTables(
+    args: UpdateLendingPositionConfigIxArgs
+  ): Promise<readonly Address[]> {
+    return this.getTxLookupTables(args.token);
+  }
+
+  protected async buildPlanExtras(args: UpdateLendingPositionConfigIxArgs) {
+    return {
+      postSuccessCacheInvalidations: [getTokenCacheInvalidation(args.token)],
+    };
+  }
+}

package/src/client/builders/updateTokenConfigurationBuilder.ts

@@ -0,0 +1,50 @@
+import type { Address, Instruction } from "@solana/kit";
+import { toKitInstruction } from "common";
+import { LongYieldCarrySingleInstructionBuilderService } from "./base";
+import type { UpdateTokenConfigurationIxArgs } from "./args";
+
+export 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.
+   */
+  async getIx(args: UpdateTokenConfigurationIxArgs): Promise<Instruction> {
+    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(toKitInstruction);
+  }
+
+  protected async buildLookupTables(
+    args: UpdateTokenConfigurationIxArgs
+  ): Promise<readonly Address[]> {
+    return this.getTxLookupTables(args.token);
+  }
+}

package/src/client/builders/updateTokenMetadataBuilder.ts

@@ -0,0 +1,24 @@
+import type { Address, Instruction } from "@solana/kit";
+import { toKitInstruction, toWeb3AccountMeta } from "common";
+import { LongYieldCarrySingleInstructionBuilderService } from "./base";
+import type { UpdateTokenMetadataIxArgs } from "./args";
+
+export class UpdateTokenMetadataBuilder extends LongYieldCarrySingleInstructionBuilderService<UpdateTokenMetadataIxArgs> {
+  async getIx(args: UpdateTokenMetadataIxArgs): Promise<Instruction> {
+    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(toWeb3AccountMeta))
+      .instruction()
+      .then(toKitInstruction);
+  }
+
+  protected async buildLookupTables(args: UpdateTokenMetadataIxArgs): Promise<readonly Address[]> {
+    return this.getTxLookupTables(args.token);
+  }
+}

package/src/client/builders/updateYieldingBankConfigBuilder.ts

@@ -0,0 +1,32 @@
+import type { Address, Instruction } from "@solana/kit";
+import { toKitInstruction } from "common";
+import { getYieldingBankCacheInvalidation } from "../../utils";
+import { LongYieldCarrySingleInstructionBuilderService } from "./base";
+import type { UpdateYieldingBankConfigIxArgs } from "./args";
+
+export class UpdateYieldingBankConfigBuilder extends LongYieldCarrySingleInstructionBuilderService<UpdateYieldingBankConfigIxArgs> {
+  async getIx(args: UpdateYieldingBankConfigIxArgs): Promise<Instruction> {
+    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(toKitInstruction);
+  }
+
+  protected async buildLookupTables(): Promise<readonly Address[]> {
+    return this.getTxLookupTables();
+  }
+
+  protected async buildPlanExtras(args: UpdateYieldingBankConfigIxArgs) {
+    return {
+      postSuccessCacheInvalidations: [getYieldingBankCacheInvalidation(args.yieldingBank)],
+    };
+  }
+}

package/src/client/builders/utils.ts

@@ -0,0 +1,26 @@
+import type { Address, Instruction } from "@solana/kit";
+import type { LongYieldCarryBuilderContext } from "../types/builders";
+import type { LYCToken } from "../../models/lycToken";
+import { TOKEN_STALENESS_THRESHOLD_SECS } from "../../constants/general";
+import { RefreshTokensBuilder } from "./refreshTokensBuilder";
+
+export async function getRefreshTokenInstructionsIfStale(
+  context: LongYieldCarryBuilderContext,
+  signer: Address,
+  tokenData: LYCToken
+): Promise<Instruction[]> {
+  const lastRefreshed = tokenData.data.accounting.lastRefreshedTs.toNumber();
+  const nowSecs = Math.floor(Date.now() / 1000);
+  if (nowSecs - lastRefreshed <= TOKEN_STALENESS_THRESHOLD_SECS) {
+    return [];
+  }
+
+  return new RefreshTokensBuilder(context)
+    .getTx({
+      signer,
+      params: {
+        tokens: [tokenData.address],
+      },
+    })
+    .then((plan) => [...plan.instructions]);
+}

package/src/client/client.ts

@@ -0,0 +1,264 @@
+/**
+ * Long Yield Carry program client.
+ *
+ * Composes PDA derivation, account fetching, instruction building, and
+ * transaction composition behind a single entry point.
+ *
+ * The Anchor program ID flows through to all sub-clients — no global state
+ * required.
+ *
+ * Usage:
+ *   const client = new LongYieldCarryClient(provider, "local");
+ *   const [pda, bump] = client.pda.token(mintAddress);
+ *   const ix = await client.tx.createToken.getIx({
+ *     mint,
+ *     collateralMint,
+ *     params,
+ *   });
+ *   const data = await client.account.token(pda);
+ *   const tx = await client.tx.collectInterest.getTx({ manager: manager, token: token, params: { yieldingBank } });
+ */
+
+import { Program, AnchorProvider } from "@anchor-lang/core";
+import {
+  address,
+  type Instruction,
+  type Rpc,
+  type Signature,
+  type SolanaRpcApi,
+  type TransactionSigner,
+} from "@solana/kit";
+import {
+  LendingPlatform,
+  type Environment,
+  createRpc,
+  getRpcUrl,
+  getRpcUrls,
+  applyDataCacheTransactionInvalidations,
+  fromWeb3Pk,
+  mints,
+  signSendAndConfirmTransaction,
+  type SendTransactionOptionsWithPostSuccess,
+  type SwapClient,
+  type TransactionPlan,
+  createReadOnlyAnchorProvider,
+} from "common";
+import {
+  KaminoClient,
+  type LendingPlatformClientBase,
+  type LendingPlatformData,
+  type OutstandingIncentive,
+} from "lending-platforms";
+import { createAggSwapClient } from "swap-aggregator";
+import { LongYieldCarry, IDL } from "../idl/long_yield_carry";
+import { DEFAULT_MIN_INCENTIVE_UI_AMOUNT, PROGRAM_ID } from "../constants/general";
+import { PdaClient } from "./pda";
+import { AccountClient, LYC_TOKEN_CACHE_CATEGORY, YIELDING_BANK_CACHE_CATEGORY } from "./account";
+import type { LongYieldCarryTransactionPlan } from "./types";
+import type { LYCToken, TokenLendingPositionData } from "../models/lycToken";
+import {
+  LendingPlatformClientRegistry,
+  type SupportedLendingPlatformClients,
+} from "./lendingPlatformClients";
+import { LongYieldCarryExternalLiquidityResolver } from "./externalLiquidityResolver";
+import { TransactionClient } from "./transaction";
+
+export interface LongYieldCarryClientOptions {
+  /**
+   * Swap client override. Replaces the default `AggSwapClient` for all swaps
+   * (including collect_interest). Useful in tests that need a restricted routing
+   * client (e.g. Surfpool direct-route-only client).
+   */
+  swapClient?: SwapClient;
+  /**
+   * Optional overrides for internally managed lending platform clients.
+   * These are primarily useful in tests.
+   */
+  lendingPlatformClients?: Partial<SupportedLendingPlatformClients>;
+}
+
+/** Claimable incentives keyed by the token's lending position index. */
+export type OutstandingIncentivesByPosition = Map<number, OutstandingIncentive[]>;
+
+export class LongYieldCarryClient {
+  /**
+   * Deployment tier for this client (`local`, `test`, `prod`) — drives program ID,
+   * RPC URL, and authority constants passed into transaction builders.
+   */
+  readonly environment: Environment;
+  /** Shared RPC client used by SDK send helpers */
+  readonly rpc: Rpc<SolanaRpcApi>;
+  /** PDA derivation utilities */
+  readonly pda: PdaClient;
+  /** On-chain account fetchers */
+  readonly account: AccountClient;
+  /** Transaction/instruction builders */
+  readonly tx: TransactionClient;
+  /** Aggregated swap client (Perena for USD* pairs, Jupiter fallback) */
+  readonly swap: SwapClient;
+  /** Shared registry of protocol-specific lending clients */
+  readonly lendingPlatformClients: LendingPlatformClientRegistry;
+
+  /**
+   * @param provider - Anchor provider (connection + wallet)
+   * @param environment - Optional environment override ("local", "test", "prod").
+   *                      Determines which program ID and RPC URL to use. Defaults to the IDL address.
+   * @param options - Optional configuration overrides (e.g. custom swap client for tests).
+   */
+  /**
+   * Create a read-only client with a throwaway keypair.
+   *
+   * Use this for services that only need to read on-chain state (e.g. the
+   * price ingestion Lambda) and never sign transactions.
+   */
+  static readOnly(env: Environment): LongYieldCarryClient {
+    return new LongYieldCarryClient(createReadOnlyAnchorProvider(env), env);
+  }
+
+  constructor(
+    provider: AnchorProvider,
+    environment?: Environment,
+    options?: LongYieldCarryClientOptions
+  ) {
+    const env = environment ?? "local";
+    this.environment = env;
+    const rpcUrl = getRpcUrl(env);
+    const rpcUrls = getRpcUrls(env);
+    const idl = environment ? { ...IDL, address: PROGRAM_ID[environment] } : IDL;
+    const program: Program<LongYieldCarry> = new Program(idl as LongYieldCarry, provider);
+    this.rpc = createRpc(env);
+    this.pda = new PdaClient(address(program.programId.toBase58()));
+    this.account = new AccountClient(program, this.pda, this.rpc);
+    const kaminoClient =
+      options?.lendingPlatformClients?.kamino ?? new KaminoClient(rpcUrl, rpcUrls);
+    this.lendingPlatformClients = new LendingPlatformClientRegistry({
+      kamino: kaminoClient,
+    });
+    this.swap = options?.swapClient ?? createAggSwapClient(rpcUrl, env);
+    const externalLiquidityResolver = new LongYieldCarryExternalLiquidityResolver(rpcUrl);
+    this.tx = new TransactionClient({
+      rpc: this.rpc,
+      program,
+      account: this.account,
+      pda: this.pda,
+      swap: this.swap,
+      externalLiquidityResolver,
+      environment: environment ?? "local",
+      lendingPlatformClients: this.lendingPlatformClients,
+    });
+  }
+
+  /**
+   * Sign, send, and confirm a transaction, then apply any post-success cache
+   * invalidations embedded in the transaction plan.
+   */
+  async sendTransaction(
+    payer: TransactionSigner,
+    instructionsOrPlan: Instruction[] | TransactionPlan,
+    options?: SendTransactionOptionsWithPostSuccess
+  ): Promise<Signature> {
+    const plan = Array.isArray(instructionsOrPlan)
+      ? undefined
+      : (instructionsOrPlan as LongYieldCarryTransactionPlan);
+
+    return signSendAndConfirmTransaction(this.rpc, payer, instructionsOrPlan, {
+      ...options,
+      onSuccess: () => {
+        if (plan) this.applyCacheInvalidations(plan);
+        options?.onSuccess?.();
+      },
+    });
+  }
+
+  /**
+   * Returns currently claimable lending incentives keyed by lending position
+   * index. Each value contains that position's claimable incentive entries as
+   * reported by the underlying lending-platform client.
+   *
+   * `minUiAmount` filters out dust rewards (UI-denominated, per reward token);
+   * defaults to {@link DEFAULT_MIN_INCENTIVE_UI_AMOUNT} so harvesting never pays
+   * a transaction fee for an economically negligible balance.
+   */
+  async getOutstandingIncentives(
+    token: LYCToken,
+    minUiAmount: number = DEFAULT_MIN_INCENTIVE_UI_AMOUNT,
+    log?: (msg: string) => void
+  ): Promise<OutstandingIncentivesByPosition> {
+    const positionIncentives = await Promise.all(
+      token.activeLendingPositions.map(async ({ index, data: position }) => {
+        log?.(
+          `\n[getOutstandingIncentives] position #${index} userAcc=${fromWeb3Pk(position.protocolUserAcc).slice(0, 6)}…`
+        );
+        const incentives = await this.lendingPlatformClients
+          .getForPosition(position)
+          .getOutstandingIncentives(fromWeb3Pk(position.protocolUserAcc), minUiAmount, log);
+        return { index, incentives };
+      })
+    );
+
+    const incentivesByPosition: OutstandingIncentivesByPosition = new Map();
+    for (const { index, incentives } of positionIncentives) {
+      const known = incentives.filter((i) => mints.get(i.mint) !== undefined);
+      const unknown = incentives.filter((i) => mints.get(i.mint) === undefined);
+      if (unknown.length > 0) {
+        log?.(
+          `  position #${index}: ${unknown.length} incentive(s) skipped — mint not in registry: ${unknown.map((i) => i.mint.slice(0, 6) + "…").join(", ")}`
+        );
+      }
+      if (known.length > 0) {
+        incentivesByPosition.set(index, known);
+      }
+    }
+
+    return incentivesByPosition;
+  }
+
+  /**
+   * Drops every cached entry across all sub-clients (account data, Kamino
+   * lending data, swap quotes). The next read through any sub-client will
+   * hit the RPC / API fresh.
+   *
+   * Use this between sequential phases that mutate on-chain state so that
+   * the later phase doesn't operate on stale snapshots.
+   */
+  clearAllCache(): void {
+    this.account.dataCache.clearAllCache();
+    for (const lpClient of this.lendingPlatformClients.getAll()) {
+      lpClient.data.clearCache();
+    }
+  }
+
+  /**
+   * Clears cached data that a confirmed transaction has made stale.
+   *
+   * Call this after a transaction built from a `LongYieldCarryTransactionPlan`
+   * has been confirmed by an external sender (e.g. the backend
+   * `TransactionService`). The built-in `sendTransaction` applies these
+   * automatically; this method exists for callers that sign/send through a
+   * different path.
+   */
+  applyCacheInvalidations(plan: LongYieldCarryTransactionPlan): void {
+    const invalidations = plan.postSuccessCacheInvalidations ?? [];
+    for (const lpClient of this.lendingPlatformClients.getAll()) {
+      lpClient.applyPostSuccessCacheInvalidations(invalidations);
+    }
+    applyDataCacheTransactionInvalidations(this.account.dataCache, invalidations, {
+      tokenPdaCategory: LYC_TOKEN_CACHE_CATEGORY,
+      yieldingBankPdaCategory: YIELDING_BANK_CACHE_CATEGORY,
+    });
+  }
+
+  getLendingPlatformClient(position: TokenLendingPositionData) {
+    return this.lendingPlatformClients.getForPosition(position);
+  }
+
+  getLendingPlatformClientByPlatform(platform: LendingPlatform.Kamino): KaminoClient;
+  getLendingPlatformClientByPlatform(
+    platform: LendingPlatform
+  ): LendingPlatformClientBase<LendingPlatformData>;
+  getLendingPlatformClientByPlatform(
+    platform: LendingPlatform
+  ): LendingPlatformClientBase<LendingPlatformData> {
+    return this.lendingPlatformClients.getByPlatform(platform);
+  }
+}

package/src/client/externalLiquidityResolver.ts

@@ -0,0 +1,54 @@
+import type { Address } from "@solana/kit";
+import {
+  dedupeOrderedAddresses,
+  mints,
+  type CpiData,
+  type TransactionCacheInvalidation,
+} from "common";
+import { getPerenaWithdrawalQueueAddressesFromCpiData, PerenaClient } from "perena-helpers";
+import type { YieldingBankExternalLiquiditySource } from "./types";
+import type { AccountClient } from "./account";
+
+export interface YieldingBankRefreshExternalLiquidity {
+  externalLiquiditySources: YieldingBankExternalLiquiditySource[];
+  postSuccessCacheInvalidations: TransactionCacheInvalidation[];
+}
+
+export class LongYieldCarryExternalLiquidityResolver {
+  private readonly perena: PerenaClient;
+
+  constructor(rpcUrl: string) {
+    this.perena = new PerenaClient(rpcUrl);
+  }
+
+  async resolveYieldingBankRefreshExternalLiquidity(
+    accountClient: AccountClient,
+    yieldingBank: Address,
+    cpiData: readonly CpiData[] = []
+  ): Promise<YieldingBankRefreshExternalLiquidity> {
+    const usdStarJuniorMint = mints.get("USD*-J");
+    if (!usdStarJuniorMint) {
+      return { externalLiquiditySources: [], postSuccessCacheInvalidations: [] };
+    }
+
+    const bank = await accountClient.fetchYieldingBank(yieldingBank);
+    if (!bank.findAssetHolding(usdStarJuniorMint.address)) {
+      return { externalLiquiditySources: [], postSuccessCacheInvalidations: [] };
+    }
+
+    const withdrawalQueues = dedupeOrderedAddresses([
+      ...(await this.perena.getActiveWithdrawalQueues(yieldingBank)),
+      ...getPerenaWithdrawalQueueAddressesFromCpiData(cpiData),
+    ]);
+
+    return {
+      externalLiquiditySources: withdrawalQueues.map((account) => ({
+        mint: usdStarJuniorMint.address,
+        account,
+      })),
+      postSuccessCacheInvalidations: withdrawalQueues.length
+        ? [this.perena.getActiveWithdrawalQueuesCacheInvalidation(yieldingBank)]
+        : [],
+    };
+  }
+}

package/src/client/index.ts

@@ -0,0 +1,20 @@
+export { LongYieldCarryClient, type LongYieldCarryClientOptions } from "./client";
+export * from "./transaction";
+export {
+  LendingPlatformClientRegistry,
+  type SupportedLendingPlatformClients,
+} from "./lendingPlatformClients";
+export {
+  assertCollectInterestPlanHasPositiveRedemptions,
+  buildCollectInterestPlan,
+} from "./plans/collectInterest";
+export { buildDecreaseCarryPositionPlan } from "./plans/decreaseCarryPosition";
+export * from "./types";
+export { LYCToken } from "../models/lycToken";
+export type {
+  TokenAccountData,
+  TokenCarryPositionData,
+  IndexedCarryPosition,
+} from "../models/lycToken";
+export { LYCYieldingBank } from "../models/yieldingBank";
+export * from "../types";

package/src/client/lendingPlatformClients.ts

@@ -0,0 +1,50 @@
+import { LendingPlatform, lendingPlatformToEnum } from "common";
+import type {
+  KaminoClient,
+  LendingPlatformClientBase,
+  LendingPlatformData,
+} from "lending-platforms";
+import type { TokenLendingPositionData } from "../models/lycToken";
+
+export interface SupportedLendingPlatformClients {
+  kamino: KaminoClient;
+}
+
+/**
+ * Central registry for protocol-specific lending clients used throughout the
+ * long-yield-carry SDK.
+ */
+export class LendingPlatformClientRegistry {
+  private readonly kaminoClient: KaminoClient;
+
+  constructor(clients: SupportedLendingPlatformClients) {
+    this.kaminoClient = clients.kamino;
+  }
+
+  getAll(): LendingPlatformClientBase<LendingPlatformData>[] {
+    return [this.kaminoClient];
+  }
+
+  getPlatformForPosition(position: TokenLendingPositionData): LendingPlatform {
+    return lendingPlatformToEnum(position.platform);
+  }
+
+  getForPosition(
+    position: TokenLendingPositionData
+  ): LendingPlatformClientBase<LendingPlatformData> {
+    return this.getByPlatform(this.getPlatformForPosition(position));
+  }
+
+  getByPlatform(platform: LendingPlatform.Kamino): KaminoClient;
+  getByPlatform(platform: LendingPlatform): LendingPlatformClientBase<LendingPlatformData>;
+  getByPlatform(platform: LendingPlatform): LendingPlatformClientBase<LendingPlatformData> {
+    switch (platform) {
+      case LendingPlatform.None:
+        throw new Error("Lending position does not have an active lending platform");
+      case LendingPlatform.Kamino:
+        return this.kaminoClient;
+      default:
+        throw new Error(`Unsupported lending platform client: ${platform}`);
+    }
+  }
+}