@exponent-labs/exponent-sdk 0.1.6 → 0.1.8

package/src/flavors.ts

@@ -20,9 +20,11 @@ import {
   FlavorPerena,
   FlavorPerenaState,
   FlavorPerenaStateJson,
+  fromAdditionalDataGenericJson,
+  fromInterfaceTypeGenericJson,
   MintSyArgs,
   RedeemSyArgs,
-  fromInterfaceTypeGenericJson,
+  toAdditionalDataGenericJson,
   toInterfaceTypeGenericJson,
 } from "@exponent-labs/exponent-types"
 import { GenericSySdk } from "@exponent-labs/generic-sy-sdk"
@@ -90,7 +92,7 @@ export function deserializeFlavorMarginfi(flavor: FlavorMarginfiStateJson): Flav
     mintBase: new web3.PublicKey(flavor.mintBase),
     baseTokenProgram: new web3.PublicKey(flavor.baseTokenProgram),
     emissions: flavor.emissions.map((e) => ({
-      exchangeRate: { 0: [new BN(PreciseNumber.fromRaw([new BN(e.exchangeRate)]).valueString)] },
+      exchangeRate: new PreciseNumber(e.exchangeRate.toString()).anchorify(),
       mint: new web3.PublicKey(e.mint),
       tokenProgram: new web3.PublicKey(e.tokenProgram),
     })),
@@ -121,8 +123,8 @@ export function deserializeFlavorMarginfi(flavor: FlavorMarginfiStateJson): Flav
           mint: new web3.PublicKey(emission.mint),
           tokenProgram: new web3.PublicKey(emission.tokenProgram),
           escrowAccount: new web3.PublicKey(emission.escrowAccount),
-          index: { 0: [new BN(emission.index)] },
-          lastSeenIndex: { 0: [new BN(emission.lastSeenIndex)] },
+          index: new PreciseNumber(emission.index.toString()).anchorify(),
+          lastSeenIndex: new PreciseNumber(emission.lastSeenIndex.toString()).anchorify(),
           lastSeenTotalAccruedEmissions: new BN(emission.lastSeenTotalAccruedEmissions),
           totalClaimedEmissions: new BN(emission.totalClaimedEmissions),
           treasuryEmission: new BN(emission.treasuryEmission),
@@ -151,6 +153,7 @@ export function serializeFlavorKamino(flavor: FlavorKaminoState): FlavorKaminoSt
       tokenProgramBase: flavor.kaminoSyState.tokenProgramBase.toString(),
       klendProgramId: flavor.kaminoSyState.klendProgramId.toString(),
       klendMarketId: flavor.kaminoSyState.klendMarketId.toString(),
+      scopePriceFeed: flavor.kaminoSyState.scopePriceFeed?.toString(),
       account: {
         kaminoReserve: flavor.kaminoSyState.account.kaminoReserve.toString(),
         kaminoObligation: flavor.kaminoSyState.account.kaminoObligation.toString(),
@@ -184,7 +187,7 @@ export function deserializeFlavorKamino(flavor: FlavorKaminoStateJson): FlavorKa
     mintBase: new web3.PublicKey(flavor.mintBase),
     baseTokenProgram: new web3.PublicKey(flavor.baseTokenProgram),
     emissions: flavor.emissions.map((e) => ({
-      exchangeRate: { 0: [new BN(PreciseNumber.fromRaw([new BN(e.exchangeRate)]).valueString)] },
+      exchangeRate: new PreciseNumber(e.exchangeRate.toString()).anchorify(),
       mint: new web3.PublicKey(e.mint),
       tokenProgram: new web3.PublicKey(e.tokenProgram),
     })),
@@ -196,6 +199,9 @@ export function deserializeFlavorKamino(flavor: FlavorKaminoStateJson): FlavorKa
       tokenProgramBase: new web3.PublicKey(flavor.kaminoSyState.tokenProgramBase),
       klendProgramId: new web3.PublicKey(flavor.kaminoSyState.klendProgramId),
       klendMarketId: new web3.PublicKey(flavor.kaminoSyState.klendMarketId),
+      scopePriceFeed: flavor.kaminoSyState.scopePriceFeed
+        ? new web3.PublicKey(flavor.kaminoSyState.scopePriceFeed)
+        : undefined,
       account: {
         kaminoReserve: new web3.PublicKey(flavor.kaminoSyState.account.kaminoReserve),
         kaminoObligation: new web3.PublicKey(flavor.kaminoSyState.account.kaminoObligation),
@@ -211,8 +217,8 @@ export function deserializeFlavorKamino(flavor: FlavorKaminoStateJson): FlavorKa
           mint: new web3.PublicKey(emission.mint),
           tokenProgram: new web3.PublicKey(emission.tokenProgram),
           escrowAccount: new web3.PublicKey(emission.escrowAccount),
-          index: { 0: [new BN(emission.index)] },
-          lastSeenIndex: { 0: [new BN(emission.lastSeenIndex)] },
+          index: new PreciseNumber(emission.index.toString()).anchorify(),
+          lastSeenIndex: new PreciseNumber(emission.lastSeenIndex.toString()).anchorify(),
           lastSeenTotalAccruedEmissions: new BN(emission.lastSeenTotalAccruedEmissions),
           totalClaimedEmissions: new BN(emission.totalClaimedEmissions),
           treasuryEmission: new BN(emission.treasuryEmission),
@@ -270,7 +276,7 @@ export function deserializeFlavorJitoRestaking(flavor: FlavorJitoRestakingStateJ
     mintBase: new web3.PublicKey(flavor.mintBase),
     baseTokenProgram: new web3.PublicKey(flavor.baseTokenProgram),
     emissions: flavor.emissions.map((e) => ({
-      exchangeRate: { 0: [new BN(PreciseNumber.fromRaw([new BN(e.exchangeRate)]).valueString)] },
+      exchangeRate: new PreciseNumber(e.exchangeRate.toString()).anchorify(),
       mint: new web3.PublicKey(e.mint),
       tokenProgram: new web3.PublicKey(e.tokenProgram),
     })),
@@ -293,8 +299,8 @@ export function deserializeFlavorJitoRestaking(flavor: FlavorJitoRestakingStateJ
           mint: new web3.PublicKey(emission.mint),
           tokenProgram: new web3.PublicKey(emission.tokenProgram),
           escrowAccount: new web3.PublicKey(emission.escrowAccount),
-          index: { 0: [new BN(emission.index)] },
-          lastSeenIndex: { 0: [new BN(emission.lastSeenIndex)] },
+          index: new PreciseNumber(emission.index.toString()).anchorify(),
+          lastSeenIndex: new PreciseNumber(emission.lastSeenIndex.toString()).anchorify(),
           lastSeenTotalAccruedEmissions: new BN(emission.lastSeenTotalAccruedEmissions),
           totalClaimedEmissions: new BN(emission.totalClaimedEmissions),
           treasuryEmission: new BN(emission.treasuryEmission),
@@ -359,6 +365,9 @@ export function serializeFlavorGeneric(flavor: FlavorGenericState): FlavorGeneri
       selfAddress: flavor.genericSyState.selfAddress.toString(),
       syRate: flavor.genericSyState.syRate,
       tokenProgramBase: flavor.genericSyState.tokenProgramBase.toString(),
+      additionalData: flavor.genericSyState.additionalData
+        ? toAdditionalDataGenericJson(flavor.genericSyState.additionalData)
+        : undefined,
       account: {
         yieldBearingMint: flavor.genericSyState.account.yieldBearingMint.toString(),
         mintSy: flavor.genericSyState.account.mintSy.toString(),
@@ -367,9 +376,11 @@ export function serializeFlavorGeneric(flavor: FlavorGenericState): FlavorGeneri
         minRedeemSize: flavor.genericSyState.account.minRedeemSize.toString(),
         maxSySupply: flavor.genericSyState.account.maxSySupply.toString(),
         hook: {
-          ...flavor.genericSyState.account.hook,
-          preMintHookDiscriminator: Buffer.from(flavor.genericSyState.account.hook.preMintHookDiscriminator),
-          postRedeemHookDiscriminator: Buffer.from(flavor.genericSyState.account.hook.postRedeemHookDiscriminator),
+          enabled: flavor.genericSyState.account.hook.enabled,
+          interfaceEmissionsAccountsUntil: flavor.genericSyState.account.hook.interfaceEmissionsAccountsUntil,
+          programId: flavor.genericSyState.account.hook.programId.toString(),
+          preMintHookDiscriminator: flavor.genericSyState.account.hook.preMintHookDiscriminator,
+          postRedeemHookDiscriminator: flavor.genericSyState.account.hook.postRedeemHookDiscriminator,
         },
         emissions: flavor.genericSyState.account.emissions.map((e) => ({
           mint: e.mint.toString(),
@@ -409,8 +420,8 @@ export function deserializeFlavorPerena(flavor: FlavorPerenaStateJson): FlavorPe
           mint: new web3.PublicKey(emission.mint),
           tokenProgram: new web3.PublicKey(emission.tokenProgram),
           escrowAccount: new web3.PublicKey(emission.escrowAccount),
-          index: { 0: [new BN(emission.index)] },
-          lastSeenIndex: { 0: [new BN(emission.lastSeenIndex)] },
+          index: new PreciseNumber(emission.index.toString()).anchorify(),
+          lastSeenIndex: new PreciseNumber(emission.lastSeenIndex.toString()).anchorify(),
           lastSeenTotalAccruedEmissions: new BN(emission.lastSeenTotalAccruedEmissions),
           totalClaimedEmissions: new BN(emission.totalClaimedEmissions),
           treasuryEmission: new BN(emission.treasuryEmission),
@@ -421,7 +432,7 @@ export function deserializeFlavorPerena(flavor: FlavorPerenaStateJson): FlavorPe
       tokenProgramBase: new web3.PublicKey(flavor.perenaSyState.tokenProgramBase),
     },
     emissions: flavor.emissions.map((e) => ({
-      exchangeRate: { 0: [new BN(PreciseNumber.fromRaw([new BN(e.exchangeRate)]).valueString)] },
+      exchangeRate: new PreciseNumber(e.exchangeRate.toString()).anchorify(),
       mint: new web3.PublicKey(e.mint),
       tokenProgram: new web3.PublicKey(e.tokenProgram),
     })),
@@ -435,7 +446,7 @@ export function deserializeFlavorGeneric(flavor: FlavorGenericStateJson): Flavor
     mintBase: new web3.PublicKey(flavor.mintBase),
     baseTokenProgram: new web3.PublicKey(flavor.baseTokenProgram),
     emissions: flavor.emissions.map((e) => ({
-      exchangeRate: { 0: [new BN(PreciseNumber.fromRaw([new BN(e.exchangeRate)]).valueString)] },
+      exchangeRate: new PreciseNumber(e.exchangeRate.toString()).anchorify(),
       mint: new web3.PublicKey(e.mint),
       tokenProgram: new web3.PublicKey(e.tokenProgram),
     })),
@@ -443,6 +454,9 @@ export function deserializeFlavorGeneric(flavor: FlavorGenericStateJson): Flavor
       selfAddress: new web3.PublicKey(flavor.genericSyState.selfAddress),
       syRate: flavor.genericSyState.syRate,
       tokenProgramBase: new web3.PublicKey(flavor.genericSyState.tokenProgramBase),
+      additionalData: flavor.genericSyState.additionalData
+        ? fromAdditionalDataGenericJson(flavor.genericSyState.additionalData)
+        : undefined,
       account: {
         mintSy: new web3.PublicKey(flavor.genericSyState.account.mintSy),
         yieldBearingMint: new web3.PublicKey(flavor.genericSyState.account.yieldBearingMint),
@@ -463,13 +477,13 @@ export function deserializeFlavorGeneric(flavor: FlavorGenericStateJson): Flavor
           mint: new web3.PublicKey(e.mint),
           tokenProgram: new web3.PublicKey(e.tokenProgram),
           escrowAccount: new web3.PublicKey(e.escrowAccount),
-          index: { 0: [new BN(e.index)] },
-          lastSeenIndex: { 0: [new BN(e.lastSeenIndex)] },
+          index: new PreciseNumber(e.index.toString()).anchorify(),
+          lastSeenIndex: new PreciseNumber(e.lastSeenIndex.toString()).anchorify(),
           lastSeenTotalAccruedEmissions: new BN(e.lastSeenTotalAccruedEmissions),
           totalClaimedEmissions: new BN(e.totalClaimedEmissions),
           treasuryEmission: new BN(e.treasuryEmission),
         })),
-        index: { 0: [new BN(flavor.genericSyState.account.index)] },
+        index: new PreciseNumber(flavor.genericSyState.account.index.toString()).anchorify(),
       },
     },
   }
@@ -539,15 +553,15 @@ export function makeFlavorGenericSync(data: FlavorGenericState, syConfig?: { ski
 }
 
 export function flavorFinder(env: Environment, syProgram: web3.PublicKey): FlavorDiscriminator {
-  if (env.marginfiSyProgramId.equals(syProgram)) {
+  if (env.marginfiSyProgramId?.equals(syProgram)) {
     return "marginfi"
-  } else if (env.kaminoSyProgramId.equals(syProgram)) {
+  } else if (env.kaminoSyProgramId?.equals(syProgram)) {
     return "kamino"
-  } else if (env.jitoRestakingSyProgramId.equals(syProgram)) {
+  } else if (env.jitoRestakingSyProgramId?.equals(syProgram)) {
     return "jitoRestaking"
-  } else if (env.perenaSyProgramId.equals(syProgram)) {
+  } else if (env.perenaSyProgramId?.equals(syProgram)) {
     return "perena"
-  } else if (env.genericSyProgramId.equals(syProgram)) {
+  } else if (env.genericSyProgramId?.equals(syProgram)) {
     return "generic"
   } else {
     throw new Error("Unknown flavor")
@@ -637,6 +651,8 @@ async function makeKaminoFlavor(
   const mintBase = reserveAcct.baseMint
 
   // TODO - don't do this
+  // Type error: 'a' is possibly 'null'.
+  // @ts-ignore
   const baseTokenProgram = await fetcher.connection.getAccountInfo(mintBase).then((a) => a.owner)
 
   const pda = new KaminoSyPda(new web3.PublicKey(KAMINO_STANDARD_PROGRAM_ID))
@@ -750,6 +766,10 @@ async function makeGenericFlavor(
     syMetaAddress: genericSyMeta,
     config: syConfig,
   })
+  // @ts-ignore
+  const preIxs = []
+  // @ts-ignore
+  const postIxs = []
 
   return {
     flavor: "generic",
@@ -758,8 +778,10 @@ async function makeGenericFlavor(
     baseTokenProgram: sySdk.tokenProgramBase,
     ixMintSy: (args) => sySdk.ixMintSy(args),
     ixRedeemSy: (args) => sySdk.ixRedeemSy(args),
-    preIxs: async () => [],
-    postIxs: async () => [],
+    // @ts-ignore
+    preIxs: async () => preIxs,
+    // @ts-ignore
+    postIxs: async () => postIxs,
     genericSyState: sySdk.state,
     emissions: sySdk.emissions.map((e) => ({
       exchangeRate: e.index,
@@ -768,3 +790,51 @@ async function makeGenericFlavor(
     })),
   }
 }
+
+export function serializeFlavor(
+  flavor: Flavor,
+):
+  | FlavorMarginfiStateJson
+  | FlavorKaminoStateJson
+  | FlavorJitoRestakingStateJson
+  | FlavorPerenaStateJson
+  | FlavorGenericStateJson {
+  switch (flavor.flavor) {
+    case "marginfi":
+      return serializeFlavorMarginfi(flavor)
+    case "kamino":
+      return serializeFlavorKamino(flavor)
+    case "jitoRestaking":
+      return serializeFlavorJitoRestaking(flavor)
+    case "perena":
+      return serializeFlavorPerena(flavor)
+    case "generic":
+      return serializeFlavorGeneric(flavor)
+    default:
+      throw new Error(`Unsupported flavor for serialization: ${(flavor as any).flavor}`)
+  }
+}
+
+export function deserializeFlavor(
+  flavor:
+    | FlavorMarginfiStateJson
+    | FlavorKaminoStateJson
+    | FlavorJitoRestakingStateJson
+    | FlavorPerenaStateJson
+    | FlavorGenericStateJson,
+): Flavor {
+  switch (flavor.flavor) {
+    case "marginfi":
+      return makeFlavorMarginfiSync(deserializeFlavorMarginfi(flavor))
+    case "kamino":
+      return makeFlavorKaminoSync(deserializeFlavorKamino(flavor))
+    case "jitoRestaking":
+      return makeFlavorJitoRestakingSync(deserializeFlavorJitoRestaking(flavor))
+    case "perena":
+      return makeFlavorPerenaSync(deserializeFlavorPerena(flavor))
+    case "generic":
+      return makeFlavorGenericSync(deserializeFlavorGeneric(flavor))
+    default:
+      throw new Error(`Unsupported flavor for deserialization: ${(flavor as any).flavor}`)
+  }
+}

package/src/index.ts

@@ -1,11 +1,17 @@
 export { Market, LiquidityAdd, MarketAdminAction } from "./market"
 export { Vault } from "./vault"
+export { MarketThree, MarketSnapshotData } from "./marketThree"
+export * from "./orderbook"
 export { LpPosition, LpPositionState } from "./lpPosition"
 export { YtPosition } from "./ytPosition"
 export { EventDecoder } from "./events"
+export * as exponentEvents from "./eventsV2"
+export * as clmmEvents from "./clmm/events"
+export * from "./EventDecoderV2"
 export type { AdminAction } from "./vault"
 export type { CategorizedEvents } from "./events"
 export * as events from "./events"
 export * from "./environment"
 export * as flavors from "./flavors"
 export { makeSyPosition } from "./syPosition"
+export { Router, RouterTradeSource, RouterQuoteDirection } from "./router"

package/src/lpPosition.ts

@@ -31,7 +31,7 @@ export class LpPosition {
     public state: LpPositionState,
   ) {
     const mockWallet = new MyWallet(web3.Keypair.generate())
-    this.coreProgram = new Program<ExponentCore>(IDL as ExponentCore, new AnchorProvider(connection, mockWallet))
+    this.coreProgram = new Program(IDL as ExponentCore, new AnchorProvider(connection, mockWallet))
   }
 
   static async load(env: Environment, connection: web3.Connection, address: web3.PublicKey, market?: Market) {
@@ -121,8 +121,11 @@ export class LpPosition {
     const positionFarm = this.state.farms[marketFarmIndex]
 
     const timeNow = new Date().getTime() / 1000
+    const expirationTs = this.state.market.state.expirationTs
 
-    const deltaTimeFarm = timeNow - this.marketSdk.state.lpFarm.lastSeenTimestamp
+    // cap time at expiration - emissions stop accruing after market expires
+    const effectiveTime = Math.min(timeNow, expirationTs)
+    const deltaTimeFarm = effectiveTime - this.marketSdk.state.lpFarm.lastSeenTimestamp
     const lpStakedTotal = this.marketSdk.state.lpEscrowAmount
     const tokensEmitted = Number(marketFarm.tokenRate) * deltaTimeFarm
     const increaseAmount = Number(tokensEmitted) / Number(lpStakedTotal)

package/src/market.ts

@@ -1,8 +1,8 @@
 import { AnchorProvider, BN, Program, Wallet, web3 } from "@coral-xyz/anchor"
 import {
-  TOKEN_PROGRAM_ID,
   createAssociatedTokenAccountIdempotentInstruction,
   getAssociatedTokenAddressSync,
+  TOKEN_PROGRAM_ID,
 } from "@solana/spl-token"
 
 import { ExponentFetcher, LiquidityNetBalanceLimits, LpFarm } from "@exponent-labs/exponent-fetcher"
@@ -13,28 +13,38 @@ import {
   CpiAccountsRaw,
   CpiAccountsRawJson,
   Flavor,
-  SyPosition,
   serializeCpiAccountsRaw,
+  SyPosition,
 } from "@exponent-labs/exponent-types"
-import { LiquidityAdd, MarketCalculator, lpOutForTokensIn } from "@exponent-labs/market-math"
+import { LiquidityAdd, lpOutForTokensIn, MarketCalculator } from "@exponent-labs/market-math"
 import { PreciseNumber } from "@exponent-labs/precise-number"
 
 import { fetchAddressLookupTable, makeCpiAccountMetaLists } from "./addressLookupTableUtil"
 import { Environment } from "./environment"
 import {
+  deserializeFlavor,
   makeFlavorGenericSync,
   makeFlavorJitoRestakingSync,
   makeFlavorKaminoSync,
   makeFlavorMarginfiSync,
   makeFlavorPerenaSync,
+  serializeFlavor,
 } from "./flavors"
+import {
+  deserializeCpiAccountsRaw,
+  FlavorGenericStateJson,
+  SyPositionJson,
+  VaultJson,
+} from "@exponent-labs/exponent-types"
+
+import { deserializeSyPosition, serializeSyPosition } from "./syPosition"
 import { makeSyPosition } from "./syPosition"
 import { getMultipleMintSupply } from "./tokenUtil"
 import { emitEventAuthority, getExponentAdminStatePda, uniqueRemainingAccounts } from "./utils"
 import { extendAddressLookupTable } from "./utils/altUtil"
 import { Vault } from "./vault"
 
-export { LiquidityAdd }
+export type { LiquidityAdd }
 
 const SECONDS_PER_YEAR = 365 * 24 * 60 * 60
 
@@ -61,6 +71,7 @@ interface Emission {
 export type MarketAdminAction =
   | { setStatus: [number] }
   | { setMaxLpSupply: [BN] }
+  | { changeTreasuryTradeSyBpsFee: [number] }
   | { changeLnFeeRateRoot: [number] }
   | { changeRateScalarRoot: [number] }
   | {
@@ -142,7 +153,7 @@ export class MyWallet implements Wallet {
   }
 }
 
-interface MarketLoadOptions {
+export interface MarketLoadOptions {
   syConfig?: {
     skipWrap?: boolean
   }
@@ -160,7 +171,7 @@ export class Market {
   ) {
     this.xponPda = new ExponentPDA(env.coreProgramId)
     const mockWallet = new MyWallet(web3.Keypair.generate())
-    this.coreProgram = new Program<ExponentCore>(IDL as ExponentCore, new AnchorProvider(connection, mockWallet))
+    this.coreProgram = new Program(IDL as ExponentCore, new AnchorProvider(connection, mockWallet))
   }
 
   static async load(
@@ -1000,6 +1011,7 @@ export class Market {
       tokenBaseClaimer,
       claimer,
       this.flavor.mintBase,
+      this.flavor.baseTokenProgram,
     )
 
     const tokenSyClaimer = getAssociatedTokenAddressSync(this.mintSy, claimer, true)
@@ -1091,6 +1103,7 @@ export class Market {
       tokenBaseTrader,
       owner,
       this.flavor.mintBase,
+      this.flavor.baseTokenProgram,
     )
 
     const mintSyIx = await this.flavor.ixMintSy({
@@ -1181,6 +1194,7 @@ export class Market {
       tokenBaseTrader,
       owner,
       this.flavor.mintBase,
+      this.flavor.baseTokenProgram,
     )
 
     const redeemSyIx = await this.flavor.ixRedeemSy({
@@ -1314,32 +1328,8 @@ export class Market {
       .remainingAccounts(allRemainingAccounts)
       .instruction()
 
-    const ix2 = await this.coreProgram.methods
-      .depositYt(new BN(ytOut.toString()))
-      .accountsStrict({
-        depositor: owner,
-        vault: this.vault.selfAddress,
-        userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner }),
-        ytSrc: tokenYtTrader,
-        escrowYt: this.vault.escrowYt,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        syProgram: this.syProgram,
-        addressLookupTable: this.vault.addressLookupTable,
-        systemProgram: web3.SystemProgram.programId,
-        eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-        yieldPosition: this.vault.state.yieldPositonAddress,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction()
-
     return {
-      ixs: [
-        ...(await this.flavor.preIxs({ signer: owner })),
-        ix1,
-        ...(await this.flavor.postIxs({ signer: owner })),
-        ix2,
-      ],
+      ixs: [...(await this.flavor.preIxs({ signer: owner })), ix1, ...(await this.flavor.postIxs({ signer: owner }))],
       setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx],
     }
   }
@@ -1394,6 +1384,7 @@ export class Market {
       tokenBaseTrader,
       owner,
       this.flavor.mintBase,
+      this.flavor.baseTokenProgram,
     )
 
     const redeemSyIx = await this.flavor.ixRedeemSy({
@@ -2210,6 +2201,63 @@ export class Market {
     }
   }
 
+  static fromJson(json: MarketJson, env: Environment, connection: web3.Connection): Market {
+    const state: MarketArgs = {
+      seedId: [json.seedId],
+      ptBalance: BigInt(json.ptBalance),
+      syBalance: BigInt(json.syBalance),
+      lpSupply: BigInt(json.lpSupply),
+      lpEscrowAmount: BigInt(json.lpEscrowAmount),
+      maxLpSupply: BigInt(json.maxLpSupply),
+      rateScalarRoot: json.rateScalarRoot,
+      lnFeeRateRoot: json.lnFeeRateRoot,
+      lastLnImpliedRate: json.lastLnImpliedRate,
+      expirationTs: json.expirationTs,
+      addressLookupTable: new web3.PublicKey(json.addressLookupTable),
+      mintSy: new web3.PublicKey(json.mintSy),
+      mintPt: new web3.PublicKey(json.mintPt),
+      mintLp: new web3.PublicKey(json.mintLp),
+      tokenPtEscrow: new web3.PublicKey(json.tokenPtEscrow),
+      tokenSyEscrow: new web3.PublicKey(json.tokenSyEscrow),
+      tokenLpEscrow: new web3.PublicKey(json.tokenLpEscrow),
+      syProgram: new web3.PublicKey(json.syProgram),
+      cpiAccounts: deserializeCpiAccountsRaw(json.cpiAccounts),
+      feeTreasurySyBps: json.feeTreasurySyBps,
+      tokenFeeTreasurySy: new web3.PublicKey(json.treasurySyTokenAccount),
+      lpFarm: {
+        farmEmissions: json.lpFarm.farmEmissions.map((e) => ({
+          mint: new web3.PublicKey(e.mint),
+          tokenRate: new BN(e.tokenRate),
+          expiryTimestamp: e.expiryTimestamp,
+          index: new PreciseNumber(e.index).anchorify(),
+        })),
+        lastSeenTimestamp: json.lpFarm.lastSeenTimestamp,
+      },
+      liquidityNetBalanceLimits: {
+        windowStartTimestamp: json.liquidityNetBalanceLimits.windowStartTimestamp,
+        windowStartNetBalance: new BN(json.liquidityNetBalanceLimits.windowStartNetBalance),
+        maxNetBalanceChangeNegativePercentage: json.liquidityNetBalanceLimits.maxNetBalanceChangeNegativePercentage,
+        maxNetBalanceChangePositivePercentage: json.liquidityNetBalanceLimits.maxNetBalanceChangePositivePercentage,
+        windowDurationSeconds: json.liquidityNetBalanceLimits.windowDurationSeconds,
+      },
+      emissions: {
+        trackers: json.emissions.trackers.map((e) => ({
+          tokenEscrow: new web3.PublicKey(e.tokenEscrow),
+          lpShareIndex: e.lpShareIndex,
+          lastSeenStaged: e.lastSeenStaged,
+        })),
+      },
+      vault: Vault.loadFromJson(json.vault, new web3.PublicKey(json.vault.selfAddress), env, connection),
+      sySupply: BigInt(json.sySupply),
+      statusFlags: json.statusFlags,
+      isCurrentFlashSwap: json.isCurrentFlashSwap,
+      flavor: deserializeFlavor(json.flavor),
+      syPosition: deserializeSyPosition(json.syPosition),
+    }
+
+    return new Market(state, new web3.PublicKey(json.address), env, connection)
+  }
+
   /** 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)
@@ -2269,6 +2317,8 @@ export class Market {
 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 */
@@ -2349,6 +2399,18 @@ export type MarketJson = {
   /** Annualized yield for PT */
   ptApr: number
 
+  vault: VaultJson
+
+  sySupply: string
+
+  statusFlags: number
+
+  isCurrentFlashSwap: boolean
+
+  flavor: FlavorGenericStateJson
+
+  syPosition: SyPositionJson
+
   ptApy: number
 
   /** Emission tokens */
@@ -2442,5 +2504,12 @@ function toJson(market: Market): MarketJson {
         index: PreciseNumber.fromRaw(e.index[0]).valueString,
       })),
     },
+    vault: market.vault.toJson(),
+    sySupply: market.state.sySupply.toString(),
+    statusFlags: market.state.statusFlags,
+    isCurrentFlashSwap: market.state.isCurrentFlashSwap,
+    // @ts-ignore
+    flavor: serializeFlavor(market.state.flavor),
+    syPosition: serializeSyPosition(market.state.syPosition),
   }
 }