@exponent-labs/exponent-sdk 0.0.3

package/build/market.d.ts

@@ -0,0 +1,567 @@
+/// <reference types="bn.js" />
+import { Program, Wallet, web3 } from "@coral-xyz/anchor";
+import { LiquidityNetBalanceLimits, LpFarm } from "@exponent-labs/exponent-fetcher";
+import { ExponentIx } from "@exponent-labs/exponent-ix";
+import { Environment } from "./environment";
+import { ExponentCore } from "@exponent-labs/exponent-idl";
+import { BN } from "@coral-xyz/anchor";
+import { ExponentPDA } from "@exponent-labs/exponent-pda";
+import { Vault } from "./vault";
+import { LiquidityAdd, MarketCalculator } from "@exponent-labs/market-math";
+import { CpiAccountsRaw, Flavor, SyPosition } from "@exponent-labs/exponent-types";
+import { AnchorizedPNum } from "@exponent-labs/exponent-types";
+import { CpiAccountsRawJson } from "@exponent-labs/exponent-types";
+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];
+} | {
+    changeLnFeeRateRoot: [number];
+} | {
+    changeRateScalarRoot: [number];
+} | {
+    changeLiquidityNetBalanceLimits: {
+        maxNetBalanceChangeNegativePercentage: number;
+        maxNetBalanceChangePositivePercentage: number;
+        windowDurationSeconds: number;
+    };
+} | {
+    removeMarketEmission: [number];
+};
+type MarketArgs = {
+    ptBalance: bigint;
+    syBalance: bigint;
+    lpSupply: bigint;
+    sySupply: bigint;
+    lpEscrowAmount: bigint;
+    maxLpSupply: bigint;
+    rateScalarRoot: number;
+    lnFeeRateRoot: number;
+    lastLnImpliedRate: number;
+    expirationTs: number;
+    addressLookupTable: web3.PublicKey;
+    mintSy: web3.PublicKey;
+    mintPt: web3.PublicKey;
+    vault: Vault;
+    mintLp: web3.PublicKey;
+    tokenPtEscrow: web3.PublicKey;
+    tokenSyEscrow: web3.PublicKey;
+    tokenLpEscrow: web3.PublicKey;
+    syProgram: web3.PublicKey;
+    statusFlags: number;
+    cpiAccounts: CpiAccountsRaw;
+    feeTreasurySyBps: number;
+    tokenFeeTreasurySy: web3.PublicKey;
+    isCurrentFlashSwap: boolean;
+    lpFarm: LpFarm;
+    flavor: Flavor;
+    liquidityNetBalanceLimits: LiquidityNetBalanceLimits;
+    syPosition: SyPosition;
+    emissions: {
+        trackers: {
+            tokenEscrow: web3.PublicKey;
+            lpShareIndex: number;
+            lastSeenStaged: number;
+        }[];
+    };
+};
+export declare class MyWallet implements Wallet {
+    readonly payer: web3.Keypair;
+    constructor(payer: web3.Keypair);
+    signTransaction<T extends web3.Transaction | web3.VersionedTransaction>(tx: T): Promise<T>;
+    signAllTransactions<T extends web3.Transaction | web3.VersionedTransaction>(txs: T[]): Promise<T[]>;
+    get publicKey(): web3.PublicKey;
+}
+export declare class Market {
+    state: MarketArgs;
+    selfAddress: web3.PublicKey;
+    env: Environment;
+    connection: web3.Connection;
+    coreProgram: Program<ExponentCore>;
+    xponIx: ExponentIx;
+    xponPda: ExponentPDA;
+    constructor(state: MarketArgs, selfAddress: web3.PublicKey, env: Environment, connection: web3.Connection);
+    static load(env: Environment, connection: web3.Connection, address: web3.PublicKey, vault?: Vault): Promise<Market>;
+    reload(conn?: web3.Connection): Promise<Market>;
+    /** Convert to a JSON representation */
+    toJson(): MarketJson;
+    get vault(): Vault;
+    get flavor(): Flavor;
+    get lpSupply(): bigint;
+    get syBalance(): bigint;
+    get ptBalance(): bigint;
+    get mintSy(): web3.PublicKey;
+    get mintPt(): web3.PublicKey;
+    get statusFlags(): number;
+    get mintYt(): web3.PublicKey;
+    get mintLp(): web3.PublicKey;
+    get addressLookupTable(): web3.PublicKey;
+    get syProgram(): web3.PublicKey;
+    get cpiAccounts(): CpiAccountsRaw;
+    get marketEmissions(): {
+        trackers: {
+            tokenEscrow: web3.PublicKey;
+            lpShareIndex: number;
+            lastSeenStaged: number;
+        }[];
+    };
+    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;
+    /** SY account that holds treasury SY fees from PT trading */
+    get tokenFeeTreasurySy(): web3.PublicKey;
+    /** Market liquidity for PT */
+    get tokenPtEscrow(): web3.PublicKey;
+    get tokenLpEscrow(): web3.PublicKey;
+    get currentSyExchangeRate(): number;
+    /** Special account for event emit self-cpi */
+    get eventAuthority(): web3.PublicKey;
+    get currentPtPriceInSy(): number;
+    get currentPtPriceInAsset(): number;
+    get ptDiscount(): number;
+    get lpPriceInAsset(): number;
+    get secondsRemaining(): number;
+    get absolutePtYield(): number;
+    /** Annualize a rate given the number of seconds remaining until maturity */
+    static annualize(r: number, secondsRemaining: number): number;
+    /** Annualized PT fixed rate */
+    get ptApr(): number;
+    /** The fee rate taken off of trade fees (typically around 20%) expressed as a BPS number */
+    get feeTreasuryBps(): number;
+    /** The fee rate on assets when trading PT
+     * Expressed as a rational number
+     * eg 0.01 = 1%
+     */
+    get feeRatePtTrade(): number;
+    /** The fee rate taken off of trade fees (typically around 20%) expressed as a rational number */
+    get feeTreasuryRate(): number;
+    /** Calculate amonut of LP tokens to expect for tokens in */
+    lpOutForTokensIn(syInIntent: bigint, ptInIntent: bigint): LiquidityAdd;
+    marketCalculator(): MarketCalculator;
+    /** 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, minLpOut, depositor, ptSrc, sySrc, lpDst, }: {
+        /** Intended (maximum) amount of PT in */
+        ptInIntent: bigint;
+        /** Intended (maximum) amount of SY in */
+        syInIntent: bigint;
+        /** Minimum LP tokens out */
+        minLpOut: bigint;
+        depositor: web3.PublicKey;
+        ptSrc?: web3.PublicKey;
+        sySrc?: web3.PublicKey;
+        lpDst?: web3.PublicKey;
+    }): Promise<web3.TransactionInstruction>;
+    ixModifyMarketSetting({ signer, adminAction }: {
+        signer: web3.PublicKey;
+        adminAction: MarketAdminAction;
+    }): Promise<web3.TransactionInstruction>;
+    ixModifyFarm({ newRate, untilTimestamp, signer, farmMint, farmTokenProgram, farmTokenSrc, }: {
+        newRate: bigint;
+        untilTimestamp: number;
+        signer: web3.PublicKey;
+        farmMint: web3.PublicKey;
+        farmTokenProgram: web3.PublicKey;
+        farmTokenSrc?: web3.PublicKey;
+    }): Promise<web3.TransactionInstruction>;
+    /**
+     * 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, minPtOut, minSyOut, ptDst, syDst, lpSrc, }: {
+        lpIn: bigint;
+        withdrawer: web3.PublicKey;
+        minPtOut: bigint;
+        minSyOut: bigint;
+        ptDst?: web3.PublicKey;
+        syDst?: web3.PublicKey;
+        lpSrc?: web3.PublicKey;
+    }): 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, amountPt, maxSySpend, tokenPt, tokenSy, }: {
+        trader: web3.PublicKey;
+        amountPt: bigint;
+        maxSySpend: bigint;
+        tokenPt?: web3.PublicKey;
+        tokenSy?: web3.PublicKey;
+    }): 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, minSyReceive, tokenPt, tokenSy, }: {
+        trader: web3.PublicKey;
+        amountPt: bigint;
+        minSyReceive: bigint;
+        tokenPt?: web3.PublicKey;
+        tokenSy?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixTradePt({ trader, traderPt, syConstraint, isBuy, tokenPt, tokenSy, }: {
+        trader: web3.PublicKey;
+        traderPt: bigint;
+        syConstraint: bigint;
+        isBuy: boolean;
+        tokenPt?: web3.PublicKey;
+        tokenSy?: web3.PublicKey;
+    }): 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, ptSrc, syDst, }: {
+        trader: web3.PublicKey;
+        ytIn: bigint;
+        minSyOut: bigint;
+        ytSrc?: web3.PublicKey;
+        ptSrc?: web3.PublicKey;
+        syDst?: web3.PublicKey;
+    }): 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, ptTrader, syTrader, }: {
+        trader: web3.PublicKey;
+        ytOut: bigint;
+        maxSyIn: bigint;
+        ytTrader?: web3.PublicKey;
+        ptTrader?: web3.PublicKey;
+        syTrader?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixInitLpPosition({ owner, feePayer }: {
+        owner: web3.PublicKey;
+        feePayer?: web3.PublicKey;
+    }): Promise<web3.TransactionInstruction>;
+    /** Deposit LP tokens into the farming module to earn rewards */
+    ixDepositLp({ owner, amount, lpSrc }: {
+        owner: web3.PublicKey;
+        amount: bigint;
+        lpSrc?: web3.PublicKey;
+    }): Promise<web3.TransactionInstruction>;
+    /** Withdraw LP tokens from the farming module */
+    ixWithdrawLp({ owner, amount, lpDst }: {
+        owner: web3.PublicKey;
+        amount: bigint;
+        lpDst?: web3.PublicKey;
+    }): Promise<web3.TransactionInstruction>;
+    ixWrapperCollectInterest({ claimer, tokenSyDst }: {
+        claimer: web3.PublicKey;
+        tokenSyDst?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixWrapperBuyPt({ owner, ptOut, maxBaseIn, tokenSyTrader, tokenPtTrader, tokenBaseTrader, }: {
+        owner: web3.PublicKey;
+        ptOut: bigint;
+        maxBaseIn: bigint;
+        tokenSyTrader?: web3.PublicKey;
+        tokenPtTrader?: web3.PublicKey;
+        tokenBaseTrader?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixWrapperSellPt({ owner, amount, minBaseOut, tokenSyTrader, tokenPtTrader, tokenBaseTrader, }: {
+        owner: web3.PublicKey;
+        amount: bigint;
+        minBaseOut: bigint;
+        tokenSyTrader?: web3.PublicKey;
+        tokenPtTrader?: web3.PublicKey;
+        tokenBaseTrader?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixWrapperBuyYt({ owner, ytOut, maxBaseIn, tokenSyTrader, tokenPtTrader, tokenYtTrader, tokenBaseTrader, }: {
+        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, tokenSyTrader, tokenYtTrader, tokenPtTrader, }: {
+        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[];
+    }>;
+    ixCollectMarketEmission({ owner, emissionIndex, emissionDst, }: {
+        owner: web3.PublicKey;
+        emissionIndex: number;
+        emissionDst?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    /** Provide liquidity from a base asset - and receive YT and LP tokens in return */
+    ixProvideLiquidityNoPriceImpact({ depositor, amountBase, minLpOut, tokenSyDepositor, tokenYtDepositor, tokenPtDepositor, tokenBaseDepositor, tokenLpDepositor, }: {
+        depositor: web3.PublicKey;
+        amountBase: bigint;
+        minLpOut: bigint;
+        tokenSyDepositor?: web3.PublicKey;
+        tokenYtDepositor?: web3.PublicKey;
+        tokenPtDepositor?: web3.PublicKey;
+        tokenBaseDepositor?: web3.PublicKey;
+        tokenLpDepositor?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixProvideLiquidityBase({ depositor, amountBase, minLpOut, externalPtToBuy, externalSyConstraint, tokenSyDepositor, tokenYtDepositor, tokenPtDepositor, tokenBaseDepositor, tokenLpDepositor, }: {
+        depositor: web3.PublicKey;
+        amountBase: bigint;
+        minLpOut: bigint;
+        externalPtToBuy: bigint;
+        externalSyConstraint: bigint;
+        tokenSyDepositor?: web3.PublicKey;
+        tokenYtDepositor?: web3.PublicKey;
+        tokenPtDepositor?: web3.PublicKey;
+        tokenBaseDepositor?: web3.PublicKey;
+        tokenLpDepositor?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixProvideLiquidityClassic({ depositor, amountBase, amountPt, minLpOut, tokenSyDepositor, tokenYtDepositor, tokenPtDepositor, tokenBaseDepositor, tokenLpDepositor, }: {
+        depositor: web3.PublicKey;
+        amountBase: bigint;
+        amountPt: bigint;
+        minLpOut: bigint;
+        tokenSyDepositor?: web3.PublicKey;
+        tokenYtDepositor?: web3.PublicKey;
+        tokenPtDepositor?: web3.PublicKey;
+        tokenBaseDepositor?: web3.PublicKey;
+        tokenLpDepositor?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixWithdrawLiquidityToBase({ owner, amountLp, minBaseOut, tokenSyWithdrawer, tokenYtWithdrawer, tokenPtWithdrawer, tokenBaseWithdrawer, tokenLpWithdrawer, }: {
+        owner: web3.PublicKey;
+        amountLp: bigint;
+        minBaseOut: bigint;
+        tokenSyWithdrawer?: web3.PublicKey;
+        tokenYtWithdrawer?: web3.PublicKey;
+        tokenPtWithdrawer?: web3.PublicKey;
+        tokenBaseWithdrawer?: web3.PublicKey;
+        tokenLpWithdrawer?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixWithdrawLiquidityClassic({ owner, amountLp, minBaseOut, tokenSyWithdrawer, tokenYtWithdrawer, tokenPtWithdrawer, tokenBaseWithdrawer, tokenLpWithdrawer, }: {
+        owner: web3.PublicKey;
+        amountLp: bigint;
+        minBaseOut: bigint;
+        tokenSyWithdrawer?: web3.PublicKey;
+        tokenYtWithdrawer?: web3.PublicKey;
+        tokenPtWithdrawer?: web3.PublicKey;
+        tokenBaseWithdrawer?: web3.PublicKey;
+        tokenLpWithdrawer?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    claimFarmEmissions({ owner, mint, tokenProgram, tokenDst, }: {
+        owner: web3.PublicKey;
+        mint: web3.PublicKey;
+        tokenProgram: web3.PublicKey;
+        tokenDst?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+        setupIxs: web3.TransactionInstruction[];
+    }>;
+    ixAddStandaloneEmission({ signer, emissionMint, emissionTokenProgram, altAddresses, cpiAccounts, }: {
+        signer: web3.PublicKey;
+        emissionMint: web3.PublicKey;
+        emissionTokenProgram?: web3.PublicKey;
+        altAddresses: web3.PublicKey[];
+        cpiAccounts: CpiAccountsRaw;
+    }): Promise<{
+        extendAddressLookupTableExtensionAccounts: web3.PublicKey[];
+        addMarketEmissionIx: web3.TransactionInstruction;
+    }>;
+    addFarm({ signer, farmMint, farmRewardTokenProgram, emissionsRate, untilTimestamp, farmRewardSrc, feePayer, }: {
+        signer: web3.PublicKey;
+        farmMint: web3.PublicKey;
+        farmRewardTokenProgram: web3.PublicKey;
+        emissionsRate: number;
+        untilTimestamp: number;
+        farmRewardSrc?: web3.PublicKey;
+        feePayer?: web3.PublicKey;
+    }): Promise<{
+        ixs: web3.TransactionInstruction[];
+    }>;
+    /** Calculate available liquidity for PT trades
+     * @param is_buy - true if buying PT with SY, false if selling PT for SY
+     * @param size_pt - amount of PT to trade (in PT decimals)
+     * @returns amount of PT that can be traded given current liquidity
+     */
+    liquidityAvailable(is_buy: boolean, size_pt: bigint): bigint;
+}
+export type MarketJson = {
+    /** The market's public key */
+    address: string;
+    /** The market's address lookup table public key */
+    addressLookupTable: string;
+    /** The market's SY escrow account public key - this is a pass-through account which moves SY between an end-user and the SY program where it is deposited and withdrawn from */
+    tokenSyEscrow: string;
+    /** The market's PT escrow account public key - this account holds the market's PT liquidity*/
+    tokenPtEscrow: string;
+    /** The market's LP escrow account public key - this account holds the market's LP tokens which are used to farm rewards */
+    tokenLpEscrow: string;
+    /** Token account that holds the market's SY fees */
+    treasurySyTokenAccount: string;
+    /** The market's LP supply */
+    lpSupply: string;
+    /** The SY program ID */
+    syProgram: string;
+    mintPt: string;
+    mintSy: string;
+    mintLp: string;
+    /** The market's PT balance */
+    ptBalance: string;
+    /** The market's SY balance */
+    syBalance: string;
+    /** The market's LP escrow amount */
+    lpEscrowAmount: string;
+    /** The market's current SY rate */
+    currentSyRate: number;
+    /** The market's expiration timestamp */
+    expirationTs: number;
+    /** The market's expiration date */
+    expirationDate: string;
+    /** The number of seconds remaining until the market expires */
+    secondsRemaining: number;
+    /** The market's maximum LP supply */
+    maxLpSupply: string;
+    lnFeeRateRoot: number;
+    rateScalarRoot: number;
+    feeTreasurySyBps: number;
+    lastLnImpliedRate: number;
+    /** The current rate scalar, taking into account the time decay*/
+    currentRateScalar: number;
+    /** The current rate anchor that preserves the last implied rate */
+    currentRateAnchor: number;
+    /** How many SY are required to buy 1 PT */
+    currentPtPriceInSy: number;
+    /** How many assets are required to buy 1 PT */
+    currentPtPriceInAsset: number;
+    /** Proportion of PT in terms of assets */
+    proportionPtInAsset: number;
+    /** Proportion of PT in terms of SY */
+    proportionPtInSy: number;
+    /** Current fee rate */
+    currentFeeRate: number;
+    /** CPI accounts */
+    cpiAccounts: CpiAccountsRawJson;
+    /** Annualized yield for PT */
+    ptApr: number;
+    /** Emission tokens */
+    emissions: {
+        trackers: {
+            tokenEscrow: string;
+            lpShareIndex: number;
+            lastSeenStaged: number;
+        }[];
+    };
+    liquidityNetBalanceLimits: {
+        windowStartTimestamp: number;
+        windowStartNetBalance: string;
+        maxNetBalanceChangeNegativePercentage: number;
+        maxNetBalanceChangePositivePercentage: number;
+        windowDurationSeconds: number;
+    };
+    lpFarm: {
+        lastSeenTimestamp: number;
+        farmEmissions: {
+            mint: string;
+            /** Tokens per second */
+            tokenRate: string;
+            expiryTimestamp: number;
+            /** Index for converting LP shares into earned emissions */
+            index: string;
+        }[];
+    };
+};