@exponent-labs/exponent-sdk 0.1.7 → 0.9.0

package/build/marketThree.d.ts

@@ -0,0 +1,798 @@
+import { ExponentCLMMPDA } from "@exponent-labs/exponent-clmm-pda";
+import { LiquidityNetBalanceLimits, LpFarm, LpPositionCLMM, MarketConfigurationOptions, MarketThreeFinancials, Ticks } from "@exponent-labs/exponent-fetcher";
+import { ExponentPDA } from "@exponent-labs/exponent-pda";
+import { AnchorizedPNum, CpiAccountsRaw, ExponentCoreCpiAccountsRaw, Flavor, SyPosition } from "@exponent-labs/exponent-types";
+import { LiquidityAdd } from "@exponent-labs/market-math";
+import { Environment } from "./environment";
+import { Vault } from "./vault";
+import { Connection, Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import * as exponentClmm from './client/clmm';
+import { SwapDirection } from './client/clmm';
+export { LiquidityAdd };
+interface Emission {
+    /** Token account that holds emission tokens */
+    escrowAccountAddress: PublicKey;
+    /** Mint for the emission token */
+    mint: PublicKey;
+    /** Token program ID for the emission token */
+    tokenProgramAddress: PublicKey;
+    /** How many emissions have been claimed by SY holders */
+    totalClaimed: bigint;
+    /** How many emissions have been earned by the SY robot over its lifetime */
+    lastSeenTotalAccruedEmissions: bigint;
+    /** Global index for sharing out rewards to SY holders */
+    index: AnchorizedPNum;
+}
+export type MarketAdminAction = exponentClmm.MarketAdminAction;
+export { SwapDirection } from './client/clmm';
+interface MarketThreeLoadOptions {
+    syConfig?: {
+        skipWrap?: boolean;
+    };
+}
+type MarketThreeArgs = {
+    admin: PublicKey;
+    addressLookupTable: PublicKey;
+    mintPt: PublicKey;
+    mintYt: PublicKey;
+    mintSy: PublicKey;
+    vault: Vault;
+    tokenPtEscrow: PublicKey;
+    tokenSyEscrow: PublicKey;
+    tokenYtEscrow: PublicKey;
+    tokenFeeTreasurySy: PublicKey;
+    tokenFeeTreasuryPt: PublicKey;
+    syProgram: PublicKey;
+    selfAddress: PublicKey;
+    statusFlags: number;
+    configurationOptions: MarketConfigurationOptions;
+    financials: MarketThreeFinancials;
+    cpiSyAccounts: CpiAccountsRaw;
+    cpiCoreAccounts: ExponentCoreCpiAccountsRaw;
+    isCurrentFlashSwap: boolean;
+    lpFarm: LpFarm;
+    flavor: Flavor;
+    emissions: {
+        trackers: {
+            tokenEscrow: PublicKey;
+            lpShareIndex: number;
+            lastSeenStaged: number;
+        }[];
+    };
+    liquidityNetBalanceLimits: LiquidityNetBalanceLimits;
+    ticksAccount: PublicKey;
+    ticks: Ticks;
+    syPosition: SyPosition;
+    treasuryFeeOwner: PublicKey;
+};
+/**
+ * CLMM (Concentrated Liquidity Market Maker) market client for the Exponent protocol.
+ *
+ * Provides instruction builders for trading PT/YT tokens, managing concentrated liquidity positions,
+ * and administering market settings. Each `ix*` method returns one or more Solana `TransactionInstruction`s
+ * ready to be included in a transaction.
+ *
+ * "Wrapper" methods (e.g. `ixWrapperBuyPt`) combine a base-asset mint/redeem step with the
+ * underlying trade so the caller can operate directly with the base asset rather than SY.
+ */
+export declare class MarketThree {
+    state: MarketThreeArgs;
+    selfAddress: PublicKey;
+    env: Environment;
+    connection: Connection;
+    xponPda: ExponentPDA;
+    pda: ExponentCLMMPDA;
+    constructor(state: MarketThreeArgs, selfAddress: PublicKey, env: Environment, connection: Connection);
+    /**
+     * Build the modify_market_setting instruction without loading the full market.
+     * Use this when the market's ALT is invalid/unset (e.g. repair flow) to avoid fetching the ALT.
+     */
+    static buildModifyMarketSettingIx(connection: Connection, marketAddress: PublicKey, { signer, adminAction }: {
+        signer: PublicKey;
+        adminAction: MarketAdminAction;
+    }): TransactionInstruction;
+    /**
+     * Load a MarketThree instance from on-chain state.
+     *
+     * Fetches the market account, its address lookup table, vault, and ticks data in parallel.
+     * Pre-loaded vault/ticks can be passed to avoid redundant fetches.
+     *
+     * @param env - Environment configuration (program IDs, cluster)
+     * @param connection - Solana RPC connection
+     * @param address - On-chain address of the market account
+     * @param vault - Optional pre-loaded vault (fetched automatically if omitted)
+     * @param ticks - Optional pre-loaded ticks data (fetched automatically if omitted)
+     * @param options - Optional load options (e.g. SY config overrides)
+     */
+    static load(env: Environment, connection: Connection, address: PublicKey, vault?: Vault, ticks?: Ticks, options?: MarketThreeLoadOptions): Promise<MarketThree>;
+    reload(connection?: Connection): Promise<MarketThree>;
+    get vault(): Vault;
+    get flavor(): Flavor;
+    get lpBalance(): bigint;
+    get syBalance(): bigint;
+    get ptBalance(): bigint;
+    get mintSy(): PublicKey;
+    get mintPt(): PublicKey;
+    get statusFlags(): number;
+    get mintYt(): PublicKey;
+    get addressLookupTable(): PublicKey;
+    get syProgram(): PublicKey;
+    get cpiSyAccounts(): CpiAccountsRaw;
+    get cpiCoreAccounts(): ExponentCoreCpiAccountsRaw;
+    get marketEmissions(): {
+        trackers: {
+            tokenEscrow: PublicKey;
+            lpShareIndex: number;
+            lastSeenStaged: number;
+        }[];
+    };
+    get ticksKey(): PublicKey;
+    get corePda(): ExponentPDA;
+    get coreEventAuthority(): PublicKey;
+    get emissions(): Emission[];
+    /** Get the escrow token account addresses for the emissions, in order */
+    get emissionTokenAccounts(): PublicKey[];
+    /** Pass-through SY account owned by the market */
+    get tokenSyEscrow(): PublicKey;
+    /** Pass-through YT account owned by the market */
+    get tokenYtEscrow(): PublicKey;
+    /** SY account that holds treasury SY fees from PT trading */
+    get tokenFeeTreasurySy(): PublicKey;
+    /** PT account that holds treasury PT fees from PT trading */
+    get tokenFeeTreasuryPt(): PublicKey;
+    /** Market liquidity for PT */
+    get tokenPtEscrow(): PublicKey;
+    get currentSyExchangeRate(): number;
+    /** Special account for event emit self-cpi */
+    get eventAuthority(): PublicKey;
+    get secondsRemaining(): number;
+    /** Annualize a rate given the number of seconds remaining until maturity */
+    static annualize(rate: number, secondsRemaining: number): number;
+    static annualizeApy(rate: number, secondsRemaining: number): number;
+    /** The fee rate taken off of trade fees (typically around 20%) expressed as a BPS number */
+    get feeTreasuryBps(): number;
+    /** The fee rate taken off of trade fees (typically around 20%) expressed as a rational number */
+    get feeTreasuryRate(): number;
+    /** Get the owner of the treasury fee accounts: tokenFeeTreasuryPt & tokenFeeTreasurySy */
+    static fetchTreasuryFeeOwner(tokenFeeTreasury: PublicKey, connection: Connection): Promise<PublicKey>;
+    /** Deposit a pair of tokens as liquidity to the market
+     * Adds PT & SY from the `depositor` to the market
+     *
+     * Due to unforeseeable slippage, the PT & SY amounts intended are effectively the maximum amounts
+     * The minimum LP tokens to receive is specified by `minLpOut`
+     *
+     * The token accounts themselves are optional, and will be derived from the depositor's wallet if not provided
+     */
+    ixDepositLiquidity({ ptInIntent, syInIntent, depositor, lowerTickKey, upperTickKey, ptSrc: ptSrcParam, sySrc: sySrcParam, lpPosition: lpPositionParam, }: {
+        /** Intended (maximum) amount of PT in */
+        ptInIntent: bigint;
+        /** Intended (maximum) amount of SY in */
+        syInIntent: bigint;
+        /** Lower tick key */
+        lowerTickKey: number;
+        /** Upper tick key */
+        upperTickKey: number;
+        depositor: PublicKey;
+        ptSrc?: PublicKey;
+        sySrc?: PublicKey;
+        lpPosition?: Keypair;
+    }): {
+        ix: TransactionInstruction;
+        signers: Keypair;
+    };
+    /**
+     * Redeem LP tokens for PT & SY  (liquidity removal)
+     *
+     * The lpIn is exactly the amount of LP tokens to burn
+     * The minimum PT & SY out are specified by minPtOut & minSyOut
+     * The transaction may fail due to unforeseeable slippage on the redemption rate
+     *
+     * The token accounts themselves are optional, and will be derived from the withdrawer's wallet if not provided
+     */
+    ixWithdrawLiquidity({ lpIn, withdrawer, lpPosition, minPtOut, minSyOut, ptDst: ptDstParam, syDst: syDstParam, }: {
+        lpIn: bigint;
+        withdrawer: PublicKey;
+        lpPosition: PublicKey;
+        minPtOut: bigint;
+        minSyOut: bigint;
+        ptDst?: PublicKey;
+        syDst?: PublicKey;
+        lnImpliedApyLimit?: number;
+    }): {
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    };
+    /**
+     * Swap PT <-> SY on the CLMM.
+     *
+     * Low-level instruction — prefer {@link ixBuyPt} / {@link ixSellPt} for directional trades.
+     *
+     * @param trader - Wallet signing the transaction
+     * @param traderAmount - Amount of the input token
+     * @param outConstraint - Minimum output amount (slippage protection)
+     * @param swapDirection - `SwapDirection.SyToPt` or `SwapDirection.PtToSy`
+     * @param lnImpliedApyLimit - Optional price limit (ln implied APY)
+     */
+    ixTradePt({ trader, traderAmount, outConstraint, swapDirection, tokenPt: tokenPtParam, tokenSy: tokenSyParam, lnImpliedApyLimit, }: {
+        trader: PublicKey;
+        traderAmount: bigint;
+        outConstraint: bigint;
+        swapDirection: SwapDirection;
+        tokenPt?: PublicKey;
+        tokenSy?: PublicKey;
+        lnImpliedApyLimit?: number;
+    }): {
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    };
+    /**
+     * Swap PT <-> SY specifying the exact output amount.
+     *
+     * Inverse of {@link ixTradePt} — the caller specifies how much they want to *receive*
+     * rather than how much they want to *spend*.
+     *
+     * @param trader - Wallet signing the transaction
+     * @param amountOut - Exact amount of the output token to receive
+     * @param swapDirection - `SwapDirection.SyToPt` or `SwapDirection.PtToSy`
+     * @param amountInConstraint - Maximum input amount (slippage protection)
+     * @param lnImpliedApyLimit - Optional price limit (ln implied APY)
+     */
+    ixTradePtExactOut({ trader, amountOut, swapDirection, amountInConstraint, tokenPt: tokenPtParam, tokenSy: tokenSyParam, lnImpliedApyLimit, }: {
+        trader: PublicKey;
+        amountOut: bigint;
+        swapDirection: SwapDirection;
+        amountInConstraint?: bigint;
+        tokenPt?: PublicKey;
+        tokenSy?: PublicKey;
+        lnImpliedApyLimit?: number;
+    }): {
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    };
+    /** Buy PT with SY
+     *
+     * The trader is the account that sends the SY
+     * The amountPt is the exact amount of PT the trader intends to buy
+     * The syConstraint is the maximum amount of SY the trader is willing to spend
+     *
+     * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
+     */
+    ixBuyPt({ trader, amountSy, outConstraint, tokenPt, tokenSy, lnImpliedApyLimit, }: {
+        trader: PublicKey;
+        amountSy: bigint;
+        outConstraint: bigint;
+        tokenPt?: PublicKey;
+        tokenSy?: PublicKey;
+        lnImpliedApyLimit?: number;
+    }): {
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    };
+    /**
+     * Sell PT for SY
+     * The trader is the account that sends the PT
+     * The amountPt is the exact amount of PT the trader intends to sell
+     * The minSyReceive is the minimum amount of SY the trader is willing to receive
+     *
+     * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
+     */
+    ixSellPt({ trader, amountPt, outConstraint, tokenPt, tokenSy, lnImpliedApyLimit, }: {
+        trader: PublicKey;
+        amountPt: bigint;
+        outConstraint: bigint;
+        tokenPt?: PublicKey;
+        tokenSy?: PublicKey;
+        lnImpliedApyLimit?: number;
+    }): {
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    };
+    /**
+     * Buy exact amount of PT with SY
+     *
+     * The trader specifies the exact amount of PT they want to receive
+     * The maxSyIn is the maximum amount of SY the trader is willing to spend
+     */
+    ixBuyPtExactOut({ trader, amountPt, maxSyIn, tokenPt, tokenSy, lnImpliedApyLimit, }: {
+        trader: PublicKey;
+        amountPt: bigint;
+        maxSyIn?: bigint;
+        tokenPt?: PublicKey;
+        tokenSy?: PublicKey;
+        lnImpliedApyLimit?: number;
+    }): {
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    };
+    /**
+     * Sell PT for exact amount of SY
+     *
+     * The trader specifies the exact amount of SY they want to receive
+     * The maxPtIn is the maximum amount of PT the trader is willing to spend
+     */
+    ixSellPtExactOut({ trader, amountSy, maxPtIn, tokenPt, tokenSy, lnImpliedApyLimit, }: {
+        trader: PublicKey;
+        amountSy: bigint;
+        maxPtIn?: bigint;
+        tokenPt?: PublicKey;
+        tokenSy?: PublicKey;
+        lnImpliedApyLimit?: number;
+    }): {
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    };
+    /** Buy YT with SY
+     *
+     * The trader is the account that sends the SY
+     *
+     * The ytOut is the exact amount of YT the trader intends to buy
+     *
+     * The maxSyIn is the maximum amount of SY the trader is willing to spend
+     *
+     * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
+     */
+    ixBuyYt({ trader, ytOut, maxSyIn, ytTrader: ytTraderParam, ptTrader: ptTraderParam, syTrader: syTraderParam, lnImpliedApyLimit, }: {
+        trader: PublicKey;
+        ytOut: bigint;
+        maxSyIn: bigint;
+        ytTrader?: PublicKey;
+        ptTrader?: PublicKey;
+        syTrader?: PublicKey;
+        lnImpliedApyLimit?: number;
+    }): {
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    };
+    /** Sell YT for SY
+     *
+     * The trader is the account that sends the YT
+     *
+     * The amountYt is the exact amount of YT the trader intends to sell
+     *
+     * The minSyOut is the minimum amount of SY the trader is willing to receive
+     *
+     * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
+     */
+    ixSellYt({ trader, ytIn, minSyOut, ytSrc: ytSrcParam, ptSrc: ptSrcParam, syDst: syDstParam, lnImpliedApyLimit, }: {
+        trader: PublicKey;
+        ytIn: bigint;
+        minSyOut: bigint;
+        ytSrc?: PublicKey;
+        ptSrc?: PublicKey;
+        syDst?: PublicKey;
+        lnImpliedApyLimit?: number;
+    }): {
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    };
+    /** Apply an admin action to the market (e.g. change status, fees, tick spacing). */
+    ixModifyMarketSetting({ signer, adminAction }: {
+        signer: PublicKey;
+        adminAction: MarketAdminAction;
+    }): TransactionInstruction;
+    /**
+     * Add a new farm to the market to distribute rewards to LP holders
+     *
+     * @param signer - The admin address that signs the transaction
+     * @param farmMint - The mint address of the farm reward token
+     * @param farmTokenProgram - The token program for the farm reward token
+     * @param emissionsRate - The rate of emissions per second (in token smallest units)
+     * @param untilTimestamp - Unix timestamp when the farm emissions should end
+     * @param farmTokenSrc - Optional source token account for the farm rewards (derived from signer if not provided)
+     * @param feePayer - Optional fee payer for account reallocation (defaults to signer)
+     */
+    ixAddFarm({ signer, farmMint, farmTokenProgram, emissionsRate, untilTimestamp, farmTokenSrc: farmTokenSrcParam, feePayer: feePayerParam, }: {
+        signer: PublicKey;
+        farmMint: PublicKey;
+        farmTokenProgram: PublicKey;
+        emissionsRate: bigint;
+        untilTimestamp: number;
+        farmTokenSrc?: PublicKey;
+        feePayer?: PublicKey;
+    }): {
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    };
+    /**
+     * Modify an existing farm's emissions rate and/or expiration timestamp
+     *
+     * If the new parameters require more tokens than previously undistributed,
+     * additional tokens will be transferred from the signer's token account.
+     * If fewer tokens are needed, the surplus will be returned to the signer.
+     *
+     * @param signer - The admin address that signs the transaction
+     * @param farmMint - The mint address of the farm reward token
+     * @param farmTokenProgram - The token program for the farm reward token
+     * @param newRate - The new rate of emissions per second (in token smallest units)
+     * @param untilTimestamp - New unix timestamp when the farm emissions should end
+     * @param farmTokenSrc - Optional source/destination token account (derived from signer if not provided)
+     */
+    ixModifyFarm({ signer, farmMint, farmTokenProgram, newRate, untilTimestamp, farmTokenSrc: farmTokenSrcParam, }: {
+        signer: PublicKey;
+        farmMint: PublicKey;
+        farmTokenProgram: PublicKey;
+        newRate: bigint;
+        untilTimestamp: number;
+        farmTokenSrc?: PublicKey;
+    }): {
+        ixs: TransactionInstruction[];
+    };
+    /**
+     * Buy PT directly from the base asset (e.g. SOL, USDC).
+     *
+     * Wraps a mint-SY step (via the flavor) with a buy-PT swap in a single instruction.
+     * The program mints SY from the base asset, then swaps SY -> PT on the CLMM.
+     *
+     * @param owner - Wallet signing the transaction
+     * @param baseIn - Amount of base asset to spend
+     * @param minPtOut - Minimum PT to receive (slippage protection)
+     * @param lnImpliedApyLimit - Optional price limit (ln implied APY)
+     */
+    ixWrapperBuyPt({ owner, minPtOut, baseIn, tokenSyTrader: tokenSyTraderParam, tokenPtTrader: tokenPtTraderParam, tokenBaseTrader: tokenBaseTraderParam, lnImpliedApyLimit, }: {
+        owner: PublicKey;
+        minPtOut: bigint;
+        baseIn: bigint;
+        tokenSyTrader?: PublicKey;
+        tokenPtTrader?: PublicKey;
+        tokenBaseTrader?: PublicKey;
+        lnImpliedApyLimit?: number;
+    }): Promise<{
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    }>;
+    /**
+     * Sell PT and receive the base asset (e.g. SOL, USDC).
+     *
+     * Wraps a PT -> SY swap with a redeem-SY step (via the flavor) in a single instruction.
+     * The program swaps PT -> SY on the CLMM, then redeems SY for the base asset.
+     *
+     * @param owner - Wallet signing the transaction
+     * @param amount - Amount of PT to sell
+     * @param minBaseOut - Minimum base asset to receive (slippage protection)
+     * @param lnImpliedApyLimit - Optional price limit (ln implied APY)
+     */
+    ixWrapperSellPt({ owner, amount, minBaseOut, tokenSyTrader: tokenSyTraderParam, tokenPtTrader: tokenPtTraderParam, tokenBaseTrader: tokenBaseTraderParam, lnImpliedApyLimit, }: {
+        owner: PublicKey;
+        amount: bigint;
+        minBaseOut: bigint;
+        tokenSyTrader?: PublicKey;
+        tokenPtTrader?: PublicKey;
+        tokenBaseTrader?: PublicKey;
+        lnImpliedApyLimit?: number;
+    }): Promise<{
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    }>;
+    /**
+     * Buy YT directly from the base asset.
+     *
+     * Wraps a mint-SY step with a buy-YT swap. The program mints SY from the base asset,
+     * then strips SY into PT+YT and executes the trade.
+     *
+     * @param owner - Wallet signing the transaction
+     * @param ytOut - Amount of YT to buy
+     * @param maxBaseIn - Maximum base asset to spend (slippage protection)
+     */
+    ixWrapperBuyYt({ owner, ytOut, maxBaseIn, tokenSyTrader: tokenSyTraderParam, tokenPtTrader: tokenPtTraderParam, tokenYtTrader: tokenYtTraderParam, tokenBaseTrader: tokenBaseTraderParam, }: {
+        owner: PublicKey;
+        ytOut: bigint;
+        maxBaseIn: bigint;
+        tokenSyTrader?: PublicKey;
+        tokenPtTrader?: PublicKey;
+        tokenYtTrader?: PublicKey;
+        tokenBaseTrader?: PublicKey;
+    }): Promise<{
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    }>;
+    /**
+     * Sell YT and receive the base asset.
+     *
+     * Wraps a YT -> SY swap with a redeem-SY step. The program merges YT+PT back into SY,
+     * executes the trade, then redeems SY for the base asset.
+     *
+     * @param owner - Wallet signing the transaction
+     * @param amount - Amount of YT to sell
+     * @param minBaseOut - Minimum base asset to receive (slippage protection)
+     */
+    ixWrapperSellYt({ owner, amount, minBaseOut, tokenBaseTrader: tokenBaseTraderParam, tokenSyTrader: tokenSyTraderParam, tokenYtTrader: tokenYtTraderParam, tokenPtTrader: tokenPtTraderParam, }: {
+        owner: PublicKey;
+        amount: bigint;
+        minBaseOut: bigint;
+        tokenBaseTrader?: PublicKey;
+        tokenSyTrader?: PublicKey;
+        tokenYtTrader?: PublicKey;
+        tokenPtTrader?: PublicKey;
+    }): Promise<{
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    }>;
+    /**
+     * Provide concentrated liquidity from the base asset, receiving LP and YT tokens.
+     *
+     * Wraps a mint-SY step with a deposit-liquidity operation. The program mints SY from the
+     * base asset, strips some into PT, deposits PT+SY as liquidity in the specified tick range,
+     * and returns the leftover YT to the depositor.
+     *
+     * @param depositor - Wallet signing the transaction
+     * @param amountBase - Amount of base asset to deposit
+     * @param minLpOut - Minimum LP tokens to receive (slippage protection)
+     * @param lowerTickApy - Lower APY bound for the liquidity range
+     * @param upperTickApy - Upper APY bound for the liquidity range
+     * @param lpPosition - Optional existing LP position keypair/address (new one generated if omitted)
+     */
+    ixWrapperProvideLiquidity({ depositor, amountBase, minLpOut, lowerTickApy, upperTickApy, tokenSyDepositor: tokenSyDepositorParam, tokenYtDepositor: tokenYtDepositorParam, tokenPtDepositor: tokenPtDepositorParam, tokenBaseDepositor: tokenBaseDepositorParam, lpPosition: lpPositionParam, }: {
+        depositor: PublicKey;
+        amountBase: bigint;
+        minLpOut: bigint;
+        lowerTickApy: number;
+        upperTickApy: number;
+        tokenSyDepositor?: PublicKey;
+        tokenYtDepositor?: PublicKey;
+        tokenPtDepositor?: PublicKey;
+        tokenBaseDepositor?: PublicKey;
+        lpPosition?: Keypair | PublicKey;
+    }): Promise<{
+        ixs: TransactionInstruction[];
+        signers: Keypair[];
+        setupIxs: TransactionInstruction[];
+    }>;
+    /**
+     * Provide concentrated liquidity from a base asset plus existing PT tokens ("classic" mode).
+     *
+     * Unlike {@link ixWrapperProvideLiquidity}, this allows the depositor to supply PT they already
+     * hold instead of having the program strip SY into PT+YT. Useful when the depositor has leftover
+     * PT from a previous trade or wants finer control over token composition.
+     *
+     * @param depositor - Wallet signing the transaction
+     * @param amountBase - Amount of base asset to deposit (converted to SY internally)
+     * @param amountPt - Amount of PT to deposit alongside the base asset
+     * @param minLpOut - Minimum LP tokens to receive (slippage protection)
+     * @param lowerTickApy - Lower APY bound for the liquidity range
+     * @param upperTickApy - Upper APY bound for the liquidity range
+     */
+    ixProvideLiquidityClassic({ depositor, amountBase, amountPt, minLpOut, lowerTickApy, upperTickApy, tokenSyDepositor: tokenSyDepositorParam, tokenYtDepositor: tokenYtDepositorParam, tokenPtDepositor: tokenPtDepositorParam, tokenBaseDepositor: tokenBaseDepositorParam, lpPositionParam, }: {
+        depositor: PublicKey;
+        amountBase: bigint;
+        amountPt: bigint;
+        minLpOut: bigint;
+        lowerTickApy: number;
+        upperTickApy: number;
+        tokenSyDepositor?: PublicKey;
+        tokenYtDepositor?: PublicKey;
+        tokenPtDepositor?: PublicKey;
+        tokenBaseDepositor?: PublicKey;
+        lpPositionParam?: Keypair | PublicKey;
+    }): Promise<{
+        ixs: TransactionInstruction[];
+        signers: Keypair[];
+        setupIxs: TransactionInstruction[];
+    }>;
+    ixProvideLiquidityBase({ depositor, externalPtToBuy, externalSyConstraint, minLpOut, lowerTickApy, upperTickApy, tokenSyDepositor: tokenSyDepositorParam, tokenYtDepositor: tokenYtDepositorParam, tokenPtDepositor: tokenPtDepositorParam, tokenBaseDepositor: tokenBaseDepositorParam, lpPositionParam, }: {
+        depositor: PublicKey;
+        externalPtToBuy: bigint;
+        externalSyConstraint: bigint;
+        minLpOut: bigint;
+        lowerTickApy: number;
+        upperTickApy: number;
+        tokenSyDepositor?: PublicKey;
+        tokenYtDepositor?: PublicKey;
+        tokenPtDepositor?: PublicKey;
+        tokenBaseDepositor?: PublicKey;
+        lpPositionParam?: Keypair | PublicKey;
+    }): Promise<{
+        ixs: TransactionInstruction[];
+        signers: Keypair[];
+        setupIxs: TransactionInstruction[];
+    }>;
+    ixWithdrawLiquidityToBase({ owner, amountLp, minBaseOut, lpPosition, tokenSyWithdrawer: tokenSyWithdrawerParam, tokenYtWithdrawer: tokenYtWithdrawerParam, tokenPtWithdrawer: tokenPtWithdrawerParam, tokenBaseWithdrawer: tokenBaseWithdrawerParam, }: {
+        owner: PublicKey;
+        amountLp: bigint;
+        minBaseOut: bigint;
+        lpPosition: PublicKey;
+        tokenSyWithdrawer?: PublicKey;
+        tokenYtWithdrawer?: PublicKey;
+        tokenPtWithdrawer?: PublicKey;
+        tokenBaseWithdrawer?: PublicKey;
+    }): Promise<{
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    }>;
+    ixWithdrawLiquidityClassic({ owner, amountLp, lpPosition, tokenSyWithdrawer: tokenSyWithdrawerParam, tokenYtWithdrawer: tokenYtWithdrawerParam, tokenPtWithdrawer: tokenPtWithdrawerParam, tokenBaseWithdrawer: tokenBaseWithdrawerParam, }: {
+        owner: PublicKey;
+        amountLp: bigint;
+        lpPosition: PublicKey;
+        tokenSyWithdrawer?: PublicKey;
+        tokenYtWithdrawer?: PublicKey;
+        tokenPtWithdrawer?: PublicKey;
+        tokenBaseWithdrawer?: PublicKey;
+    }): Promise<{
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    }>;
+    ixAddLiquidity({ owner, ptInIntent, syInIntent, tokenSyDepositor: tokenSyDepositorParam, tokenYtDepositor: tokenYtDepositorParam, tokenPtDepositor: tokenPtDepositorParam, tokenBaseDepositor: tokenBaseDepositorParam, lpPosition, }: {
+        owner: PublicKey;
+        /** Intended (maximum) amount of PT in */
+        ptInIntent: bigint;
+        /** Intended (maximum) amount of SY in */
+        syInIntent: bigint;
+        tokenSyDepositor?: PublicKey;
+        tokenYtDepositor?: PublicKey;
+        tokenPtDepositor?: PublicKey;
+        tokenBaseDepositor?: PublicKey;
+        lpPosition: PublicKey;
+    }): Promise<{
+        ixs: TransactionInstruction[];
+        signers: (PublicKey & Keypair)[];
+        setupIxs: TransactionInstruction[];
+    }>;
+    getUserLpPositions(owner: PublicKey, market: PublicKey): Promise<{
+        lpPositions: {
+            publicKey: PublicKey;
+            account: exponentClmm.LpPositionAccountData;
+        }[][];
+    }>;
+    ixMarketAccureEmissions({ owner, lpPosition }: {
+        owner: PublicKey;
+        lpPosition: PublicKey;
+    }): {
+        ixs: TransactionInstruction[];
+    };
+    /**
+     * Calculate the current price per unit of liquidity (principal only) for a tick range.
+     * Mirrors the on-chain `liquidity_unit_price_in_asset` helper but performs the
+     * principal aggregation client-side using the fetched ticks account.
+     *
+     * @param lowerTickKey - Inclusive tick key (APY in parts-per-million) for the left boundary
+     * @param upperTickKey - Exclusive tick key for the right boundary
+     * @param ticksOverride - Optional ticks account (defaults to the instance state)
+     * @param syExchangeRateOverride - Optional SY exchange rate (defaults to current flavor rate)
+     * @returns Price per unit of liquidity in underlying asset terms (principal only)
+     */
+    liquidityUnitPriceInAsset({ lowerTickKey, upperTickKey, ticksOverride, syExchangeRateOverride, }: {
+        lowerTickKey: number;
+        upperTickKey: number;
+        ticksOverride?: Ticks;
+        syExchangeRateOverride?: number;
+    }): number;
+    /**
+     * Compute fee growth inside a tick range using Uniswap V3 formula
+     *
+     * @param lowerTick - Lower tick boundary
+     * @param upperTick - Upper tick boundary
+     * @param feeGlobalPt - Optional: Override global PT fees (for historical calculations)
+     * @param feeGlobalSy - Optional: Override global SY fees (for historical calculations)
+     * @returns Object with inside_sy and inside_pt fee growth values
+     */
+    static computeFeeInsideForRange({ currentTickPrice, lowerTickPrice, upperTickPrice, feeGrowthIndexGlobalPt, feeGrowthIndexGlobalSy, lowerTickOutsidePt, lowerTickOutsideSy, upperTickOutsidePt, upperTickOutsideSy, }: {
+        currentTickPrice: number;
+        lowerTickPrice: number;
+        upperTickPrice: number;
+        feeGrowthIndexGlobalPt: bigint;
+        feeGrowthIndexGlobalSy: bigint;
+        lowerTickOutsidePt: bigint;
+        lowerTickOutsideSy: bigint;
+        upperTickOutsidePt: bigint;
+        upperTickOutsideSy: bigint;
+    }): {
+        insideSy: bigint;
+        insidePt: bigint;
+    };
+    /**
+     * Calculate claimable fees for a position
+     * Uses Q64.64 fixed-point math: tokens = floor((L * Δindex) >> 64)
+     *
+     * @param lpBalance - Position's liquidity balance
+     * @param feeInsideLastSy - Last snapshot of inside SY fee growth
+     * @param feeInsideLastPt - Last snapshot of inside PT fee growth
+     * @param currentInsideSy - Current inside SY fee growth
+     * @param currentInsidePt - Current inside PT fee growth
+     * @param tokensOwedSy - Previously owed SY fees
+     * @param tokensOwedPt - Previously owed PT fees
+     * @returns Object with claimable and total fees
+     */
+    static calculateClaimableFees({ lpBalance, feeInsideLastSy, feeInsideLastPt, currentInsideSy, currentInsidePt, tokensOwedSy, tokensOwedPt, }: {
+        lpBalance: bigint;
+        feeInsideLastSy: bigint;
+        feeInsideLastPt: bigint;
+        currentInsideSy: bigint;
+        currentInsidePt: bigint;
+        tokensOwedSy: bigint;
+        tokensOwedPt: bigint;
+    }): {
+        claimableSy: bigint;
+        claimablePt: bigint;
+        tokensOwedSy: bigint;
+        tokensOwedPt: bigint;
+        totalSy: bigint;
+        totalPt: bigint;
+    };
+    /**
+     * Calculate historical fee APY for a tick range
+     *
+     * @param feeGrowthDeltaSy - Change in global SY fee growth over period
+     * @param feeGrowthDeltaPt - Change in global PT fee growth over period
+     * @param avgLiquidity - Average liquidity in the range during period
+     * @param hoursElapsed - Number of hours in the period
+     * @returns Object with fee APY metrics
+     */
+    static calculateHistoricalFeeApy({ feeGrowthDeltaSy, feeGrowthDeltaPt, avgLiquidity, hoursElapsed, }: {
+        feeGrowthDeltaSy: bigint;
+        feeGrowthDeltaPt: bigint;
+        avgLiquidity: bigint;
+        hoursElapsed: number;
+    }): {
+        feeApySy: number;
+        feeApyPt: number;
+        feeApyTotal: number;
+        totalFeesSy: bigint;
+        totalFeesPt: bigint;
+    };
+    depositYtAccounts({ owner, ytSrc: ytSrcParam, }: {
+        owner: PublicKey;
+        ytSrc?: PublicKey;
+    }): TransactionInstruction;
+    withdrawYtAccounts({ owner, ytDst: ytDstParam, }: {
+        owner: PublicKey;
+        ytDst?: PublicKey;
+    }): TransactionInstruction;
+    /**
+     * Estimate the yield (fees + emissions) a hypothetical LP position would have earned
+     * between two market snapshots.
+     *
+     * @param marketSnapshotDataCurrent - The more recent market snapshot
+     * @param marketSnapshotDataHistory - The older market snapshot (defines the look-back window)
+     * @param lowerPricePercentage - Lower price bound as a percentage (e.g. 5 for 5%)
+     * @param upperPricePercentage - Upper price bound as a percentage
+     * @param baseTokenAmount - Amount of base tokens in the hypothetical position
+     */
+    static calcEstimatedYieldForPosition(marketSnapshotDataCurrent: MarketSnapshotData, marketSnapshotDataHistory: MarketSnapshotData, lowerPricePercentage: number, upperPricePercentage: number, baseTokenAmount: number): {
+        totalFeeRate: number;
+        ptExpectedFees: bigint;
+        syExpectedFees: bigint;
+        expectedFeesBaseToken: number;
+    };
+    /**
+     * Calculate TVL (Total Value Locked) in baseToken for a market
+     *
+     * @param currentSpotPrice - Current spot price in format of 1 + percentage / 100
+     * @param financials - Market financials containing balances and expiration timestamp
+     * @param syExchangeRate - SY exchange rate
+     * @param timestampUnix - Timestamp in seconds (defaults to current time)
+     * @returns Object with TVL breakdown: total TVL, PT liquidity, and SY liquidity in baseToken
+     */
+    static calcTvlInBaseToken(params: {
+        financials: MarketThreeFinancials;
+        currentSpotPrice: number;
+        syExchangeRate: number;
+        timestampUnix?: number;
+    }): {
+        tvlInBaseToken: number;
+        ptLiquidityInBaseToken: number;
+        syLiquidityInBaseToken: number;
+    };
+    static calcGlobalFeeRate(marketSnapshotDataCurrent: MarketSnapshotData, marketSnapshotDataHistory: MarketSnapshotData): {
+        totalFeeRate: number;
+        totalFeesInBaseToken: number;
+        tvlInBaseToken: number;
+    };
+    /**
+     * Returns PT and SY amounts that will be received on liquidity removal from a position
+     * If liquidityToRemove is not provided, assume that the full position balance will be removed
+     */
+    getPtAndSyOnWithdrawLiquidity(position: LpPositionCLMM, liquidityToRemove?: bigint): {
+        totalPtOut: bigint;
+        totalSyOut: bigint;
+    };
+}
+/** Market snapshot data for CLMM market */
+export type MarketSnapshotData = {
+    syExchangeRate: number;
+    /** Current spot price in format of 1 + percentage / 100 */
+    currentSpotPrice: number;
+    financials: MarketThreeFinancials;
+    feeGrowthIndexGlobalPt: bigint;
+    feeGrowthIndexGlobalSy: bigint;
+    currentPrefixSum: bigint;
+    snapshotTimeUnix: number;
+};