@kestrelfi/lyc-sdk 1.0.1

package/dist/shared/common/src/services/swap/routableSwapClient.d.ts

@@ -0,0 +1,36 @@
+import type { Address } from "@solana/kit";
+import type { SwapClient } from "./swapClientBase";
+/**
+ * Swap client with explicit routable mint metadata for aggregators.
+ *
+ * Composite clients (e.g. one that delegates to several backends) typically
+ * implement only {@link SwapClient}.
+ */
+export interface RoutableSwapClient<TRawQuote = unknown> extends SwapClient<TRawQuote> {
+    /**
+     * Mints that may appear on the input side of a supported swap (see
+     * {@link swapClientCanRoute}).
+     */
+    readonly inputMints: readonly Address[];
+    /**
+     * Mints that may appear on the output side of a supported swap.
+     * For symmetric protocols, this is often the same array as `inputMints`.
+     */
+    readonly outputMints: readonly Address[];
+    /**
+     * Extra constraint when `inputMints` / `outputMints` alone would admit invalid
+     * pairs.
+     *
+     * A naive rule “`inputMint` ∈ `inputMints` and `outputMint` ∈ `outputMints`”
+     * is equivalent to allowing **every** directed edge in the complete bipartite
+     * graph between those two name sets. That is wrong for Perena: USDC→USD* and
+     * USD*→USDT are supported, so USDC must be allowed as an input and USDT as an
+     * output — which would also admit USDC→USDT, which Perena does not support.
+     * `routeAnchorMints` (e.g. USD* and USD*-J) requires at least one side of the
+     * swap to touch the bank/junior tranche so yielding↔yielding legs are excluded.
+     *
+     * Empty means no such constraint (and empty `inputMints`/`outputMints` mean
+     * wildcard routing for clients like Jupiter).
+     */
+    readonly routeAnchorMints: readonly Address[];
+}

package/dist/shared/common/src/services/swap/routableSwapClient.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/common/src/services/swap/swapClientBase.d.ts

@@ -0,0 +1,45 @@
+import type { Address } from "@solana/kit";
+import type { SwapQuoteParams, SwapQuote, SwapInstructionOptions, SwapQuoteCoveringMinOutputParams } from "./types";
+import { CpiData } from "../../types";
+/**
+ * Base interface for swap clients.
+ *
+ * Implementations of this interface provide a unified API for interacting
+ * with different DEX aggregators (Jupiter, Raydium, etc.) for CPI swaps
+ * in addition to direct integration with other swap-like programs, like USD* mint/burn.
+ *
+ * @typeParam TRawQuote - Platform-specific quote type
+ *
+ * @example
+ * ```typescript
+ * const client: SwapClient = new JupiterSwapClient(rpc);
+ * const quote = await client.getQuote({ inputMint, outputMint, amount });
+ * const { data, accounts, programId } = await client.getSwapCpiData(quote, userPda);
+ * ```
+ */
+export interface SwapClient<TRawQuote = unknown> {
+    /**
+     * Get a swap quote for the given parameters.
+     *
+     * @param params - Quote parameters (mints, amount, slippage)
+     * @returns Normalized swap quote with expected output amount
+     */
+    getQuote(params: SwapQuoteParams): Promise<SwapQuote<TRawQuote>>;
+    /**
+     * Size a swap so expected output is at least {@link SwapQuoteCoveringMinOutputParams.minOutputAmount}
+     * while spending no more than {@link SwapQuoteCoveringMinOutputParams.maxInputAmount} input.
+     *
+     * Implementations use backend-specific mechanics (e.g. Perena oracle linearization,
+     * Jupiter `ExactOut` quotes).
+     */
+    getQuoteCoveringMinOutput(params: SwapQuoteCoveringMinOutputParams): Promise<SwapQuote<TRawQuote>>;
+    /**
+     * Build the swap instruction for CPI.
+     *
+     * @param quote - Quote from getQuote()
+     * @param userPublicKey - Address that will execute the swap (can be a PDA)
+     * @param options - Optional settings (e.g., wrapAndUnwrapSol)
+     * @returns Instruction data and accounts for CPI
+     */
+    getSwapCpiData(quote: SwapQuote<TRawQuote>, userPublicKey: Address, options?: SwapInstructionOptions): Promise<CpiData>;
+}

package/dist/shared/common/src/services/swap/swapClientBase.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/common/src/services/swap/swapRouting.d.ts

@@ -0,0 +1,13 @@
+import type { Address } from "@solana/kit";
+import type { RoutableSwapClient } from "./routableSwapClient";
+/**
+ * Whether a routable swap client can quote a swap from `inputMint` to `outputMint`.
+ *
+ * - **Wildcard** (`inputMints` and `outputMints` both empty): any distinct pair
+ *   (Jupiter-style fallback).
+ * - Otherwise: `inputMint` must be in `inputMints` and `outputMint` in `outputMints`.
+ *   When `routeAnchorMints` is non-empty, at least one of the two mints must be an
+ *   anchor — see {@link RoutableSwapClient} (two name sets alone are not enough for
+ *   protocols like Perena).
+ */
+export declare function swapClientCanRoute(client: RoutableSwapClient, inputMint: Address, outputMint: Address): boolean;

package/dist/shared/common/src/services/swap/swapRouting.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swapClientCanRoute = swapClientCanRoute;
+/**
+ * Whether a routable swap client can quote a swap from `inputMint` to `outputMint`.
+ *
+ * - **Wildcard** (`inputMints` and `outputMints` both empty): any distinct pair
+ *   (Jupiter-style fallback).
+ * - Otherwise: `inputMint` must be in `inputMints` and `outputMint` in `outputMints`.
+ *   When `routeAnchorMints` is non-empty, at least one of the two mints must be an
+ *   anchor — see {@link RoutableSwapClient} (two name sets alone are not enough for
+ *   protocols like Perena).
+ */
+function swapClientCanRoute(client, inputMint, outputMint) {
+    if (inputMint === outputMint) {
+        return false;
+    }
+    if (client.inputMints.length === 0 && client.outputMints.length === 0) {
+        return true;
+    }
+    if (!client.inputMints.includes(inputMint) || !client.outputMints.includes(outputMint)) {
+        return false;
+    }
+    if (client.routeAnchorMints.length === 0) {
+        return true;
+    }
+    return client.routeAnchorMints.some((m) => m === inputMint || m === outputMint);
+}

package/dist/shared/common/src/services/swap/types.d.ts

@@ -0,0 +1,77 @@
+import type { Address } from "@solana/kit";
+/**
+ * Parameters for requesting a swap quote.
+ */
+export interface SwapQuoteParams {
+    /** Input token mint address */
+    inputMint: Address;
+    /** Output token mint address */
+    outputMint: Address;
+    /** Amount to swap in smallest units (e.g., lamports, not SOL) */
+    amount: number;
+    /** Slippage tolerance in basis points (e.g., 500 = 5%) */
+    slippageBps?: number;
+    /**
+     * If true, restrict the quote to direct routes (no intermediate hops).
+     * Useful for CPI flows where intermediate-mint ATAs (e.g. WSOL) wouldn't
+     * exist for a PDA caller. Backends that don't multi-hop ignore this.
+     */
+    onlyDirectRoutes?: boolean;
+    /**
+     * Optional backend-specific route account budget. Jupiter uses this to
+     * decide whether larger multi-hop routes are eligible.
+     */
+    maxAccounts?: number;
+    /**
+     * DEX labels to exclude from routing, merged with any client-level default
+     * exclusions. Backends without venue routing (Perena) ignore this.
+     */
+    excludeDexes?: string[];
+}
+/**
+ * Parameters for sizing a swap so realized output is at least a target, without
+ * exceeding a maximum input spend (base units). Backends may use oracle math
+ * (Perena) or exact-out routing (Jupiter), etc.
+ */
+export interface SwapQuoteCoveringMinOutputParams {
+    inputMint: Address;
+    outputMint: Address;
+    /** Minimum output amount required (smallest units of `outputMint`). */
+    minOutputAmount: bigint;
+    /** Maximum input amount allowed (smallest units of `inputMint`). */
+    maxInputAmount: bigint;
+    slippageBps?: number;
+}
+/**
+ * Normalized swap quote returned by any swap client.
+ *
+ * @typeParam TRawQuote - Platform-specific quote type (e.g., Jupiter's QuoteResponse)
+ */
+export interface SwapQuote<TRawQuote = unknown> {
+    /** Input token mint address */
+    inputMint: Address;
+    /** Output token mint address */
+    outputMint: Address;
+    /** Input amount in smallest units */
+    inputAmount: bigint;
+    /** Expected output amount in smallest units */
+    outputAmount: bigint;
+    /** Price impact as a percentage (e.g., 0.5 = 0.5%) */
+    priceImpactPct: number;
+    /** Platform-specific quote data (e.g., Jupiter's QuoteResponse) */
+    rawQuote: TRawQuote;
+}
+/**
+ * Options for building a swap instruction.
+ */
+export interface SwapInstructionOptions {
+    /** Whether to automatically wrap/unwrap SOL (default: false for CPI) */
+    wrapAndUnwrapSol?: boolean;
+    /**
+     * Real signer that pays for any pre-instructions the swap client needs
+     * (e.g. createATA for intermediate-mint accounts on a multi-hop route).
+     * The swap authority (`userPublicKey`) is typically a PDA and cannot pay.
+     * When omitted, the swap client skips emitting pre-instructions.
+     */
+    payer?: Address;
+}

package/dist/shared/common/src/services/swap/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/common/src/services/token/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./tokenProtocolClientBase";

package/dist/shared/common/src/services/token/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./tokenProtocolClientBase"), exports);

package/dist/shared/common/src/services/token/tokenProtocolClientBase.d.ts

@@ -0,0 +1,51 @@
+import type { Address } from "@solana/kit";
+import type { TokenProtocolInfo } from "./types";
+/**
+ * Interface for token protocol clients.
+ *
+ * This interface provides information about protocol capabilities,
+ * supported mints, fees, and limits. It's separate from SwapClient
+ * to maintain single responsibility - SwapClient handles quotes and
+ * instructions, TokenProtocolClient handles protocol info.
+ *
+ * Clients like PerenaClient can implement both interfaces.
+ *
+ * @example
+ * ```typescript
+ * // Check if direct minting is possible
+ * const supported = await client.getSupportedSourceMints();
+ * if (supported.includes(inputMint)) {
+ *   // Direct mint via token protocol
+ *   const quote = await client.getQuote({ inputMint, outputMint, amount });
+ * } else {
+ *   // Need to swap to a supported mint first
+ *   const swapQuote = await jupiterClient.getQuote({ inputMint, outputMint: supported[0], amount });
+ * }
+ *
+ * // Get protocol info for fee/limit checks
+ * const info = await client.getProtocolInfo(sourceMint);
+ * console.log(`Mint fee: ${info.mintFeeBps} bps`);
+ * ```
+ */
+export interface TokenProtocolClient {
+    /**
+     * Get mints that can directly convert to the output mint.
+     *
+     * These are the "preferred" mints that don't require a swap first.
+     * For USD*, this might be [USDC]. For ONyc, this might be [USDC, USDG].
+     *
+     * @returns Array of mint addresses that can directly mint the output
+     */
+    getSupportedSourceMints(): Promise<Address[]>;
+    /**
+     * Get current protocol info for a source mint.
+     *
+     * Returns dynamic information including fees and limits.
+     * This data is fetched from the protocol and may change over time.
+     *
+     * @param sourceMint - The source mint to get info for
+     * @returns Protocol info including fees and limits
+     * @throws Error if sourceMint is not supported
+     */
+    getProtocolInfo(sourceMint: Address): Promise<TokenProtocolInfo>;
+}

package/dist/shared/common/src/services/token/tokenProtocolClientBase.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/common/src/services/token/types.d.ts

@@ -0,0 +1,19 @@
+import type { Address } from "@solana/kit";
+/**
+ * Dynamic protocol information for a token asset.
+ *
+ * This info is fetched from the protocol and may change over time
+ * based on governance, utilization, or other factors.
+ */
+export interface TokenProtocolInfo {
+    /** The source mint this info applies to */
+    sourceMint: Address;
+    /** Minting/deposit fee in basis points */
+    mintFeeBps: number;
+    /** Redemption/burn fee in basis points */
+    redemptionFeeBps: number;
+    /** Maximum deposit amount (undefined = no limit) */
+    depositLimit?: bigint;
+    /** Maximum redemption amount (undefined = no limit) */
+    redemptionLimit?: bigint;
+}

package/dist/shared/common/src/services/token/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/common/src/services/transactionSender.d.ts

@@ -0,0 +1,24 @@
+import type { Rpc, SolanaRpcApi, TransactionSigner, Instruction, Signature } from "@solana/kit";
+import { type SendTransactionOptionsWithPostSuccess, type TransactionPlan } from "../utils/transaction";
+/**
+ * Reusable transaction sender that wraps `signSendAndConfirmTransaction`.
+ *
+ * Oversized transactions are split and submitted as an atomic Jito bundle
+ * (via the user's RPC when it proxies `sendBundle`) when `jitoTipLamports > 0`.
+ * For Surfpool / local validators, pass `sendOversizedAsSequentialTransactions`
+ * to send each split as a normal transaction instead (not atomic).
+ *
+ * Designed to be extended with:
+ * - Retry logic with configurable backoff
+ * - Priority fee estimation
+ * - Transaction batching
+ *
+ * Any consumer (backend services, CLI tools, scripts) can instantiate this
+ * directly — it has no framework dependency (no NestJS, no decorators).
+ */
+export declare class TransactionSender {
+    private readonly rpc;
+    private readonly signer;
+    constructor(rpc: Rpc<SolanaRpcApi>, signer: TransactionSigner);
+    send(instructionsOrPlan: Instruction[] | TransactionPlan, options?: SendTransactionOptionsWithPostSuccess): Promise<Signature>;
+}

package/dist/shared/common/src/services/transactionSender.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionSender = void 0;
+const transaction_1 = require("../utils/transaction");
+/**
+ * Reusable transaction sender that wraps `signSendAndConfirmTransaction`.
+ *
+ * Oversized transactions are split and submitted as an atomic Jito bundle
+ * (via the user's RPC when it proxies `sendBundle`) when `jitoTipLamports > 0`.
+ * For Surfpool / local validators, pass `sendOversizedAsSequentialTransactions`
+ * to send each split as a normal transaction instead (not atomic).
+ *
+ * Designed to be extended with:
+ * - Retry logic with configurable backoff
+ * - Priority fee estimation
+ * - Transaction batching
+ *
+ * Any consumer (backend services, CLI tools, scripts) can instantiate this
+ * directly — it has no framework dependency (no NestJS, no decorators).
+ */
+class TransactionSender {
+    constructor(rpc, signer) {
+        this.rpc = rpc;
+        this.signer = signer;
+    }
+    async send(instructionsOrPlan, options) {
+        return (0, transaction_1.signSendAndConfirmTransaction)(this.rpc, this.signer, instructionsOrPlan, options);
+    }
+}
+exports.TransactionSender = TransactionSender;

package/dist/shared/common/src/types/cpi.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Generic CPI-related types for instruction building.
+ *
+ * Protocol-specific args types belong in their respective packages
+ * (e.g., perena-helpers, jupiter-helpers).
+ */
+import { CpiMapping } from "../utils/cpi/refs";
+/**
+ * References for CPI invocations.
+ *
+ * Matches Rust `CpiRefs` struct in common/src/cpi/refs.rs.
+ */
+export interface CpiRefs {
+    /** Account indices per CPI (first account of each CPI = program) */
+    accounts: CpiMapping;
+    /** Index into CPI_REGISTRY for each CPI slot */
+    types: Buffer;
+    /** Packed CPI args buffer built by CpiArgsBuilder */
+    args: Buffer;
+}
+/**
+ * Top-level references for an instruction.
+ *
+ * Matches Rust `InstructionRefs` struct in common/src/accounts/refs.rs.
+ *
+ * @property cpi - CPI refs (accounts, types, args)
+ * @property tracked - Indices of accounts to access directly
+ */
+export interface InstructionRefs {
+    /** CPI account mapping, type indices, and packed args */
+    cpi: CpiRefs;
+    /** Indices of accounts to access directly */
+    tracked: Buffer;
+}

package/dist/shared/common/src/types/cpi.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Generic CPI-related types for instruction building.
+ *
+ * Protocol-specific args types belong in their respective packages
+ * (e.g., perena-helpers, jupiter-helpers).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/common/src/types/enums.d.ts

@@ -0,0 +1,59 @@
+export type AnchorOracleType = {
+    pyth: {};
+} | {
+    switchboard: {};
+} | {
+    perenaBank: {};
+} | {
+    perenaTranche: {};
+} | {
+    tpConsensusOracle: {};
+} | {
+    pythSplStake: {};
+};
+export declare enum OracleType {
+    Pyth = 0,
+    Switchboard = 1,
+    PerenaBank = 2,
+    PerenaTranche = 3,
+    PythSplStake = 4,
+    TPConsensusOracle = 5
+}
+export declare function oracleTypeToEnum(v: AnchorOracleType): OracleType;
+export declare function enumToOracleType(t: OracleType): AnchorOracleType;
+export type AnchorExternalLiquidityType = {
+    none: {};
+} | {
+    perenaWithdrawalQueue: {};
+};
+export declare enum ExternalLiquidityType {
+    None = 0,
+    PerenaWithdrawalQueue = 1
+}
+export declare function ExternalLiquidityTypeToEnum(v: AnchorExternalLiquidityType): ExternalLiquidityType;
+export declare function enumToExternalLiquidityType(t: ExternalLiquidityType): AnchorExternalLiquidityType;
+export type AnchorTokenProgram = {
+    spl: {};
+} | {
+    token2022: {};
+};
+export declare enum TokenProgram {
+    Spl = 0,
+    Token2022 = 1
+}
+export declare function tokenProgramToEnum(v: AnchorTokenProgram): TokenProgram;
+export declare function enumToTokenProgram(t: TokenProgram): AnchorTokenProgram;
+export type AnchorLendingPlatform = {
+    none: {};
+} | {
+    marginfi: {};
+} | {
+    kamino: {};
+};
+export declare enum LendingPlatform {
+    None = 0,
+    Marginfi = 1,
+    Kamino = 2
+}
+export declare function lendingPlatformToEnum(v: AnchorLendingPlatform): LendingPlatform;
+export declare function enumToLendingPlatform(t: LendingPlatform): AnchorLendingPlatform;

package/dist/shared/common/src/types/enums.js

@@ -0,0 +1,122 @@
+"use strict";
+// =============================================================================
+// Shared Anchor enum types + numeric enums + converters
+// =============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LendingPlatform = exports.TokenProgram = exports.ExternalLiquidityType = exports.OracleType = void 0;
+exports.oracleTypeToEnum = oracleTypeToEnum;
+exports.enumToOracleType = enumToOracleType;
+exports.ExternalLiquidityTypeToEnum = ExternalLiquidityTypeToEnum;
+exports.enumToExternalLiquidityType = enumToExternalLiquidityType;
+exports.tokenProgramToEnum = tokenProgramToEnum;
+exports.enumToTokenProgram = enumToTokenProgram;
+exports.lendingPlatformToEnum = lendingPlatformToEnum;
+exports.enumToLendingPlatform = enumToLendingPlatform;
+var OracleType;
+(function (OracleType) {
+    OracleType[OracleType["Pyth"] = 0] = "Pyth";
+    OracleType[OracleType["Switchboard"] = 1] = "Switchboard";
+    OracleType[OracleType["PerenaBank"] = 2] = "PerenaBank";
+    OracleType[OracleType["PerenaTranche"] = 3] = "PerenaTranche";
+    // LST priced from an SPL stake pool exchange rate × a Pyth SOL/USD feed
+    // (capped at 1.1 × SOL/USD). The Pyth SOL feed is the primary oracle and the
+    // SPL stake pool account is the secondary oracle.
+    OracleType[OracleType["PythSplStake"] = 4] = "PythSplStake";
+    OracleType[OracleType["TPConsensusOracle"] = 5] = "TPConsensusOracle";
+})(OracleType || (exports.OracleType = OracleType = {}));
+function oracleTypeToEnum(v) {
+    if ("pyth" in v)
+        return OracleType.Pyth;
+    if ("switchboard" in v)
+        return OracleType.Switchboard;
+    if ("perenaBank" in v)
+        return OracleType.PerenaBank;
+    if ("perenaTranche" in v)
+        return OracleType.PerenaTranche;
+    if ("pythSplStake" in v)
+        return OracleType.PythSplStake;
+    if ("tpConsensusOracle" in v)
+        return OracleType.TPConsensusOracle;
+    throw new Error("Unknown OracleType variant");
+}
+function enumToOracleType(t) {
+    switch (t) {
+        case OracleType.Pyth:
+            return { pyth: {} };
+        case OracleType.Switchboard:
+            return { switchboard: {} };
+        case OracleType.PerenaBank:
+            return { perenaBank: {} };
+        case OracleType.PerenaTranche:
+            return { perenaTranche: {} };
+        case OracleType.PythSplStake:
+            return { pythSplStake: {} };
+        case OracleType.TPConsensusOracle:
+            return { tpConsensusOracle: {} };
+    }
+}
+var ExternalLiquidityType;
+(function (ExternalLiquidityType) {
+    ExternalLiquidityType[ExternalLiquidityType["None"] = 0] = "None";
+    ExternalLiquidityType[ExternalLiquidityType["PerenaWithdrawalQueue"] = 1] = "PerenaWithdrawalQueue";
+})(ExternalLiquidityType || (exports.ExternalLiquidityType = ExternalLiquidityType = {}));
+function ExternalLiquidityTypeToEnum(v) {
+    if ("none" in v)
+        return ExternalLiquidityType.None;
+    if ("perenaWithdrawalQueue" in v)
+        return ExternalLiquidityType.PerenaWithdrawalQueue;
+    throw new Error("Unknown ExternalLiquidityType variant");
+}
+function enumToExternalLiquidityType(t) {
+    switch (t) {
+        case ExternalLiquidityType.None:
+            return { none: {} };
+        case ExternalLiquidityType.PerenaWithdrawalQueue:
+            return { perenaWithdrawalQueue: {} };
+    }
+}
+var TokenProgram;
+(function (TokenProgram) {
+    TokenProgram[TokenProgram["Spl"] = 0] = "Spl";
+    TokenProgram[TokenProgram["Token2022"] = 1] = "Token2022";
+})(TokenProgram || (exports.TokenProgram = TokenProgram = {}));
+function tokenProgramToEnum(v) {
+    if ("spl" in v)
+        return TokenProgram.Spl;
+    if ("token2022" in v)
+        return TokenProgram.Token2022;
+    throw new Error("Unknown TokenProgram variant");
+}
+function enumToTokenProgram(t) {
+    switch (t) {
+        case TokenProgram.Spl:
+            return { spl: {} };
+        case TokenProgram.Token2022:
+            return { token2022: {} };
+    }
+}
+var LendingPlatform;
+(function (LendingPlatform) {
+    LendingPlatform[LendingPlatform["None"] = 0] = "None";
+    LendingPlatform[LendingPlatform["Marginfi"] = 1] = "Marginfi";
+    LendingPlatform[LendingPlatform["Kamino"] = 2] = "Kamino";
+})(LendingPlatform || (exports.LendingPlatform = LendingPlatform = {}));
+function lendingPlatformToEnum(v) {
+    if ("none" in v)
+        return LendingPlatform.None;
+    if ("marginfi" in v)
+        return LendingPlatform.Marginfi;
+    if ("kamino" in v)
+        return LendingPlatform.Kamino;
+    throw new Error("Unknown LendingPlatform variant");
+}
+function enumToLendingPlatform(t) {
+    switch (t) {
+        case LendingPlatform.None:
+            return { none: {} };
+        case LendingPlatform.Marginfi:
+            return { marginfi: {} };
+        case LendingPlatform.Kamino:
+            return { kamino: {} };
+    }
+}

package/dist/shared/common/src/types/general.d.ts

@@ -0,0 +1,38 @@
+import { Address } from "@solana/kit";
+import type { DataCache } from "../services/dataCache";
+export type Environment = "local" | "test" | "prod";
+/**
+ * Remote deployment tiers only (`test` | `prod`). `local` is dev/Surfpool and is excluded from
+ * types that describe on-chain deployed program tiers (e.g. operator keypair paths per cluster).
+ */
+export type DeployedEnv = Exclude<Environment, "local">;
+/** A mint address or token symbol (case-insensitive) */
+export type MintIdentifier = string | Address;
+/**
+ * Cache entries to clear after a successful transaction.
+ *
+ * Kamino entries target lending SDK caches; `lycToken` / `lycYieldingBank` clear
+ * long-yield-carry program DataCache entries; `splAta` clears the SPL ATA existence
+ * cache for one address (must match `SPL_ATA_CACHE_CATEGORY` in
+ * `services/baseAccountClient.ts`); `perena` clears one entry from a Perena client
+ * DataCache after the transaction confirms.
+ */
+export type TransactionCacheInvalidation = {
+    client: "kamino";
+    category: string;
+    id: Address;
+} | {
+    client: "lycToken";
+    tokenPda: Address;
+} | {
+    client: "lycYieldingBank";
+    yieldingBankPda: Address;
+} | {
+    client: "splAta";
+    ata: Address;
+} | {
+    client: "perena";
+    dataCache: DataCache;
+    category: string;
+    id: Address;
+};

package/dist/shared/common/src/types/general.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/common/src/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./solana";
+export * from "./general";
+export * from "./cpi";
+export * from "./enums";