@exponent-labs/exponent-sdk 0.1.7 → 0.9.0

package/build/market.d.ts

@@ -1,20 +1,20 @@
-/// <reference types="bn.js" />
-import { BN, Program, Wallet, web3 } from "@coral-xyz/anchor";
 import { LiquidityNetBalanceLimits, LpFarm } from "@exponent-labs/exponent-fetcher";
-import { ExponentCore } from "@exponent-labs/exponent-idl";
 import { ExponentPDA } from "@exponent-labs/exponent-pda";
 import { AnchorizedPNum, CpiAccountsRaw, CpiAccountsRawJson, Flavor, SyPosition } from "@exponent-labs/exponent-types";
+import { FlavorGenericStateJson, SyPositionJson, VaultJson } from "@exponent-labs/exponent-types";
 import { LiquidityAdd, MarketCalculator } from "@exponent-labs/market-math";
 import { Environment } from "./environment";
 import { Vault } from "./vault";
-export { LiquidityAdd };
+import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import * as exponentCore from "./client/core";
+export type { LiquidityAdd };
 interface Emission {
     /** Token account that holds emission tokens */
-    escrowAccountAddress: web3.PublicKey;
+    escrowAccountAddress: PublicKey;
     /** Mint for the emission token */
-    mint: web3.PublicKey;
+    mint: PublicKey;
     /** Token program ID for the emission token */
-    tokenProgramAddress: web3.PublicKey;
+    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 */
@@ -22,23 +22,7 @@ interface Emission {
     /** 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];
-};
+export type MarketAdminAction = exponentCore.MarketAdminAction;
 type MarketArgs = {
     ptBalance: bigint;
     syBalance: bigint;
@@ -50,19 +34,19 @@ type MarketArgs = {
     lnFeeRateRoot: number;
     lastLnImpliedRate: number;
     expirationTs: number;
-    addressLookupTable: web3.PublicKey;
-    mintSy: web3.PublicKey;
-    mintPt: web3.PublicKey;
+    addressLookupTable: PublicKey;
+    mintSy: PublicKey;
+    mintPt: PublicKey;
     vault: Vault;
-    mintLp: web3.PublicKey;
-    tokenPtEscrow: web3.PublicKey;
-    tokenSyEscrow: web3.PublicKey;
-    tokenLpEscrow: web3.PublicKey;
-    syProgram: web3.PublicKey;
+    mintLp: PublicKey;
+    tokenPtEscrow: PublicKey;
+    tokenSyEscrow: PublicKey;
+    tokenLpEscrow: PublicKey;
+    syProgram: PublicKey;
     statusFlags: number;
     cpiAccounts: CpiAccountsRaw;
     feeTreasurySyBps: number;
-    tokenFeeTreasurySy: web3.PublicKey;
+    tokenFeeTreasurySy: PublicKey;
     isCurrentFlashSwap: boolean;
     lpFarm: LpFarm;
     flavor: Flavor;
@@ -70,35 +54,27 @@ type MarketArgs = {
     syPosition: SyPosition;
     emissions: {
         trackers: {
-            tokenEscrow: web3.PublicKey;
+            tokenEscrow: PublicKey;
             lpShareIndex: number;
             lastSeenStaged: number;
         }[];
     };
     seedId: 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;
-}
-interface MarketLoadOptions {
+export interface MarketLoadOptions {
     syConfig?: {
         skipWrap?: boolean;
     };
 }
 export declare class Market {
     state: MarketArgs;
-    selfAddress: web3.PublicKey;
+    selfAddress: PublicKey;
     env: Environment;
-    connection: web3.Connection;
-    coreProgram: Program<ExponentCore>;
+    connection: Connection;
     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, options?: MarketLoadOptions): Promise<Market>;
-    reload(connection?: web3.Connection): Promise<Market>;
+    constructor(state: MarketArgs, selfAddress: PublicKey, env: Environment, connection: Connection);
+    static load(env: Environment, connection: Connection, address: PublicKey, vault?: Vault, options?: MarketLoadOptions): Promise<Market>;
+    reload(connection?: Connection): Promise<Market>;
     /** Convert to a JSON representation */
     toJson(): MarketJson;
     get vault(): Vault;
@@ -106,34 +82,34 @@ export declare class Market {
     get lpSupply(): bigint;
     get syBalance(): bigint;
     get ptBalance(): bigint;
-    get mintSy(): web3.PublicKey;
-    get mintPt(): web3.PublicKey;
+    get mintSy(): PublicKey;
+    get mintPt(): PublicKey;
     get statusFlags(): number;
-    get mintYt(): web3.PublicKey;
-    get mintLp(): web3.PublicKey;
-    get addressLookupTable(): web3.PublicKey;
-    get syProgram(): web3.PublicKey;
+    get mintYt(): PublicKey;
+    get mintLp(): PublicKey;
+    get addressLookupTable(): PublicKey;
+    get syProgram(): PublicKey;
     get cpiAccounts(): CpiAccountsRaw;
     get marketEmissions(): {
         trackers: {
-            tokenEscrow: web3.PublicKey;
+            tokenEscrow: PublicKey;
             lpShareIndex: number;
             lastSeenStaged: number;
         }[];
     };
     get emissions(): Emission[];
     /** Get the escrow token account addresses for the emissions, in order */
-    get emissionTokenAccounts(): web3.PublicKey[];
+    get emissionTokenAccounts(): PublicKey[];
     /** Pass-through SY account owned by the market */
-    get tokenSyEscrow(): web3.PublicKey;
+    get tokenSyEscrow(): PublicKey;
     /** SY account that holds treasury SY fees from PT trading */
-    get tokenFeeTreasurySy(): web3.PublicKey;
+    get tokenFeeTreasurySy(): PublicKey;
     /** Market liquidity for PT */
-    get tokenPtEscrow(): web3.PublicKey;
-    get tokenLpEscrow(): web3.PublicKey;
+    get tokenPtEscrow(): PublicKey;
+    get tokenLpEscrow(): PublicKey;
     get currentSyExchangeRate(): number;
     /** Special account for event emit self-cpi */
-    get eventAuthority(): web3.PublicKey;
+    get eventAuthority(): PublicKey;
     get currentPtPriceInSy(): number;
     get currentPtPriceInAsset(): number;
     get ptDiscount(): number;
@@ -174,23 +150,23 @@ export declare class Market {
         syInIntent: bigint;
         /** Minimum LP tokens out */
         minLpOut: bigint;
-        depositor: web3.PublicKey;
-        ptSrc?: web3.PublicKey;
-        sySrc?: web3.PublicKey;
-        lpDst?: web3.PublicKey;
-    }): Promise<web3.TransactionInstruction>;
+        depositor: PublicKey;
+        ptSrc?: PublicKey;
+        sySrc?: PublicKey;
+        lpDst?: PublicKey;
+    }): TransactionInstruction;
     ixModifyMarketSetting({ signer, adminAction }: {
-        signer: web3.PublicKey;
-        adminAction: MarketAdminAction;
-    }): Promise<web3.TransactionInstruction>;
+        signer: PublicKey;
+        adminAction: exponentCore.MarketAdminAction;
+    }): TransactionInstruction;
     ixModifyFarm({ newRate, untilTimestamp, signer, farmMint, farmTokenProgram, farmTokenSrc: farmTokenSrcParam, }: {
         newRate: bigint;
         untilTimestamp: number;
-        signer: web3.PublicKey;
-        farmMint: web3.PublicKey;
-        farmTokenProgram: web3.PublicKey;
-        farmTokenSrc?: web3.PublicKey;
-    }): Promise<web3.TransactionInstruction>;
+        signer: PublicKey;
+        farmMint: PublicKey;
+        farmTokenProgram: PublicKey;
+        farmTokenSrc?: PublicKey;
+    }): TransactionInstruction;
     /**
      * Redeem LP tokens for PT & SY  (liquidity removal)
      *
@@ -202,16 +178,16 @@ export declare class Market {
      */
     ixWithdrawLiquidity({ lpIn, withdrawer, minPtOut, minSyOut, ptDst: ptDstParam, syDst: syDstParam, lpSrc: lpSrcParam, }: {
         lpIn: bigint;
-        withdrawer: web3.PublicKey;
+        withdrawer: PublicKey;
         minPtOut: bigint;
         minSyOut: bigint;
-        ptDst?: web3.PublicKey;
-        syDst?: web3.PublicKey;
-        lpSrc?: web3.PublicKey;
-    }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
-    }>;
+        ptDst?: PublicKey;
+        syDst?: PublicKey;
+        lpSrc?: PublicKey;
+    }): {
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    };
     /** Buy PT with SY
      *
      * The trader is the account that sends the SY
@@ -221,14 +197,14 @@ export declare class Market {
      * 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;
+        trader: PublicKey;
         amountPt: bigint;
         maxSySpend: bigint;
-        tokenPt?: web3.PublicKey;
-        tokenSy?: web3.PublicKey;
+        tokenPt?: PublicKey;
+        tokenSy?: PublicKey;
     }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
     }>;
     /**
      * Sell PT for SY
@@ -239,26 +215,26 @@ export declare class Market {
      * 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;
+        trader: PublicKey;
         amountPt: bigint;
         minSyReceive: bigint;
-        tokenPt?: web3.PublicKey;
-        tokenSy?: web3.PublicKey;
+        tokenPt?: PublicKey;
+        tokenSy?: PublicKey;
     }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
     }>;
     ixTradePt({ trader, traderPt, syConstraint, isBuy, tokenPt: tokenPtParam, tokenSy: tokenSyParam, }: {
-        trader: web3.PublicKey;
+        trader: PublicKey;
         traderPt: bigint;
         syConstraint: bigint;
         isBuy: boolean;
-        tokenPt?: web3.PublicKey;
-        tokenSy?: web3.PublicKey;
-    }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
-    }>;
+        tokenPt?: PublicKey;
+        tokenSy?: PublicKey;
+    }): {
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    };
     /** Sell YT for SY
      *
      * The trader is the account that sends the YT
@@ -270,16 +246,16 @@ export declare class Market {
      * 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, }: {
-        trader: web3.PublicKey;
+        trader: PublicKey;
         ytIn: bigint;
         minSyOut: bigint;
-        ytSrc?: web3.PublicKey;
-        ptSrc?: web3.PublicKey;
-        syDst?: web3.PublicKey;
-    }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
-    }>;
+        ytSrc?: PublicKey;
+        ptSrc?: PublicKey;
+        syDst?: PublicKey;
+    }): {
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    };
     /** Buy YT with SY
      *
      * The trader is the account that sends the SY
@@ -291,191 +267,192 @@ export declare class Market {
      * 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, }: {
-        trader: web3.PublicKey;
+        trader: PublicKey;
         ytOut: bigint;
         maxSyIn: bigint;
-        ytTrader?: web3.PublicKey;
-        ptTrader?: web3.PublicKey;
-        syTrader?: web3.PublicKey;
-    }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
-    }>;
+        ytTrader?: PublicKey;
+        ptTrader?: PublicKey;
+        syTrader?: PublicKey;
+    }): {
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    };
     ixInitLpPosition({ owner, feePayer }: {
-        owner: web3.PublicKey;
-        feePayer?: web3.PublicKey;
-    }): Promise<web3.TransactionInstruction>;
+        owner: PublicKey;
+        feePayer?: PublicKey;
+    }): TransactionInstruction;
     /** Deposit LP tokens into the farming module to earn rewards */
     ixDepositLp({ owner, amount, lpSrc: lpSrcParam, }: {
-        owner: web3.PublicKey;
+        owner: PublicKey;
         amount: bigint;
-        lpSrc?: web3.PublicKey;
-    }): Promise<web3.TransactionInstruction>;
+        lpSrc?: PublicKey;
+    }): TransactionInstruction;
     /** Withdraw LP tokens from the farming module */
     ixWithdrawLp({ owner, amount, lpDst: lpDstParam, }: {
-        owner: web3.PublicKey;
+        owner: PublicKey;
         amount: bigint;
-        lpDst?: web3.PublicKey;
-    }): Promise<web3.TransactionInstruction>;
+        lpDst?: PublicKey;
+    }): TransactionInstruction;
     ixWrapperCollectInterest({ claimer, tokenSyDst: tokenSyDstParam, }: {
-        claimer: web3.PublicKey;
-        tokenSyDst?: web3.PublicKey;
+        claimer: PublicKey;
+        tokenSyDst?: PublicKey;
     }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
     }>;
     ixWrapperBuyPt({ owner, ptOut, maxBaseIn, tokenSyTrader: tokenSyTraderParam, tokenPtTrader: tokenPtTraderParam, tokenBaseTrader: tokenBaseTraderParam, }: {
-        owner: web3.PublicKey;
+        owner: PublicKey;
         ptOut: bigint;
         maxBaseIn: bigint;
-        tokenSyTrader?: web3.PublicKey;
-        tokenPtTrader?: web3.PublicKey;
-        tokenBaseTrader?: web3.PublicKey;
+        tokenSyTrader?: PublicKey;
+        tokenPtTrader?: PublicKey;
+        tokenBaseTrader?: PublicKey;
     }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
     }>;
     ixWrapperSellPt({ owner, amount, minBaseOut, tokenSyTrader: tokenSyTraderParam, tokenPtTrader: tokenPtTraderParam, tokenBaseTrader: tokenBaseTraderParam, }: {
-        owner: web3.PublicKey;
+        owner: PublicKey;
         amount: bigint;
         minBaseOut: bigint;
-        tokenSyTrader?: web3.PublicKey;
-        tokenPtTrader?: web3.PublicKey;
-        tokenBaseTrader?: web3.PublicKey;
+        tokenSyTrader?: PublicKey;
+        tokenPtTrader?: PublicKey;
+        tokenBaseTrader?: PublicKey;
     }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
     }>;
     ixWrapperBuyYt({ owner, ytOut, maxBaseIn, tokenSyTrader: tokenSyTraderParam, tokenPtTrader: tokenPtTraderParam, tokenYtTrader: tokenYtTraderParam, tokenBaseTrader: tokenBaseTraderParam, }: {
-        owner: web3.PublicKey;
+        owner: PublicKey;
         ytOut: bigint;
         maxBaseIn: bigint;
-        tokenSyTrader?: web3.PublicKey;
-        tokenPtTrader?: web3.PublicKey;
-        tokenYtTrader?: web3.PublicKey;
-        tokenBaseTrader?: web3.PublicKey;
+        tokenSyTrader?: PublicKey;
+        tokenPtTrader?: PublicKey;
+        tokenYtTrader?: PublicKey;
+        tokenBaseTrader?: PublicKey;
     }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
     }>;
     ixWrapperSellYt({ owner, amount, minBaseOut, tokenBaseTrader: tokenBaseTraderParam, tokenSyTrader: tokenSyTraderParam, tokenYtTrader: tokenYtTraderParam, tokenPtTrader: tokenPtTraderParam, }: {
-        owner: web3.PublicKey;
+        owner: PublicKey;
         amount: bigint;
         minBaseOut: bigint;
-        tokenBaseTrader?: web3.PublicKey;
-        tokenSyTrader?: web3.PublicKey;
-        tokenYtTrader?: web3.PublicKey;
-        tokenPtTrader?: web3.PublicKey;
+        tokenBaseTrader?: PublicKey;
+        tokenSyTrader?: PublicKey;
+        tokenYtTrader?: PublicKey;
+        tokenPtTrader?: PublicKey;
     }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
     }>;
     ixCollectMarketEmission({ owner, emissionIndex, emissionDst, }: {
-        owner: web3.PublicKey;
+        owner: PublicKey;
         emissionIndex: number;
-        emissionDst?: web3.PublicKey;
-    }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
-    }>;
+        emissionDst?: PublicKey;
+    }): {
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    };
     /** Provide liquidity from a base asset - and receive YT and LP tokens in return */
     ixProvideLiquidityNoPriceImpact({ depositor, amountBase, minLpOut, tokenSyDepositor: tokenSyDepositorParam, tokenYtDepositor: tokenYtDepositorParam, tokenPtDepositor: tokenPtDepositorParam, tokenBaseDepositor: tokenBaseDepositorParam, tokenLpDepositor: tokenLpDepositorParam, }: {
-        depositor: web3.PublicKey;
+        depositor: PublicKey;
         amountBase: bigint;
         minLpOut: bigint;
-        tokenSyDepositor?: web3.PublicKey;
-        tokenYtDepositor?: web3.PublicKey;
-        tokenPtDepositor?: web3.PublicKey;
-        tokenBaseDepositor?: web3.PublicKey;
-        tokenLpDepositor?: web3.PublicKey;
+        tokenSyDepositor?: PublicKey;
+        tokenYtDepositor?: PublicKey;
+        tokenPtDepositor?: PublicKey;
+        tokenBaseDepositor?: PublicKey;
+        tokenLpDepositor?: PublicKey;
     }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
     }>;
     ixProvideLiquidityBase({ depositor, amountBase, minLpOut, externalPtToBuy, externalSyConstraint, tokenSyDepositor: tokenSyDepositorParam, tokenYtDepositor: tokenYtDepositorParam, tokenPtDepositor: tokenPtDepositorParam, tokenBaseDepositor: tokenBaseDepositorParam, tokenLpDepositor: tokenLpDepositorParam, }: {
-        depositor: web3.PublicKey;
+        depositor: PublicKey;
         amountBase: bigint;
         minLpOut: bigint;
         externalPtToBuy: bigint;
         externalSyConstraint: bigint;
-        tokenSyDepositor?: web3.PublicKey;
-        tokenYtDepositor?: web3.PublicKey;
-        tokenPtDepositor?: web3.PublicKey;
-        tokenBaseDepositor?: web3.PublicKey;
-        tokenLpDepositor?: web3.PublicKey;
+        tokenSyDepositor?: PublicKey;
+        tokenYtDepositor?: PublicKey;
+        tokenPtDepositor?: PublicKey;
+        tokenBaseDepositor?: PublicKey;
+        tokenLpDepositor?: PublicKey;
     }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
     }>;
     ixProvideLiquidityClassic({ depositor, amountBase, amountPt, minLpOut, tokenSyDepositor: tokenSyDepositorParam, tokenYtDepositor: tokenYtDepositorParam, tokenPtDepositor: tokenPtDepositorParam, tokenBaseDepositor: tokenBaseDepositorParam, tokenLpDepositor: tokenLpDepositorParam, }: {
-        depositor: web3.PublicKey;
+        depositor: PublicKey;
         amountBase: bigint;
         amountPt: bigint;
         minLpOut: bigint;
-        tokenSyDepositor?: web3.PublicKey;
-        tokenYtDepositor?: web3.PublicKey;
-        tokenPtDepositor?: web3.PublicKey;
-        tokenBaseDepositor?: web3.PublicKey;
-        tokenLpDepositor?: web3.PublicKey;
+        tokenSyDepositor?: PublicKey;
+        tokenYtDepositor?: PublicKey;
+        tokenPtDepositor?: PublicKey;
+        tokenBaseDepositor?: PublicKey;
+        tokenLpDepositor?: PublicKey;
     }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
     }>;
     ixWithdrawLiquidityToBase({ owner, amountLp, minBaseOut, tokenSyWithdrawer: tokenSyWithdrawerParam, tokenYtWithdrawer: tokenYtWithdrawerParam, tokenPtWithdrawer: tokenPtWithdrawerParam, tokenBaseWithdrawer: tokenBaseWithdrawerParam, tokenLpWithdrawer: tokenLpWithdrawerParam, }: {
-        owner: web3.PublicKey;
+        owner: PublicKey;
         amountLp: bigint;
         minBaseOut: bigint;
-        tokenSyWithdrawer?: web3.PublicKey;
-        tokenYtWithdrawer?: web3.PublicKey;
-        tokenPtWithdrawer?: web3.PublicKey;
-        tokenBaseWithdrawer?: web3.PublicKey;
-        tokenLpWithdrawer?: web3.PublicKey;
+        tokenSyWithdrawer?: PublicKey;
+        tokenYtWithdrawer?: PublicKey;
+        tokenPtWithdrawer?: PublicKey;
+        tokenBaseWithdrawer?: PublicKey;
+        tokenLpWithdrawer?: PublicKey;
     }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
     }>;
     ixWithdrawLiquidityClassic({ owner, amountLp, tokenSyWithdrawer: tokenSyWithdrawerParam, tokenYtWithdrawer: tokenYtWithdrawerParam, tokenPtWithdrawer: tokenPtWithdrawerParam, tokenBaseWithdrawer: tokenBaseWithdrawerParam, tokenLpWithdrawer: tokenLpWithdrawerParam, }: {
-        owner: web3.PublicKey;
+        owner: PublicKey;
         amountLp: bigint;
-        tokenSyWithdrawer?: web3.PublicKey;
-        tokenYtWithdrawer?: web3.PublicKey;
-        tokenPtWithdrawer?: web3.PublicKey;
-        tokenBaseWithdrawer?: web3.PublicKey;
-        tokenLpWithdrawer?: web3.PublicKey;
+        tokenSyWithdrawer?: PublicKey;
+        tokenYtWithdrawer?: PublicKey;
+        tokenPtWithdrawer?: PublicKey;
+        tokenBaseWithdrawer?: PublicKey;
+        tokenLpWithdrawer?: PublicKey;
     }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
     }>;
     claimFarmEmissions({ owner, mint, tokenProgram, tokenDst: tokenDstParam, }: {
-        owner: web3.PublicKey;
-        mint: web3.PublicKey;
-        tokenProgram: web3.PublicKey;
-        tokenDst?: web3.PublicKey;
-    }): Promise<{
-        ixs: web3.TransactionInstruction[];
-        setupIxs: web3.TransactionInstruction[];
-    }>;
+        owner: PublicKey;
+        mint: PublicKey;
+        tokenProgram: PublicKey;
+        tokenDst?: PublicKey;
+    }): {
+        ixs: TransactionInstruction[];
+        setupIxs: TransactionInstruction[];
+    };
     ixAddStandaloneEmission({ signer, emissionMint, emissionTokenProgram, altAddresses, cpiAccounts, }: {
-        signer: web3.PublicKey;
-        emissionMint: web3.PublicKey;
-        emissionTokenProgram?: web3.PublicKey;
-        altAddresses: web3.PublicKey[];
+        signer: PublicKey;
+        emissionMint: PublicKey;
+        emissionTokenProgram?: PublicKey;
+        altAddresses: PublicKey[];
         cpiAccounts: CpiAccountsRaw;
-    }): Promise<{
-        extendAddressLookupTableExtensionAccounts: web3.PublicKey[];
-        addMarketEmissionIx: web3.TransactionInstruction;
-    }>;
+    }): {
+        extendAddressLookupTableExtensionAccounts: PublicKey[];
+        addMarketEmissionIx: TransactionInstruction;
+    };
     addFarm({ signer, farmMint, farmRewardTokenProgram, emissionsRate, untilTimestamp, farmRewardSrc: farmRewardSrcParam, feePayer: feePayerParam, }: {
-        signer: web3.PublicKey;
-        farmMint: web3.PublicKey;
-        farmRewardTokenProgram: web3.PublicKey;
+        signer: PublicKey;
+        farmMint: PublicKey;
+        farmRewardTokenProgram: PublicKey;
         emissionsRate: number;
         untilTimestamp: number;
-        farmRewardSrc?: web3.PublicKey;
-        feePayer?: web3.PublicKey;
-    }): Promise<{
-        ixs: web3.TransactionInstruction[];
-    }>;
+        farmRewardSrc?: PublicKey;
+        feePayer?: PublicKey;
+    }): {
+        ixs: TransactionInstruction[];
+    };
+    static fromJson(json: MarketJson, env: Environment, connection: Connection): Market;
     /** Calculate available liquidity for PT trades
      * @param isBuy - true if buying PT with SY, false if selling PT for SY
      * @param sizePt - amount of PT to trade (in PT decimals)
@@ -488,15 +465,17 @@ export declare class Market {
      * @returns transaction instruction to realloc market
      */
     realloc_market({ signer, additionalBytes }: {
-        signer: web3.PublicKey;
+        signer: PublicKey;
         additionalBytes: number;
-    }): Promise<{
-        ixs: web3.TransactionInstruction[];
-    }>;
+    }): {
+        ixs: TransactionInstruction[];
+    };
 }
 export type MarketJson = {
     /** The market's public key */
     address: string;
+    /** The market's seed ID */
+    seedId: number;
     /** 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 */
@@ -552,6 +531,12 @@ export type MarketJson = {
     cpiAccounts: CpiAccountsRawJson;
     /** Annualized yield for PT */
     ptApr: number;
+    vault: VaultJson;
+    sySupply: string;
+    statusFlags: number;
+    isCurrentFlashSwap: boolean;
+    flavor: FlavorGenericStateJson;
+    syPosition: SyPositionJson;
     ptApy: number;
     /** Emission tokens */
     emissions: {