@exponent-labs/exponent-sdk 0.1.6 → 0.1.8

package/build/marketThree.d.ts

@@ -0,0 +1,664 @@
+/// <reference types="bn.js" />
+import { BN, Program, web3 } from "@coral-xyz/anchor";
+import { ExponentClmm } from "@exponent-labs/exponent-clmm-idl";
+import { ExponentCLMMPDA } from "@exponent-labs/exponent-clmm-pda";
+import { LiquidityNetBalanceLimits, LpFarm, LpPositionCLMM, MarketConfigurationOptions, MarketThreeFinancials, Ticks } from "@exponent-labs/exponent-fetcher";
+import { ExponentCore } from "@exponent-labs/exponent-idl";
+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";
+export { LiquidityAdd };
+interface Emission {
+    /** Token account that holds emission tokens */
+    escrowAccountAddress: web3.PublicKey;
+    /** Mint for the emission token */
+    mint: web3.PublicKey;
+    /** Token program ID for the emission token */
+    tokenProgramAddress: web3.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 = {
+    setStatus: [number];
+} | {
+    setMaxLpSupply: [BN];
+} | {
+    changeTreasuryTradeSyBpsFee: [number];
+} | {
+    changeLnFeeRateRoot: [number];
+} | {
+    changeLiquidityNetBalanceLimits: {
+        maxNetBalanceChangeNegativePercentage: number;
+        maxNetBalanceChangePositivePercentage: number;
+        windowDurationSeconds: number;
+    };
+} | {
+    changeEpsilonClamp: [number];
+} | {
+    changeMinLpTickAmount: [BN];
+} | {
+    changeTickSpace: [number];
+};
+export type SwapDirection = {
+    ptToSy: {};
+} | {
+    syToPt: {};
+};
+interface MarketThreeLoadOptions {
+    syConfig?: {
+        skipWrap?: boolean;
+    };
+}
+type MarketThreeArgs = {
+    admin: web3.PublicKey;
+    addressLookupTable: web3.PublicKey;
+    mintPt: web3.PublicKey;
+    mintYt: web3.PublicKey;
+    mintSy: web3.PublicKey;
+    vault: Vault;
+    tokenPtEscrow: web3.PublicKey;
+    tokenSyEscrow: web3.PublicKey;
+    tokenYtEscrow: web3.PublicKey;
+    tokenFeeTreasurySy: web3.PublicKey;
+    tokenFeeTreasuryPt: web3.PublicKey;
+    syProgram: web3.PublicKey;
+    exponentCoreProgram: web3.PublicKey;
+    selfAddress: web3.PublicKey;
+    statusFlags: number;
+    configurationOptions: MarketConfigurationOptions;
+    financials: MarketThreeFinancials;
+    cpiSyAccounts: CpiAccountsRaw;
+    cpiCoreAccounts: ExponentCoreCpiAccountsRaw;
+    isCurrentFlashSwap: boolean;
+    lpFarm: LpFarm;
+    flavor: Flavor;
+    emissions: {
+        trackers: {
+            tokenEscrow: web3.PublicKey;
+            lpShareIndex: number;
+            lastSeenStaged: number;
+        }[];
+    };
+    liquidityNetBalanceLimits: LiquidityNetBalanceLimits;
+    ticksAccount: web3.PublicKey;
+    ticks: Ticks;
+    syPosition: SyPosition;
+    treasuryFeeOwner: web3.PublicKey;
+};
+export declare class MarketThree {
+    state: MarketThreeArgs;
+    selfAddress: web3.PublicKey;
+    env: Environment;
+    connection: web3.Connection;
+    clmmProgram: Program<ExponentClmm>;
+    coreProgram: Program<ExponentCore>;
+    xponPda: ExponentPDA;
+    pda: ExponentCLMMPDA;
+    constructor(state: MarketThreeArgs, selfAddress: web3.PublicKey, env: Environment, connection: web3.Connection);
+    static load(env: Environment, connection: web3.Connection, address: web3.PublicKey, vault?: Vault, ticks?: Ticks, options?: MarketThreeLoadOptions): Promise<MarketThree>;
+    reload(connection?: web3.Connection): Promise<MarketThree>;
+    get vault(): Vault;
+    get flavor(): Flavor;
+    get lpBalance(): bigint;
+    get syBalance(): bigint;
+    get ptBalance(): bigint;
+    get mintSy(): web3.PublicKey;
+    get mintPt(): web3.PublicKey;
+    get statusFlags(): number;
+    get mintYt(): web3.PublicKey;
+    get addressLookupTable(): web3.PublicKey;
+    get syProgram(): web3.PublicKey;
+    get cpiSyAccounts(): CpiAccountsRaw;
+    get cpiCoreAccounts(): ExponentCoreCpiAccountsRaw;
+    get marketEmissions(): {
+        trackers: {
+            tokenEscrow: web3.PublicKey;
+            lpShareIndex: number;
+            lastSeenStaged: number;
+        }[];
+    };
+    get ticksKey(): web3.PublicKey;
+    get corePda(): ExponentPDA;
+    get coreEventAuthority(): web3.PublicKey;
+    get emissions(): Emission[];
+    /** Get the escrow token account addresses for the emissions, in order */
+    get emissionTokenAccounts(): web3.PublicKey[];
+    /** Pass-through SY account owned by the market */
+    get tokenSyEscrow(): web3.PublicKey;
+    /** Pass-through YT account owned by the market */
+    get tokenYtEscrow(): web3.PublicKey;
+    /** SY account that holds treasury SY fees from PT trading */
+    get tokenFeeTreasurySy(): web3.PublicKey;
+    /** PT account that holds treasury PT fees from PT trading */
+    get tokenFeeTreasuryPt(): web3.PublicKey;
+    /** Market liquidity for PT */
+    get tokenPtEscrow(): web3.PublicKey;
+    get currentSyExchangeRate(): number;
+    /** Special account for event emit self-cpi */
+    get eventAuthority(): web3.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: web3.PublicKey, connection: web3.Connection): Promise<web3.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: web3.PublicKey;
+        ptSrc?: web3.PublicKey;
+        sySrc?: web3.PublicKey;
+        lpPosition?: web3.Keypair;
+    }): Promise<{
+        ix: web3.TransactionInstruction;
+        signers: web3.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: web3.PublicKey;
+        lpPosition: web3.PublicKey;
+        minPtOut: bigint;
+        minSyOut: bigint;
+        ptDst?: web3.PublicKey;
+        syDst?: web3.PublicKey;
+        lnImpliedApyLimit?: number;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixTradePt({ trader, traderAmount, outConstraint, swapDirection, tokenPt: tokenPtParam, tokenSy: tokenSyParam, lnImpliedApyLimit, }: {
+        trader: web3.PublicKey;
+        traderAmount: bigint;
+        outConstraint: bigint;
+        swapDirection: SwapDirection;
+        tokenPt?: web3.PublicKey;
+        tokenSy?: web3.PublicKey;
+        lnImpliedApyLimit?: number;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixTradePtExactOut({ trader, amountOut, swapDirection, amountInConstraint, tokenPt: tokenPtParam, tokenSy: tokenSyParam, lnImpliedApyLimit, }: {
+        trader: web3.PublicKey;
+        amountOut: bigint;
+        swapDirection: SwapDirection;
+        amountInConstraint?: bigint;
+        tokenPt?: web3.PublicKey;
+        tokenSy?: web3.PublicKey;
+        lnImpliedApyLimit?: number;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.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: web3.PublicKey;
+        amountSy: bigint;
+        outConstraint: bigint;
+        tokenPt?: web3.PublicKey;
+        tokenSy?: web3.PublicKey;
+        lnImpliedApyLimit?: number;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.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: web3.PublicKey;
+        amountPt: bigint;
+        outConstraint: bigint;
+        tokenPt?: web3.PublicKey;
+        tokenSy?: web3.PublicKey;
+        lnImpliedApyLimit?: number;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.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: web3.PublicKey;
+        amountPt: bigint;
+        maxSyIn?: bigint;
+        tokenPt?: web3.PublicKey;
+        tokenSy?: web3.PublicKey;
+        lnImpliedApyLimit?: number;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.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: web3.PublicKey;
+        amountSy: bigint;
+        maxPtIn?: bigint;
+        tokenPt?: web3.PublicKey;
+        tokenSy?: web3.PublicKey;
+        lnImpliedApyLimit?: number;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.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: web3.PublicKey;
+        ytOut: bigint;
+        maxSyIn: bigint;
+        ytTrader?: web3.PublicKey;
+        ptTrader?: web3.PublicKey;
+        syTrader?: web3.PublicKey;
+        lnImpliedApyLimit?: number;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.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: web3.PublicKey;
+        ytIn: bigint;
+        minSyOut: bigint;
+        ytSrc?: web3.PublicKey;
+        ptSrc?: web3.PublicKey;
+        syDst?: web3.PublicKey;
+        lnImpliedApyLimit?: number;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixModifyMarketSetting({ signer, adminAction }: {
+        signer: web3.PublicKey;
+        adminAction: MarketAdminAction;
+    }): Promise<web3.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: web3.PublicKey;
+        farmMint: web3.PublicKey;
+        farmTokenProgram: web3.PublicKey;
+        emissionsRate: bigint;
+        untilTimestamp: number;
+        farmTokenSrc?: web3.PublicKey;
+        feePayer?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.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: web3.PublicKey;
+        farmMint: web3.PublicKey;
+        farmTokenProgram: web3.PublicKey;
+        newRate: bigint;
+        untilTimestamp: number;
+        farmTokenSrc?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+    }>;
+    ixWrapperBuyPt({ owner, minPtOut, baseIn, tokenSyTrader: tokenSyTraderParam, tokenPtTrader: tokenPtTraderParam, tokenBaseTrader: tokenBaseTraderParam, lnImpliedApyLimit, }: {
+        owner: web3.PublicKey;
+        minPtOut: bigint;
+        baseIn: bigint;
+        tokenSyTrader?: web3.PublicKey;
+        tokenPtTrader?: web3.PublicKey;
+        tokenBaseTrader?: web3.PublicKey;
+        lnImpliedApyLimit?: number;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixWrapperSellPt({ owner, amount, minBaseOut, tokenSyTrader: tokenSyTraderParam, tokenPtTrader: tokenPtTraderParam, tokenBaseTrader: tokenBaseTraderParam, lnImpliedApyLimit, }: {
+        owner: web3.PublicKey;
+        amount: bigint;
+        minBaseOut: bigint;
+        tokenSyTrader?: web3.PublicKey;
+        tokenPtTrader?: web3.PublicKey;
+        tokenBaseTrader?: web3.PublicKey;
+        lnImpliedApyLimit?: number;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixWrapperBuyYt({ owner, ytOut, maxBaseIn, tokenSyTrader: tokenSyTraderParam, tokenPtTrader: tokenPtTraderParam, tokenYtTrader: tokenYtTraderParam, tokenBaseTrader: tokenBaseTraderParam, }: {
+        owner: web3.PublicKey;
+        ytOut: bigint;
+        maxBaseIn: bigint;
+        tokenSyTrader?: web3.PublicKey;
+        tokenPtTrader?: web3.PublicKey;
+        tokenYtTrader?: web3.PublicKey;
+        tokenBaseTrader?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixWrapperSellYt({ owner, amount, minBaseOut, tokenBaseTrader: tokenBaseTraderParam, tokenSyTrader: tokenSyTraderParam, tokenYtTrader: tokenYtTraderParam, tokenPtTrader: tokenPtTraderParam, }: {
+        owner: web3.PublicKey;
+        amount: bigint;
+        minBaseOut: bigint;
+        tokenBaseTrader?: web3.PublicKey;
+        tokenSyTrader?: web3.PublicKey;
+        tokenYtTrader?: web3.PublicKey;
+        tokenPtTrader?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    /** Provide liquidity from a base asset - and receive YT and LP tokens in return */
+    ixWrapperProvideLiquidity({ depositor, amountBase, minLpOut, lowerTickApy, upperTickApy, tokenSyDepositor: tokenSyDepositorParam, tokenYtDepositor: tokenYtDepositorParam, tokenPtDepositor: tokenPtDepositorParam, tokenBaseDepositor: tokenBaseDepositorParam, lpPosition: lpPositionParam, }: {
+        depositor: web3.PublicKey;
+        amountBase: bigint;
+        minLpOut: bigint;
+        lowerTickApy: number;
+        upperTickApy: number;
+        tokenSyDepositor?: web3.PublicKey;
+        tokenYtDepositor?: web3.PublicKey;
+        tokenPtDepositor?: web3.PublicKey;
+        tokenBaseDepositor?: web3.PublicKey;
+        lpPosition?: web3.Keypair;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        signers: web3.Keypair[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixProvideLiquidityClassic({ depositor, amountBase, amountPt, minLpOut, lowerTickApy, upperTickApy, tokenSyDepositor: tokenSyDepositorParam, tokenYtDepositor: tokenYtDepositorParam, tokenPtDepositor: tokenPtDepositorParam, tokenBaseDepositor: tokenBaseDepositorParam, }: {
+        depositor: web3.PublicKey;
+        amountBase: bigint;
+        amountPt: bigint;
+        minLpOut: bigint;
+        lowerTickApy: number;
+        upperTickApy: number;
+        tokenSyDepositor?: web3.PublicKey;
+        tokenYtDepositor?: web3.PublicKey;
+        tokenPtDepositor?: web3.PublicKey;
+        tokenBaseDepositor?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        signers: web3.Keypair[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixWithdrawLiquidityToBase({ owner, amountLp, minBaseOut, lpPosition, tokenSyWithdrawer: tokenSyWithdrawerParam, tokenYtWithdrawer: tokenYtWithdrawerParam, tokenPtWithdrawer: tokenPtWithdrawerParam, tokenBaseWithdrawer: tokenBaseWithdrawerParam, }: {
+        owner: web3.PublicKey;
+        amountLp: bigint;
+        minBaseOut: bigint;
+        lpPosition: web3.PublicKey;
+        tokenSyWithdrawer?: web3.PublicKey;
+        tokenYtWithdrawer?: web3.PublicKey;
+        tokenPtWithdrawer?: web3.PublicKey;
+        tokenBaseWithdrawer?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixWithdrawLiquidityClassic({ owner, amountLp, lpPosition, tokenSyWithdrawer: tokenSyWithdrawerParam, tokenYtWithdrawer: tokenYtWithdrawerParam, tokenPtWithdrawer: tokenPtWithdrawerParam, tokenBaseWithdrawer: tokenBaseWithdrawerParam, }: {
+        owner: web3.PublicKey;
+        amountLp: bigint;
+        lpPosition: web3.PublicKey;
+        tokenSyWithdrawer?: web3.PublicKey;
+        tokenYtWithdrawer?: web3.PublicKey;
+        tokenPtWithdrawer?: web3.PublicKey;
+        tokenBaseWithdrawer?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    getUserLpPositions(owner: web3.PublicKey, market: web3.PublicKey): Promise<{
+        lpPositions: import("@coral-xyz/anchor").ProgramAccount<{
+            owner: web3.PublicKey;
+            market: web3.PublicKey;
+            feeInsideLastPt: BN;
+            feeInsideLastSy: BN;
+            lpBalance: BN;
+            tokensOwedSy: BN;
+            tokensOwedPt: BN;
+            lowerTickIdx: number;
+            upperTickIdx: number;
+            farms: {
+                trackers: {
+                    lastSeenIndex: {
+                        0: BN[];
+                    };
+                    staged: BN;
+                }[];
+            };
+            shareTrackers: {
+                trackers: {
+                    tickIdx: number;
+                    rightTickIdx: number;
+                    splitEpoch: BN;
+                    lpShare: BN;
+                    emissions: {
+                        trackers: {
+                            lastSeenIndex: unknown;
+                            staged: BN;
+                        }[];
+                    };
+                }[];
+            };
+        }>[][];
+    }>;
+    ixMarketAccureEmissions({ owner, lpPosition }: {
+        owner: web3.PublicKey;
+        lpPosition: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.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: web3.PublicKey;
+        ytSrc?: web3.PublicKey;
+    }): Promise<web3.TransactionInstruction>;
+    static calcEstimatedYieldForPosition(marketSnapshotDataCurrent: MarketSnapshotData, marketSnapshotDataHistory: MarketSnapshotData, lowerPricePercentage: number, upperPricePercentage: number, baseTokenAmount: number): {
+        totalFeeRate: number;
+        ptExpectedFees: bigint;
+        syExpectedFees: bigint;
+        expectedFeesBaseToken: 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;
+};