@kestrelfi/lyc-sdk 1.0.1 → 1.0.3

package/src/client/builders/setTokenCircuitBreakerBuilder.ts

@@ -1,40 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,264 +0,0 @@
-/**
- * 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

@@ -1,54 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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}`);
-    }
-  }
-}