@exponent-labs/exponent-sdk 0.0.9 → 0.1.0

package/src/market.ts

@@ -1,32 +1,38 @@
-import { AnchorProvider, Program, Wallet, web3 } from "@coral-xyz/anchor"
-import { ExponentFetcher, LiquidityNetBalanceLimits, LpFarm } from "@exponent-labs/exponent-fetcher"
+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"
+import { ExponentCore, IDL } from "@exponent-labs/exponent-idl"
+import { ExponentPDA } from "@exponent-labs/exponent-pda"
+import {
+  AnchorizedPNum,
+  CpiAccountsRaw,
+  CpiAccountsRawJson,
+  Flavor,
+  SyPosition,
+  serializeCpiAccountsRaw,
+} from "@exponent-labs/exponent-types"
+import { LiquidityAdd, MarketCalculator, lpOutForTokensIn } from "@exponent-labs/market-math"
+import { PreciseNumber } from "@exponent-labs/precise-number"
+
 import { fetchAddressLookupTable, makeCpiAccountMetaLists } from "./addressLookupTableUtil"
 import { Environment } from "./environment"
-import { getMultipleMintSupply } from "./tokenUtil"
 import {
-  makeFlavorMarginfiSync,
-  makeFlavorKaminoSync,
+  makeFlavorGenericSync,
   makeFlavorJitoRestakingSync,
+  makeFlavorKaminoSync,
+  makeFlavorMarginfiSync,
   makeFlavorPerenaSync,
-  makeFlavorGenericSync,
 } from "./flavors"
-import { ExponentCore, IDL } from "@exponent-labs/exponent-idl"
-import { BN } from "@coral-xyz/anchor"
-import { ExponentPDA } from "@exponent-labs/exponent-pda"
-import { Vault } from "./vault"
-import { LiquidityAdd, lpOutForTokensIn, MarketCalculator } from "@exponent-labs/market-math"
+import { makeSyPosition } from "./syPosition"
+import { getMultipleMintSupply } from "./tokenUtil"
 import { emitEventAuthority, getExponentAdminStatePda, uniqueRemainingAccounts } from "./utils"
-import { AccountInfo, CpiAccountsRaw, Flavor, serializeCpiAccountsRaw, SyPosition } from "@exponent-labs/exponent-types"
-import { PreciseNumber } from "@exponent-labs/precise-number"
-import { AnchorizedPNum } from "@exponent-labs/exponent-types"
 import { extendAddressLookupTable } from "./utils/altUtil"
-import { makeSyPosition } from "./syPosition"
-import { CpiAccountsRawJson } from "@exponent-labs/exponent-types"
+import { Vault } from "./vault"
 
 export { LiquidityAdd }
 
@@ -104,6 +110,7 @@ type MarketArgs = {
   }
 }
 
+//TODO Put it in the shared package because this code is repeated in many packages
 export class MyWallet implements Wallet {
   constructor(readonly payer: web3.Keypair) {
     this.payer = payer
@@ -163,13 +170,13 @@ export class Market {
     options: MarketLoadOptions = {},
   ): Promise<Market> {
     const fetcher = new ExponentFetcher({ connection })
-    const m = await fetcher.fetchMarket(address)
+    const fetchedMarket = await fetcher.fetchMarket(address)
     const [[lpSupply, sySupply], alt, loadedVault] = await Promise.all([
-      getMultipleMintSupply(connection, [m.mintLp, m.mintSy]),
-      fetchAddressLookupTable(connection, m.addressLookupTable),
-      vault || Vault.load(env, connection, m.vault, options),
+      getMultipleMintSupply(connection, [fetchedMarket.mintLp, fetchedMarket.mintSy]),
+      fetchAddressLookupTable(connection, fetchedMarket.addressLookupTable),
+      vault || Vault.load(env, connection, fetchedMarket.vault, options),
     ])
-    const cpiAccounts = makeCpiAccountMetaLists(alt, m.cpiAccounts)
+    const cpiAccounts = makeCpiAccountMetaLists(alt, fetchedMarket.cpiAccounts)
 
     const flavor = (() => {
       switch (loadedVault.flavor.flavor) {
@@ -188,10 +195,10 @@ export class Market {
       }
     })()
 
-    const syPosition = await makeSyPosition(fetcher, flavor, m.syProgram, address)
+    const syPosition = await makeSyPosition(fetcher, flavor, fetchedMarket.syProgram, address)
 
     const state: MarketArgs = {
-      ...m,
+      ...fetchedMarket,
       vault: loadedVault,
       cpiAccounts,
       lpSupply,
@@ -202,10 +209,10 @@ export class Market {
     return new Market(state, address, env, connection)
   }
 
-  async reload(conn: web3.Connection = this.connection) {
-    const m = await Market.load(this.env, conn, this.selfAddress)
-    this.state = m.state
-    return m
+  async reload(connection: web3.Connection = this.connection) {
+    const market = await Market.load(this.env, connection, this.selfAddress)
+    this.state = market.state
+    return market
   }
 
   /** Convert to a JSON representation */
@@ -361,8 +368,8 @@ export class Market {
   }
 
   get currentPtPriceInAsset(): number {
-    const c = this.marketCalculator()
-    return c.exchangeRate
+    const marketCalculator = this.marketCalculator()
+    return marketCalculator.exchangeRate
   }
 
   get ptDiscount(): number {
@@ -378,8 +385,8 @@ export class Market {
   }
 
   get secondsRemaining(): number {
-    const now = Date.now() / 1000
-    return Math.max(0, Math.round(this.state.expirationTs - now))
+    const timeNow = Date.now() / 1000
+    return Math.max(0, Math.round(this.state.expirationTs - timeNow))
   }
 
   get absolutePtYield(): number {
@@ -388,8 +395,12 @@ export class Market {
   }
 
   /** Annualize a rate given the number of seconds remaining until maturity */
-  static annualize(r: number, secondsRemaining: number) {
-    return (r * SECONDS_PER_YEAR) / secondsRemaining
+  static annualize(rate: number, secondsRemaining: number) {
+    return (rate * SECONDS_PER_YEAR) / secondsRemaining
+  }
+
+  static annualizeApy(rate: number, secondsRemaining: number) {
+    return (1 + rate) ** (SECONDS_PER_YEAR / secondsRemaining) - 1
   }
 
   /** Annualized PT fixed rate */
@@ -397,6 +408,10 @@ export class Market {
     return Market.annualize(this.absolutePtYield, this.secondsRemaining)
   }
 
+  get ptApy(): number {
+    return Market.annualizeApy(this.absolutePtYield, this.secondsRemaining)
+  }
+
   /** The fee rate taken off of trade fees (typically around 20%) expressed as a BPS number */
   get feeTreasuryBps(): number {
     return this.state.feeTreasurySyBps
@@ -415,7 +430,7 @@ export class Market {
     return this.feeTreasuryBps / 10_000
   }
 
-  /** Calculate amonut of LP tokens to expect for tokens in */
+  /** Calculate amount of LP tokens to expect for tokens in */
   lpOutForTokensIn(syInIntent: bigint, ptInIntent: bigint): LiquidityAdd {
     return lpOutForTokensIn({
       syIntent: Number(syInIntent),
@@ -427,7 +442,8 @@ export class Market {
   }
 
   marketCalculator() {
-    const secondsRemaining = Math.max(0, Math.round(this.state.expirationTs - Date.now() / 1000))
+    const timeNow = Date.now() / 1000
+    const secondsRemaining = Math.max(0, Math.round(this.state.expirationTs - timeNow))
     return new MarketCalculator({
       liquiditySy: parseInt(this.syBalance.toString()),
       liquidityPt: parseInt(this.ptBalance.toString()),
@@ -442,6 +458,7 @@ export class Market {
       windowStartTimestamp: this.state.liquidityNetBalanceLimits.windowStartTimestamp,
       windowStartNetBalance: this.state.liquidityNetBalanceLimits.windowStartNetBalance.toNumber(),
       windowDurationSeconds: this.state.liquidityNetBalanceLimits.windowDurationSeconds,
+      feeTreasurySyBps: this.state.feeTreasurySyBps,
     })
   }
 
@@ -458,9 +475,9 @@ export class Market {
     syInIntent,
     minLpOut,
     depositor,
-    ptSrc,
-    sySrc,
-    lpDst,
+    ptSrc: ptSrcParam,
+    sySrc: sySrcParam,
+    lpDst: lpDstParam,
   }: {
     /** Intended (maximum) amount of PT in */
     ptInIntent: bigint
@@ -475,9 +492,9 @@ export class Market {
   }) {
     const tokenProgram = TOKEN_PROGRAM_ID
 
-    sySrc = sySrc || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
-    ptSrc = ptSrc || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
-    lpDst = lpDst || getAssociatedTokenAddressSync(this.mintLp, depositor, true, TOKEN_PROGRAM_ID)
+    const sySrc = sySrcParam || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
+    const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
+    const lpDst = lpDstParam || getAssociatedTokenAddressSync(this.mintLp, depositor, true, TOKEN_PROGRAM_ID)
 
     const syRemAccounts = this.cpiAccounts.depositSy
 
@@ -524,7 +541,7 @@ export class Market {
     signer,
     farmMint,
     farmTokenProgram,
-    farmTokenSrc,
+    farmTokenSrc: farmTokenSrcParam,
   }: {
     newRate: bigint
     untilTimestamp: number
@@ -533,7 +550,7 @@ export class Market {
     farmTokenProgram: web3.PublicKey
     farmTokenSrc?: web3.PublicKey
   }) {
-    farmTokenSrc = farmTokenSrc || getAssociatedTokenAddressSync(farmMint, signer, true, farmTokenProgram)
+    const farmTokenSrc = farmTokenSrcParam || getAssociatedTokenAddressSync(farmMint, signer, true, farmTokenProgram)
 
     const tokenFarm = getAssociatedTokenAddressSync(farmMint, this.selfAddress, true, farmTokenProgram)
 
@@ -550,6 +567,7 @@ export class Market {
       })
       .instruction()
   }
+
   /**
    * Redeem LP tokens for PT & SY  (liquidity removal)
    *
@@ -564,9 +582,9 @@ export class Market {
     withdrawer,
     minPtOut,
     minSyOut,
-    ptDst,
-    syDst,
-    lpSrc,
+    ptDst: ptDstParam,
+    syDst: syDstParam,
+    lpSrc: lpSrcParam,
   }: {
     lpIn: bigint
     withdrawer: web3.PublicKey
@@ -576,9 +594,9 @@ export class Market {
     syDst?: web3.PublicKey
     lpSrc?: web3.PublicKey
   }) {
-    ptDst = ptDst || getAssociatedTokenAddressSync(this.mintPt, withdrawer, true, TOKEN_PROGRAM_ID)
-    syDst = syDst || getAssociatedTokenAddressSync(this.mintSy, withdrawer, true, TOKEN_PROGRAM_ID)
-    lpSrc = lpSrc || getAssociatedTokenAddressSync(this.mintLp, withdrawer, true, TOKEN_PROGRAM_ID)
+    const ptDst = ptDstParam || getAssociatedTokenAddressSync(this.mintPt, withdrawer, true, TOKEN_PROGRAM_ID)
+    const syDst = syDstParam || getAssociatedTokenAddressSync(this.mintSy, withdrawer, true, TOKEN_PROGRAM_ID)
+    const lpSrc = lpSrcParam || getAssociatedTokenAddressSync(this.mintLp, withdrawer, true, TOKEN_PROGRAM_ID)
 
     const ptDstAtaIx = createAssociatedTokenAccountIdempotentInstruction(withdrawer, ptDst, withdrawer, this.mintPt)
     const syDstAtaIx = createAssociatedTokenAccountIdempotentInstruction(withdrawer, syDst, withdrawer, this.mintSy)
@@ -676,8 +694,8 @@ export class Market {
     traderPt,
     syConstraint,
     isBuy,
-    tokenPt,
-    tokenSy,
+    tokenPt: tokenPtParam,
+    tokenSy: tokenSyParam,
   }: {
     trader: web3.PublicKey
     traderPt: bigint
@@ -686,8 +704,8 @@ export class Market {
     tokenPt?: web3.PublicKey
     tokenSy?: web3.PublicKey
   }) {
-    tokenPt = tokenPt || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
-    tokenSy = tokenSy || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
+    const tokenPt = tokenPtParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
+    const tokenSy = tokenSyParam || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
 
     const tokenSyAtaIx = createAssociatedTokenAccountIdempotentInstruction(trader, tokenSy, trader, this.mintSy)
     const tokenPtAtaIx = createAssociatedTokenAccountIdempotentInstruction(trader, tokenPt, trader, this.mintPt)
@@ -737,9 +755,9 @@ export class Market {
     trader,
     ytIn,
     minSyOut,
-    ytSrc,
-    ptSrc,
-    syDst,
+    ytSrc: ytSrcParam,
+    ptSrc: ptSrcParam,
+    syDst: syDstParam,
   }: {
     trader: web3.PublicKey
     ytIn: bigint
@@ -748,9 +766,9 @@ export class Market {
     ptSrc?: web3.PublicKey
     syDst?: web3.PublicKey
   }) {
-    syDst = syDst || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
-    ptSrc = ptSrc || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
-    ytSrc = ytSrc || getAssociatedTokenAddressSync(this.mintYt, trader, true, TOKEN_PROGRAM_ID)
+    const syDst = syDstParam || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
+    const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
+    const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.mintYt, trader, true, TOKEN_PROGRAM_ID)
 
     const syDstAtaIxs = createAssociatedTokenAccountIdempotentInstruction(trader, syDst, trader, this.mintSy)
     const ptSrcAtaIxs = createAssociatedTokenAccountIdempotentInstruction(trader, ptSrc, trader, this.mintPt)
@@ -808,9 +826,9 @@ export class Market {
     trader,
     ytOut,
     maxSyIn,
-    ytTrader,
-    ptTrader,
-    syTrader,
+    ytTrader: ytTraderParam,
+    ptTrader: ptTraderParam,
+    syTrader: syTraderParam,
   }: {
     trader: web3.PublicKey
     ytOut: bigint
@@ -819,9 +837,9 @@ export class Market {
     ptTrader?: web3.PublicKey
     syTrader?: web3.PublicKey
   }) {
-    syTrader = syTrader || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
-    ptTrader = ptTrader || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
-    ytTrader = ytTrader || getAssociatedTokenAddressSync(this.mintYt, trader, true, TOKEN_PROGRAM_ID)
+    const syTrader = syTraderParam || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
+    const ptTrader = ptTraderParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
+    const ytTrader = ytTraderParam || getAssociatedTokenAddressSync(this.mintYt, trader, true, TOKEN_PROGRAM_ID)
 
     const syTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(trader, syTrader, trader, this.mintSy)
     const ptTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(trader, ptTrader, trader, this.mintPt)
@@ -889,8 +907,16 @@ export class Market {
   }
 
   /** Deposit LP tokens into the farming module to earn rewards */
-  async ixDepositLp({ owner, amount, lpSrc }: { owner: web3.PublicKey; amount: bigint; lpSrc?: web3.PublicKey }) {
-    lpSrc = lpSrc || getAssociatedTokenAddressSync(this.mintLp, owner, true, TOKEN_PROGRAM_ID)
+  async ixDepositLp({
+    owner,
+    amount,
+    lpSrc: lpSrcParam,
+  }: {
+    owner: web3.PublicKey
+    amount: bigint
+    lpSrc?: web3.PublicKey
+  }) {
+    const lpSrc = lpSrcParam || getAssociatedTokenAddressSync(this.mintLp, owner, true, TOKEN_PROGRAM_ID)
     const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner })
 
     return this.coreProgram.methods
@@ -914,8 +940,16 @@ export class Market {
   }
 
   /** Withdraw LP tokens from the farming module */
-  async ixWithdrawLp({ owner, amount, lpDst }: { owner: web3.PublicKey; amount: bigint; lpDst?: web3.PublicKey }) {
-    lpDst = lpDst || getAssociatedTokenAddressSync(this.mintLp, owner, true, TOKEN_PROGRAM_ID)
+  async ixWithdrawLp({
+    owner,
+    amount,
+    lpDst: lpDstParam,
+  }: {
+    owner: web3.PublicKey
+    amount: bigint
+    lpDst?: web3.PublicKey
+  }) {
+    const lpDst = lpDstParam || getAssociatedTokenAddressSync(this.mintLp, owner, true, TOKEN_PROGRAM_ID)
 
     const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner })
     return this.coreProgram.methods
@@ -938,9 +972,15 @@ export class Market {
       .instruction()
   }
 
-  async ixWrapperCollectInterest({ claimer, tokenSyDst }: { claimer: web3.PublicKey; tokenSyDst?: web3.PublicKey }) {
+  async ixWrapperCollectInterest({
+    claimer,
+    tokenSyDst: tokenSyDstParam,
+  }: {
+    claimer: web3.PublicKey
+    tokenSyDst?: web3.PublicKey
+  }) {
     const yieldPosition = this.xponPda.yieldPosition({ owner: claimer, vault: this.vault.selfAddress })
-    tokenSyDst = tokenSyDst || getAssociatedTokenAddressSync(this.mintSy, claimer, true, TOKEN_PROGRAM_ID)
+    const tokenSyDst = tokenSyDstParam || getAssociatedTokenAddressSync(this.mintSy, claimer, true, TOKEN_PROGRAM_ID)
     const tokenBaseClaimer = getAssociatedTokenAddressSync(
       this.flavor.mintBase,
       claimer,
@@ -1007,9 +1047,9 @@ export class Market {
     owner,
     ptOut,
     maxBaseIn,
-    tokenSyTrader,
-    tokenPtTrader,
-    tokenBaseTrader,
+    tokenSyTrader: tokenSyTraderParam,
+    tokenPtTrader: tokenPtTraderParam,
+    tokenBaseTrader: tokenBaseTraderParam,
   }: {
     owner: web3.PublicKey
     ptOut: bigint
@@ -1018,10 +1058,13 @@ export class Market {
     tokenPtTrader?: web3.PublicKey
     tokenBaseTrader?: web3.PublicKey
   }) {
-    tokenSyTrader = tokenSyTrader || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
-    tokenPtTrader = tokenPtTrader || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
-    tokenBaseTrader =
-      tokenBaseTrader || getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
+    const tokenSyTrader =
+      tokenSyTraderParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    const tokenPtTrader =
+      tokenPtTraderParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenBaseTrader =
+      tokenBaseTraderParam ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
 
     const tokenSyTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
       owner,
@@ -1051,7 +1094,7 @@ export class Market {
 
     const mintSyRemAccounts = mintSyIx.keys
 
-    console.log("mintSyRemAccounts", mintSyRemAccounts)
+    // console.log("mintSyRemAccounts", mintSyRemAccounts)
 
     mintSyRemAccounts.push({
       pubkey: this.coreProgram.programId,
@@ -1094,9 +1137,9 @@ export class Market {
     owner,
     amount,
     minBaseOut,
-    tokenSyTrader,
-    tokenPtTrader,
-    tokenBaseTrader,
+    tokenSyTrader: tokenSyTraderParam,
+    tokenPtTrader: tokenPtTraderParam,
+    tokenBaseTrader: tokenBaseTraderParam,
   }: {
     owner: web3.PublicKey
     amount: bigint
@@ -1105,10 +1148,13 @@ export class Market {
     tokenPtTrader?: web3.PublicKey
     tokenBaseTrader?: web3.PublicKey
   }) {
-    tokenSyTrader = tokenSyTrader || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
-    tokenPtTrader = tokenPtTrader || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
-    tokenBaseTrader =
-      tokenBaseTrader || getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
+    const tokenSyTrader =
+      tokenSyTraderParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    const tokenPtTrader =
+      tokenPtTraderParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenBaseTrader =
+      tokenBaseTraderParam ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
 
     const tokenSyTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
       owner,
@@ -1169,10 +1215,10 @@ export class Market {
     owner,
     ytOut,
     maxBaseIn,
-    tokenSyTrader,
-    tokenPtTrader,
-    tokenYtTrader,
-    tokenBaseTrader,
+    tokenSyTrader: tokenSyTraderParam,
+    tokenPtTrader: tokenPtTraderParam,
+    tokenYtTrader: tokenYtTraderParam,
+    tokenBaseTrader: tokenBaseTraderParam,
   }: {
     owner: web3.PublicKey
     ytOut: bigint
@@ -1182,11 +1228,15 @@ export class Market {
     tokenYtTrader?: web3.PublicKey
     tokenBaseTrader?: web3.PublicKey
   }) {
-    tokenSyTrader = tokenSyTrader || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
-    tokenPtTrader = tokenPtTrader || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
-    tokenYtTrader = tokenYtTrader || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
-    tokenBaseTrader =
-      tokenBaseTrader || getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
+    const tokenSyTrader =
+      tokenSyTraderParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    const tokenPtTrader =
+      tokenPtTraderParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenYtTrader =
+      tokenYtTraderParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenBaseTrader =
+      tokenBaseTraderParam ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
 
     const tokenSyTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
       owner,
@@ -1227,7 +1277,7 @@ export class Market {
     const allRemainingAccounts = mintSyRemAccounts.concat(remainingAccounts)
 
     const ix1 = await this.coreProgram.methods
-      .wrapperBuyYt(new BN(ytOut.toString()), new BN(maxBaseIn.toString()), mintSyRemAccounts.length - 1)
+      .wrapperBuyYt(new BN(ytOut.toString()), new BN(maxBaseIn.toString()), mintSyRemAccounts.length)
       .accountsStrict({
         buyer: owner,
         market: this.selfAddress,
@@ -1290,10 +1340,10 @@ export class Market {
     owner,
     amount,
     minBaseOut,
-    tokenBaseTrader,
-    tokenSyTrader,
-    tokenYtTrader,
-    tokenPtTrader,
+    tokenBaseTrader: tokenBaseTraderParam,
+    tokenSyTrader: tokenSyTraderParam,
+    tokenYtTrader: tokenYtTraderParam,
+    tokenPtTrader: tokenPtTraderParam,
   }: {
     owner: web3.PublicKey
     amount: bigint
@@ -1303,11 +1353,15 @@ export class Market {
     tokenYtTrader?: web3.PublicKey
     tokenPtTrader?: web3.PublicKey
   }) {
-    tokenBaseTrader =
-      tokenBaseTrader || getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
-    tokenSyTrader = tokenSyTrader || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
-    tokenYtTrader = tokenYtTrader || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
-    tokenPtTrader = tokenPtTrader || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenBaseTrader =
+      tokenBaseTraderParam ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
+    const tokenSyTrader =
+      tokenSyTraderParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    const tokenYtTrader =
+      tokenYtTraderParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenPtTrader =
+      tokenPtTraderParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
 
     const tokenSyTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
       owner,
@@ -1349,7 +1403,7 @@ export class Market {
       ...this.vault.cpiAccounts.depositSy,
     ])
 
-    console.log(" remaining accounts length", remainingAccounts.length)
+    // console.log(" remaining accounts length", remainingAccounts.length)
 
     // remainingAccounts.push({
     //   pubkey: this.coreProgram.programId,
@@ -1462,11 +1516,11 @@ export class Market {
     depositor,
     amountBase,
     minLpOut,
-    tokenSyDepositor,
-    tokenYtDepositor,
-    tokenPtDepositor,
-    tokenBaseDepositor,
-    tokenLpDepositor,
+    tokenSyDepositor: tokenSyDepositorParam,
+    tokenYtDepositor: tokenYtDepositorParam,
+    tokenPtDepositor: tokenPtDepositorParam,
+    tokenBaseDepositor: tokenBaseDepositorParam,
+    tokenLpDepositor: tokenLpDepositorParam,
   }: {
     depositor: web3.PublicKey
     amountBase: bigint
@@ -1477,13 +1531,17 @@ export class Market {
     tokenBaseDepositor?: web3.PublicKey
     tokenLpDepositor?: web3.PublicKey
   }) {
-    tokenSyDepositor = tokenSyDepositor || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
-    tokenYtDepositor = tokenYtDepositor || getAssociatedTokenAddressSync(this.mintYt, depositor, true, TOKEN_PROGRAM_ID)
-    tokenPtDepositor = tokenPtDepositor || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
-    tokenBaseDepositor =
-      tokenBaseDepositor ||
+    const tokenSyDepositor =
+      tokenSyDepositorParam || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
+    const tokenYtDepositor =
+      tokenYtDepositorParam || getAssociatedTokenAddressSync(this.mintYt, depositor, true, TOKEN_PROGRAM_ID)
+    const tokenPtDepositor =
+      tokenPtDepositorParam || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
+    const tokenBaseDepositor =
+      tokenBaseDepositorParam ||
       getAssociatedTokenAddressSync(this.flavor.mintBase, depositor, true, this.flavor.baseTokenProgram)
-    tokenLpDepositor = tokenLpDepositor || getAssociatedTokenAddressSync(this.mintLp, depositor, true, TOKEN_PROGRAM_ID)
+    const tokenLpDepositor =
+      tokenLpDepositorParam || getAssociatedTokenAddressSync(this.mintLp, depositor, true, TOKEN_PROGRAM_ID)
 
     const tokenSyDepositorAtaIx = createAssociatedTokenAccountIdempotentInstruction(
       depositor,
@@ -1525,9 +1583,9 @@ export class Market {
 
     const mintSyRemAccounts = mintSyIx.keys
 
-    // Log vault accounts before filtering
     const beforeVaultAccounts = [...this.vault.cpiAccounts.getSyState, ...this.vault.cpiAccounts.depositSy]
-    console.log("Before filtering vault accounts:", beforeVaultAccounts.length, "accounts")
+    // Log vault accounts before filtering
+    // console.log("Before filtering vault accounts:", beforeVaultAccounts.length, "accounts")
 
     // Filter out TOKEN_PROGRAM_ID and SystemProgram.programId from vault remaining accounts
     const vaultCpiRemainingAccounts = beforeVaultAccounts.filter(
@@ -1535,11 +1593,11 @@ export class Market {
     )
 
     // Log vault accounts after filtering
-    console.log("After filtering vault accounts:", vaultCpiRemainingAccounts.length, "accounts")
+    // console.log("After filtering vault accounts:", vaultCpiRemainingAccounts.length, "accounts")
 
     // Log market accounts before filtering
     const beforeMarketAccounts = [...this.cpiAccounts.depositSy]
-    console.log("Before filtering market accounts:", beforeMarketAccounts.length, "accounts")
+    // console.log("Before filtering market accounts:", beforeMarketAccounts.length, "accounts")
 
     // Filter out TOKEN_PROGRAM_ID and SystemProgram.programId from market remaining accounts
     const marketCpiRemainingAccounts = beforeMarketAccounts.filter(
@@ -1550,7 +1608,7 @@ export class Market {
     )
 
     // Log market accounts after filtering
-    console.log("After filtering market accounts:", marketCpiRemainingAccounts.length, "accounts")
+    // console.log("After filtering market accounts:", marketCpiRemainingAccounts.length, "accounts")
 
     // These remaining accounts can be in any order, and they can be unique-ified
     const unorderedRemainingAccounts = uniqueRemainingAccounts([
@@ -1563,7 +1621,7 @@ export class Market {
     const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner: depositor })
 
     const ix = await this.coreProgram.methods
-      .wrapperProvideLiquidity(amountBaseBn, minLpOutBn, mintSyRemAccounts.length - 1)
+      .wrapperProvideLiquidity(amountBaseBn, minLpOutBn, mintSyRemAccounts.length)
       .accountsStrict({
         depositor,
         authority: this.vault.authority,
@@ -1595,7 +1653,7 @@ export class Market {
       .remainingAccounts(allRemainingAccounts)
       .instruction()
 
-    console.log("ix accounts length", ix.keys.length)
+    // console.log("ix accounts length", ix.keys.length)
 
     return {
       ixs: [
@@ -1613,11 +1671,11 @@ export class Market {
     minLpOut,
     externalPtToBuy,
     externalSyConstraint,
-    tokenSyDepositor,
-    tokenYtDepositor,
-    tokenPtDepositor,
-    tokenBaseDepositor,
-    tokenLpDepositor,
+    tokenSyDepositor: tokenSyDepositorParam,
+    tokenYtDepositor: tokenYtDepositorParam,
+    tokenPtDepositor: tokenPtDepositorParam,
+    tokenBaseDepositor: tokenBaseDepositorParam,
+    tokenLpDepositor: tokenLpDepositorParam,
   }: {
     depositor: web3.PublicKey
     amountBase: bigint
@@ -1630,13 +1688,17 @@ export class Market {
     tokenBaseDepositor?: web3.PublicKey
     tokenLpDepositor?: web3.PublicKey
   }) {
-    tokenSyDepositor = tokenSyDepositor || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
-    tokenYtDepositor = tokenYtDepositor || getAssociatedTokenAddressSync(this.mintYt, depositor, true, TOKEN_PROGRAM_ID)
-    tokenPtDepositor = tokenPtDepositor || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
-    tokenBaseDepositor =
-      tokenBaseDepositor ||
+    const tokenSyDepositor =
+      tokenSyDepositorParam || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
+    const tokenYtDepositor =
+      tokenYtDepositorParam || getAssociatedTokenAddressSync(this.mintYt, depositor, true, TOKEN_PROGRAM_ID)
+    const tokenPtDepositor =
+      tokenPtDepositorParam || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
+    const tokenBaseDepositor =
+      tokenBaseDepositorParam ||
       getAssociatedTokenAddressSync(this.flavor.mintBase, depositor, true, this.flavor.baseTokenProgram)
-    tokenLpDepositor = tokenLpDepositor || getAssociatedTokenAddressSync(this.mintLp, depositor, true, TOKEN_PROGRAM_ID)
+    const tokenLpDepositor =
+      tokenLpDepositorParam || getAssociatedTokenAddressSync(this.mintLp, depositor, true, TOKEN_PROGRAM_ID)
 
     const tokenSyAtaIx = createAssociatedTokenAccountIdempotentInstruction(
       depositor,
@@ -1690,7 +1752,7 @@ export class Market {
       .wrapperProvideLiquidityBase(
         new BN(amountBase.toString()),
         new BN(minLpOut.toString()),
-        mintSyRemAccounts.length - 1,
+        mintSyRemAccounts.length,
         new BN(externalPtToBuy.toString()),
         new BN(externalSyConstraint.toString()),
       )
@@ -1731,11 +1793,11 @@ export class Market {
     amountBase,
     amountPt,
     minLpOut,
-    tokenSyDepositor,
-    tokenYtDepositor,
-    tokenPtDepositor,
-    tokenBaseDepositor,
-    tokenLpDepositor,
+    tokenSyDepositor: tokenSyDepositorParam,
+    tokenYtDepositor: tokenYtDepositorParam,
+    tokenPtDepositor: tokenPtDepositorParam,
+    tokenBaseDepositor: tokenBaseDepositorParam,
+    tokenLpDepositor: tokenLpDepositorParam,
   }: {
     depositor: web3.PublicKey
     amountBase: bigint
@@ -1747,13 +1809,17 @@ export class Market {
     tokenBaseDepositor?: web3.PublicKey
     tokenLpDepositor?: web3.PublicKey
   }) {
-    tokenSyDepositor = tokenSyDepositor || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
-    tokenYtDepositor = tokenYtDepositor || getAssociatedTokenAddressSync(this.mintYt, depositor, true, TOKEN_PROGRAM_ID)
-    tokenPtDepositor = tokenPtDepositor || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
-    tokenBaseDepositor =
-      tokenBaseDepositor ||
+    const tokenSyDepositor =
+      tokenSyDepositorParam || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
+    const tokenYtDepositor =
+      tokenYtDepositorParam || getAssociatedTokenAddressSync(this.mintYt, depositor, true, TOKEN_PROGRAM_ID)
+    const tokenPtDepositor =
+      tokenPtDepositorParam || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
+    const tokenBaseDepositor =
+      tokenBaseDepositorParam ||
       getAssociatedTokenAddressSync(this.flavor.mintBase, depositor, true, this.flavor.baseTokenProgram)
-    tokenLpDepositor = tokenLpDepositor || getAssociatedTokenAddressSync(this.mintLp, depositor, true, TOKEN_PROGRAM_ID)
+    const tokenLpDepositor =
+      tokenLpDepositorParam || getAssociatedTokenAddressSync(this.mintLp, depositor, true, TOKEN_PROGRAM_ID)
 
     const tokenSyAtaIx = createAssociatedTokenAccountIdempotentInstruction(
       depositor,
@@ -1804,7 +1870,7 @@ export class Market {
         new BN(amountBase.toString()),
         new BN(amountPt.toString()),
         new BN(minLpOut.toString()),
-        mintSyRemAccounts.length - 1,
+        mintSyRemAccounts.length,
       )
       .accountsStrict({
         depositor,
@@ -1841,11 +1907,11 @@ export class Market {
     owner,
     amountLp,
     minBaseOut,
-    tokenSyWithdrawer,
-    tokenYtWithdrawer,
-    tokenPtWithdrawer,
-    tokenBaseWithdrawer,
-    tokenLpWithdrawer,
+    tokenSyWithdrawer: tokenSyWithdrawerParam,
+    tokenYtWithdrawer: tokenYtWithdrawerParam,
+    tokenPtWithdrawer: tokenPtWithdrawerParam,
+    tokenBaseWithdrawer: tokenBaseWithdrawerParam,
+    tokenLpWithdrawer: tokenLpWithdrawerParam,
   }: {
     owner: web3.PublicKey
     amountLp: bigint
@@ -1856,13 +1922,17 @@ export class Market {
     tokenBaseWithdrawer?: web3.PublicKey
     tokenLpWithdrawer?: web3.PublicKey
   }) {
-    tokenSyWithdrawer = tokenSyWithdrawer || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
-    tokenYtWithdrawer = tokenYtWithdrawer || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
-    tokenPtWithdrawer = tokenPtWithdrawer || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
-    tokenBaseWithdrawer =
-      tokenBaseWithdrawer ||
+    const tokenSyWithdrawer =
+      tokenSyWithdrawerParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    const tokenYtWithdrawer =
+      tokenYtWithdrawerParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenPtWithdrawer =
+      tokenPtWithdrawerParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenBaseWithdrawer =
+      tokenBaseWithdrawerParam ||
       getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
-    tokenLpWithdrawer = tokenLpWithdrawer || getAssociatedTokenAddressSync(this.mintLp, owner, true, TOKEN_PROGRAM_ID)
+    const tokenLpWithdrawer =
+      tokenLpWithdrawerParam || getAssociatedTokenAddressSync(this.mintLp, owner, true, TOKEN_PROGRAM_ID)
 
     const tokenSyAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenSyWithdrawer, owner, this.mintSy)
     const tokenYtAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenYtWithdrawer, owner, this.mintYt)
@@ -1931,29 +2001,31 @@ export class Market {
   async ixWithdrawLiquidityClassic({
     owner,
     amountLp,
-    minBaseOut,
-    tokenSyWithdrawer,
-    tokenYtWithdrawer,
-    tokenPtWithdrawer,
-    tokenBaseWithdrawer,
-    tokenLpWithdrawer,
+    tokenSyWithdrawer: tokenSyWithdrawerParam,
+    tokenYtWithdrawer: tokenYtWithdrawerParam,
+    tokenPtWithdrawer: tokenPtWithdrawerParam,
+    tokenBaseWithdrawer: tokenBaseWithdrawerParam,
+    tokenLpWithdrawer: tokenLpWithdrawerParam,
   }: {
     owner: web3.PublicKey
     amountLp: bigint
-    minBaseOut: bigint
     tokenSyWithdrawer?: web3.PublicKey
     tokenYtWithdrawer?: web3.PublicKey
     tokenPtWithdrawer?: web3.PublicKey
     tokenBaseWithdrawer?: web3.PublicKey
     tokenLpWithdrawer?: web3.PublicKey
   }) {
-    tokenSyWithdrawer = tokenSyWithdrawer || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
-    tokenYtWithdrawer = tokenYtWithdrawer || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
-    tokenPtWithdrawer = tokenPtWithdrawer || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
-    tokenBaseWithdrawer =
-      tokenBaseWithdrawer ||
+    const tokenSyWithdrawer =
+      tokenSyWithdrawerParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    const tokenYtWithdrawer =
+      tokenYtWithdrawerParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenPtWithdrawer =
+      tokenPtWithdrawerParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenBaseWithdrawer =
+      tokenBaseWithdrawerParam ||
       getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
-    tokenLpWithdrawer = tokenLpWithdrawer || getAssociatedTokenAddressSync(this.mintLp, owner, true, TOKEN_PROGRAM_ID)
+    const tokenLpWithdrawer =
+      tokenLpWithdrawerParam || getAssociatedTokenAddressSync(this.mintLp, owner, true, TOKEN_PROGRAM_ID)
 
     const tokenSyAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenSyWithdrawer, owner, this.mintSy)
     const tokenYtAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenYtWithdrawer, owner, this.mintYt)
@@ -2016,14 +2088,14 @@ export class Market {
     owner,
     mint,
     tokenProgram,
-    tokenDst,
+    tokenDst: tokenDstParam,
   }: {
     owner: web3.PublicKey
     mint: web3.PublicKey
     tokenProgram: web3.PublicKey
     tokenDst?: web3.PublicKey
   }) {
-    tokenDst = tokenDst || getAssociatedTokenAddressSync(mint, owner, true, tokenProgram)
+    const tokenDst = tokenDstParam || getAssociatedTokenAddressSync(mint, owner, true, tokenProgram)
     const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner })
 
     const tokenFarm = getAssociatedTokenAddressSync(mint, this.selfAddress, true, tokenProgram)
@@ -2092,8 +2164,8 @@ export class Market {
     farmRewardTokenProgram,
     emissionsRate,
     untilTimestamp,
-    farmRewardSrc,
-    feePayer,
+    farmRewardSrc: farmRewardSrcParam,
+    feePayer: feePayerParam,
   }: {
     signer: web3.PublicKey
     farmMint: web3.PublicKey
@@ -2103,9 +2175,10 @@ export class Market {
     farmRewardSrc?: web3.PublicKey
     feePayer?: web3.PublicKey
   }) {
-    feePayer = feePayer || signer
+    const feePayer = feePayerParam || signer
     const farmRewardEscrow = getAssociatedTokenAddressSync(farmMint, this.selfAddress, true, farmRewardTokenProgram)
-    farmRewardSrc = farmRewardSrc || getAssociatedTokenAddressSync(farmMint, signer, true, farmRewardTokenProgram)
+    const farmRewardSrc =
+      farmRewardSrcParam || getAssociatedTokenAddressSync(farmMint, signer, true, farmRewardTokenProgram)
 
     const ix = await this.coreProgram.methods
       .addFarm(new BN(emissionsRate), untilTimestamp)
@@ -2128,22 +2201,22 @@ export class Market {
   }
 
   /** 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)
+   * @param isBuy - true if buying PT with SY, false if selling PT for SY
+   * @param sizePt - 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 {
+  liquidityAvailable(isBuy: boolean, sizePt: bigint): bigint {
     const calc = this.marketCalculator()
 
-    if (is_buy) {
+    if (isBuy) {
       // When buying PT, we're limited by SY liquidity
       // Convert PT amount to SY using current price
-      const syNeeded = Number(size_pt) * calc.exchangeRate
+      const syNeeded = Number(sizePt) * calc.exchangeRate
       // Available SY in the market
       const syAvailable = Number(this.syBalance)
 
       if (syNeeded <= syAvailable) {
-        return size_pt
+        return sizePt
       } else {
         // Calculate max PT that can be bought with available SY
         return BigInt(Math.floor(syAvailable / calc.exchangeRate))
@@ -2152,8 +2225,8 @@ export class Market {
       // When selling PT, we're limited by PT liquidity in the market
       const ptAvailable = this.ptBalance
 
-      if (size_pt <= ptAvailable) {
-        return size_pt
+      if (sizePt <= ptAvailable) {
+        return sizePt
       } else {
         return ptAvailable
       }
@@ -2244,6 +2317,8 @@ export type MarketJson = {
   /** Annualized yield for PT */
   ptApr: number
 
+  ptApy: number
+
   /** Emission tokens */
   emissions: {
     trackers: {
@@ -2274,58 +2349,61 @@ export type MarketJson = {
   }
 }
 
-function toJson(m: Market): MarketJson {
-  const c = m.marketCalculator()
+function toJson(market: Market): MarketJson {
+  const marketCalculator = market.marketCalculator()
   return {
-    treasurySyTokenAccount: m.state.tokenFeeTreasurySy.toBase58(),
-    address: m.selfAddress.toBase58(),
-    addressLookupTable: m.addressLookupTable.toBase58(),
-    tokenSyEscrow: m.tokenSyEscrow.toBase58(),
-    tokenPtEscrow: m.tokenPtEscrow.toBase58(),
-    tokenLpEscrow: m.tokenLpEscrow.toBase58(),
-    lpSupply: m.state.lpSupply.toString(),
-    syProgram: m.state.syProgram.toBase58(),
-    mintPt: m.state.mintPt.toBase58(),
-    mintSy: m.state.mintSy.toBase58(),
-    mintLp: m.state.mintLp.toBase58(),
-    feeTreasurySyBps: m.state.feeTreasurySyBps,
-    ptBalance: m.state.ptBalance.toString(),
-    syBalance: m.state.syBalance.toString(),
-    currentSyRate: m.flavor.currentSyExchangeRate,
-    expirationTs: m.state.expirationTs,
-    expirationDate: new Date(m.state.expirationTs * 1000).toISOString(),
-    lnFeeRateRoot: m.state.lnFeeRateRoot,
-    rateScalarRoot: m.state.rateScalarRoot,
-    lastLnImpliedRate: m.state.lastLnImpliedRate,
-    currentPtPriceInSy: m.currentPtPriceInSy,
-    currentPtPriceInAsset: m.currentPtPriceInAsset,
-    secondsRemaining: m.secondsRemaining,
-    proportionPtInAsset: c.proportionPtInAsset,
-    proportionPtInSy: c.proportionPtInSy,
-    currentFeeRate: c.feeRate,
-    currentRateScalar: c.rateScalar,
-    currentRateAnchor: c.findRateAnchor(),
-    cpiAccounts: serializeCpiAccountsRaw(m.cpiAccounts),
+    treasurySyTokenAccount: market.state.tokenFeeTreasurySy.toBase58(),
+    address: market.selfAddress.toBase58(),
+    addressLookupTable: market.addressLookupTable.toBase58(),
+    tokenSyEscrow: market.tokenSyEscrow.toBase58(),
+    tokenPtEscrow: market.tokenPtEscrow.toBase58(),
+    tokenLpEscrow: market.tokenLpEscrow.toBase58(),
+    lpSupply: market.state.lpSupply.toString(),
+    syProgram: market.state.syProgram.toBase58(),
+    mintPt: market.state.mintPt.toBase58(),
+    mintSy: market.state.mintSy.toBase58(),
+    mintLp: market.state.mintLp.toBase58(),
+    feeTreasurySyBps: market.state.feeTreasurySyBps,
+    ptBalance: market.state.ptBalance.toString(),
+    syBalance: market.state.syBalance.toString(),
+    currentSyRate: market.flavor.currentSyExchangeRate,
+    expirationTs: market.state.expirationTs,
+    expirationDate: new Date(market.state.expirationTs * 1000).toISOString(),
+    lnFeeRateRoot: market.state.lnFeeRateRoot,
+    rateScalarRoot: market.state.rateScalarRoot,
+    lastLnImpliedRate: market.state.lastLnImpliedRate,
+    currentPtPriceInSy: market.currentPtPriceInSy,
+    currentPtPriceInAsset: market.currentPtPriceInAsset,
+    secondsRemaining: market.secondsRemaining,
+    proportionPtInAsset: marketCalculator.proportionPtInAsset,
+    proportionPtInSy: marketCalculator.proportionPtInSy,
+    currentFeeRate: marketCalculator.feeRate,
+    currentRateScalar: marketCalculator.rateScalar,
+    currentRateAnchor: marketCalculator.findRateAnchor(),
+    cpiAccounts: serializeCpiAccountsRaw(market.cpiAccounts),
     emissions: {
-      trackers: m.marketEmissions.trackers.map((e) => ({
+      trackers: market.marketEmissions.trackers.map((e) => ({
         tokenEscrow: e.tokenEscrow.toBase58(),
         lpShareIndex: e.lpShareIndex,
         lastSeenStaged: e.lastSeenStaged,
       })),
     },
-    ptApr: m.ptApr,
-    lpEscrowAmount: m.state.lpEscrowAmount.toString(),
-    maxLpSupply: m.state.maxLpSupply.toString(),
+    ptApr: market.ptApr,
+    ptApy: market.ptApy,
+    lpEscrowAmount: market.state.lpEscrowAmount.toString(),
+    maxLpSupply: market.state.maxLpSupply.toString(),
     liquidityNetBalanceLimits: {
-      windowStartTimestamp: m.state.liquidityNetBalanceLimits.windowStartTimestamp,
-      windowStartNetBalance: m.state.liquidityNetBalanceLimits.windowStartNetBalance.toString(),
-      maxNetBalanceChangeNegativePercentage: m.state.liquidityNetBalanceLimits.maxNetBalanceChangeNegativePercentage,
-      maxNetBalanceChangePositivePercentage: m.state.liquidityNetBalanceLimits.maxNetBalanceChangePositivePercentage,
-      windowDurationSeconds: m.state.liquidityNetBalanceLimits.windowDurationSeconds,
+      windowStartTimestamp: market.state.liquidityNetBalanceLimits.windowStartTimestamp,
+      windowStartNetBalance: market.state.liquidityNetBalanceLimits.windowStartNetBalance.toString(),
+      maxNetBalanceChangeNegativePercentage:
+        market.state.liquidityNetBalanceLimits.maxNetBalanceChangeNegativePercentage,
+      maxNetBalanceChangePositivePercentage:
+        market.state.liquidityNetBalanceLimits.maxNetBalanceChangePositivePercentage,
+      windowDurationSeconds: market.state.liquidityNetBalanceLimits.windowDurationSeconds,
     },
     lpFarm: {
-      lastSeenTimestamp: m.state.lpFarm.lastSeenTimestamp,
-      farmEmissions: m.state.lpFarm.farmEmissions.map((e) => ({
+      lastSeenTimestamp: market.state.lpFarm.lastSeenTimestamp,
+      farmEmissions: market.state.lpFarm.farmEmissions.map((e) => ({
         mint: e.mint.toBase58(),
         tokenRate: e.tokenRate.toString(),
         expiryTimestamp: e.expiryTimestamp,