@exponent-labs/exponent-sdk 0.1.8 → 0.9.0

package/src/market.ts

@@ -1,22 +1,26 @@
-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,
-  serializeCpiAccountsRaw,
   SyPosition,
+  serializeCpiAccountsRaw,
+} from "@exponent-labs/exponent-types"
+import {
+  FlavorGenericStateJson,
+  SyPositionJson,
+  VaultJson,
+  deserializeCpiAccountsRaw,
 } from "@exponent-labs/exponent-types"
-import { LiquidityAdd, lpOutForTokensIn, MarketCalculator } from "@exponent-labs/market-math"
+import { LiquidityAdd, MarketCalculator, lpOutForTokensIn } from "@exponent-labs/market-math"
 import { PreciseNumber } from "@exponent-labs/precise-number"
 
 import { fetchAddressLookupTable, makeCpiAccountMetaLists } from "./addressLookupTableUtil"
@@ -30,33 +34,28 @@ import {
   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"
-
+import { Connection, PublicKey, SYSVAR_RENT_PUBKEY, SystemProgram, TransactionInstruction } from "@solana/web3.js"
+import * as exponentCore from "./client/core"
+import BN from 'bn.js'
 export type { LiquidityAdd }
 
 const SECONDS_PER_YEAR = 365 * 24 * 60 * 60
 
 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
@@ -68,20 +67,7 @@ interface Emission {
   index: AnchorizedPNum
 }
 
-export type MarketAdminAction =
-  | { setStatus: [number] }
-  | { setMaxLpSupply: [BN] }
-  | { changeTreasuryTradeSyBpsFee: [number] }
-  | { changeLnFeeRateRoot: [number] }
-  | { changeRateScalarRoot: [number] }
-  | {
-      changeLiquidityNetBalanceLimits: {
-        maxNetBalanceChangeNegativePercentage: number
-        maxNetBalanceChangePositivePercentage: number
-        windowDurationSeconds: number
-      }
-    }
-  | { removeMarketEmission: [number] }
+export type MarketAdminAction = exponentCore.MarketAdminAction
 
 type MarketArgs = {
   ptBalance: bigint
@@ -94,19 +80,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
@@ -114,7 +100,7 @@ type MarketArgs = {
   syPosition: SyPosition
   emissions: {
     trackers: {
-      tokenEscrow: web3.PublicKey
+      tokenEscrow: PublicKey
       lpShareIndex: number
       lastSeenStaged: number
     }[]
@@ -122,36 +108,6 @@ type MarketArgs = {
   seedId: number[]
 }
 
-//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
-  }
-
-  async signTransaction<T extends web3.Transaction | web3.VersionedTransaction>(tx: T): Promise<T> {
-    if (tx instanceof web3.Transaction) {
-      tx.partialSign(this.payer)
-    } else {
-      tx.sign([this.payer])
-    }
-    return tx
-  }
-
-  async signAllTransactions<T extends web3.Transaction | web3.VersionedTransaction>(txs: T[]): Promise<T[]> {
-    return txs.map((t) => {
-      if (t instanceof web3.Transaction) {
-        t.partialSign(this.payer)
-      } else if (t instanceof web3.VersionedTransaction) {
-        t.sign([this.payer])
-      }
-      return t
-    })
-  }
-
-  get publicKey(): web3.PublicKey {
-    return this.payer.publicKey
-  }
-}
 
 export interface MarketLoadOptions {
   syConfig?: {
@@ -160,24 +116,21 @@ export interface MarketLoadOptions {
 }
 
 export class Market {
-  coreProgram: Program<ExponentCore>
   xponPda: ExponentPDA
 
   constructor(
     public state: MarketArgs,
-    public selfAddress: web3.PublicKey,
+    public selfAddress: PublicKey,
     public env: Environment,
-    public connection: web3.Connection,
+    public connection: Connection,
   ) {
     this.xponPda = new ExponentPDA(env.coreProgramId)
-    const mockWallet = new MyWallet(web3.Keypair.generate())
-    this.coreProgram = new Program(IDL as ExponentCore, new AnchorProvider(connection, mockWallet))
   }
 
   static async load(
     env: Environment,
-    connection: web3.Connection,
-    address: web3.PublicKey,
+    connection: Connection,
+    address: PublicKey,
     vault?: Vault,
     options: MarketLoadOptions = {},
   ): Promise<Market> {
@@ -221,7 +174,7 @@ export class Market {
     return new Market(state, address, env, connection)
   }
 
-  async reload(connection: web3.Connection = this.connection) {
+  async reload(connection: Connection = this.connection) {
     const market = await Market.load(this.env, connection, this.selfAddress)
     this.state = market.state
     return market
@@ -343,26 +296,26 @@ export class Market {
   }
 
   /** Get the escrow token account addresses for the emissions, in order */
-  get emissionTokenAccounts(): web3.PublicKey[] {
+  get emissionTokenAccounts(): PublicKey[] {
     return this.emissions.map((e) => e.escrowAccountAddress)
   }
 
   /** Pass-through SY account owned by the market */
-  get tokenSyEscrow(): web3.PublicKey {
+  get tokenSyEscrow(): PublicKey {
     return this.state.tokenSyEscrow
   }
 
   /** SY account that holds treasury SY fees from PT trading */
-  get tokenFeeTreasurySy(): web3.PublicKey {
+  get tokenFeeTreasurySy(): PublicKey {
     return this.state.tokenFeeTreasurySy
   }
 
   /** Market liquidity for PT */
-  get tokenPtEscrow(): web3.PublicKey {
+  get tokenPtEscrow(): PublicKey {
     return this.state.tokenPtEscrow
   }
 
-  get tokenLpEscrow(): web3.PublicKey {
+  get tokenLpEscrow(): PublicKey {
     return this.state.tokenLpEscrow
   }
 
@@ -371,7 +324,7 @@ export class Market {
   }
 
   /** Special account for event emit self-cpi */
-  get eventAuthority(): web3.PublicKey {
+  get eventAuthority(): PublicKey {
     return emitEventAuthority(this.env.coreProgramId)
   }
 
@@ -489,7 +442,7 @@ export class Market {
    *
    * The token accounts themselves are optional, and will be derived from the depositor's wallet if not provided
    */
-  async ixDepositLiquidity({
+  ixDepositLiquidity({
     ptInIntent,
     syInIntent,
     minLpOut,
@@ -504,26 +457,19 @@ export class Market {
     syInIntent: bigint
     /** Minimum LP tokens out */
     minLpOut: bigint
-    depositor: web3.PublicKey
-    ptSrc?: web3.PublicKey
-    sySrc?: web3.PublicKey
-    lpDst?: web3.PublicKey
-  }) {
-    const tokenProgram = TOKEN_PROGRAM_ID
-
+    depositor: PublicKey
+    ptSrc?: PublicKey
+    sySrc?: PublicKey
+    lpDst?: PublicKey
+  }): TransactionInstruction {
     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
 
-    return this.coreProgram.methods
-      .marketTwoDepositLiquidity(
-        new BN(ptInIntent.toString()),
-        new BN(syInIntent.toString()),
-        new BN(minLpOut.toString()),
-      )
-      .accountsStrict({
+    const ix = exponentCore.createMarketTwoDepositLiquidityInstruction(
+      {
         depositor,
         market: this.selfAddress,
         mintLp: this.mintLp,
@@ -534,27 +480,29 @@ export class Market {
         tokenSyEscrow: this.tokenSyEscrow,
         addressLookupTable: this.addressLookupTable,
         syProgram: this.syProgram,
-        tokenProgram,
+        tokenProgram: TOKEN_PROGRAM_ID,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(syRemAccounts)
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { ptIntent: ptInIntent, syIntent: syInIntent, minLpOut },
+    )
+    ix.keys.push(...syRemAccounts)
+    return ix
   }
 
-  async ixModifyMarketSetting({ signer, adminAction }: { signer: web3.PublicKey; adminAction: MarketAdminAction }) {
-    return this.coreProgram.methods
-      .modifyMarketSetting(adminAction)
-      .accountsStrict({
+  ixModifyMarketSetting({ signer, adminAction }: { signer: PublicKey; adminAction: exponentCore.MarketAdminAction }): TransactionInstruction {
+    return exponentCore.createModifyMarketSettingInstruction(
+      {
         market: this.selfAddress,
         adminState: getExponentAdminStatePda(),
         signer,
-        systemProgram: web3.SystemProgram.programId,
-      })
-      .instruction()
+        systemProgram: SystemProgram.programId,
+      },
+      { action: adminAction },
+    )
   }
 
-  async ixModifyFarm({
+  ixModifyFarm({
     newRate,
     untilTimestamp,
     signer,
@@ -564,27 +512,26 @@ export class Market {
   }: {
     newRate: bigint
     untilTimestamp: number
-    signer: web3.PublicKey
-    farmMint: web3.PublicKey
-    farmTokenProgram: web3.PublicKey
-    farmTokenSrc?: web3.PublicKey
-  }) {
+    signer: PublicKey
+    farmMint: PublicKey
+    farmTokenProgram: PublicKey
+    farmTokenSrc?: PublicKey
+  }): TransactionInstruction {
     const farmTokenSrc = farmTokenSrcParam || getAssociatedTokenAddressSync(farmMint, signer, true, farmTokenProgram)
-
     const tokenFarm = getAssociatedTokenAddressSync(farmMint, this.selfAddress, true, farmTokenProgram)
 
-    return this.coreProgram.methods
-      .modifyFarm(untilTimestamp, new BN(newRate.toString()))
-      .accountsStrict({
-        adminState: getExponentAdminStatePda(),
+    return exponentCore.createModifyFarmInstruction(
+      {
         market: this.selfAddress,
-        mint: farmMint,
-        tokenFarm: tokenFarm,
         signer,
-        tokenProgram: farmTokenProgram,
+        mint: farmMint,
+        adminState: getExponentAdminStatePda(),
         tokenSource: farmTokenSrc,
-      })
-      .instruction()
+        tokenFarm,
+        tokenProgram: farmTokenProgram,
+      },
+      { untilTimestamp, newRate },
+    )
   }
 
   /**
@@ -596,7 +543,7 @@ export class Market {
    *
    * The token accounts themselves are optional, and will be derived from the withdrawer's wallet if not provided
    */
-  async ixWithdrawLiquidity({
+  ixWithdrawLiquidity({
     lpIn,
     withdrawer,
     minPtOut,
@@ -606,12 +553,12 @@ export class Market {
     lpSrc: lpSrcParam,
   }: {
     lpIn: bigint
-    withdrawer: web3.PublicKey
+    withdrawer: PublicKey
     minPtOut: bigint
     minSyOut: bigint
-    ptDst?: web3.PublicKey
-    syDst?: web3.PublicKey
-    lpSrc?: web3.PublicKey
+    ptDst?: PublicKey
+    syDst?: PublicKey
+    lpSrc?: PublicKey
   }) {
     const ptDst = ptDstParam || getAssociatedTokenAddressSync(this.mintPt, withdrawer, true, TOKEN_PROGRAM_ID)
     const syDst = syDstParam || getAssociatedTokenAddressSync(this.mintSy, withdrawer, true, TOKEN_PROGRAM_ID)
@@ -623,27 +570,27 @@ export class Market {
 
     const syRemAccounts = this.cpiAccounts.withdrawSy
 
-    const ixs = await this.coreProgram.methods
-      .marketTwoWithdrawLiquidity(new BN(lpIn.toString()), new BN(minPtOut.toString()), new BN(minSyOut.toString()))
-      .accountsStrict({
+    const ix = exponentCore.createMarketTwoWithdrawLiquidityInstruction(
+      {
         withdrawer,
         market: this.selfAddress,
-        mintLp: this.mintLp,
         tokenPtDst: ptDst,
         tokenSyDst: syDst,
-        tokenLpSrc: lpSrc,
         tokenPtEscrow: this.tokenPtEscrow,
         tokenSyEscrow: this.tokenSyEscrow,
+        tokenLpSrc: lpSrc,
+        mintLp: this.mintLp,
         addressLookupTable: this.addressLookupTable,
-        syProgram: this.syProgram,
         tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(syRemAccounts)
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { lpIn, minPtOut, minSyOut },
+    )
+    ix.keys.push(...syRemAccounts)
 
-    return { ixs: [ixs], setupIxs: [ptDstAtaIx, syDstAtaIx, lpSrcAtaIx] }
+    return { ixs: [ix], setupIxs: [ptDstAtaIx, syDstAtaIx, lpSrcAtaIx] }
   }
 
   /** Buy PT with SY
@@ -661,11 +608,11 @@ export class Market {
     tokenPt,
     tokenSy,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     amountPt: bigint
     maxSySpend: bigint
-    tokenPt?: web3.PublicKey
-    tokenSy?: web3.PublicKey
+    tokenPt?: PublicKey
+    tokenSy?: PublicKey
   }) {
     return this.ixTradePt({
       trader,
@@ -692,11 +639,11 @@ export class Market {
     tokenPt,
     tokenSy,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     amountPt: bigint
     minSyReceive: bigint
-    tokenPt?: web3.PublicKey
-    tokenSy?: web3.PublicKey
+    tokenPt?: PublicKey
+    tokenSy?: PublicKey
   }) {
     return this.ixTradePt({
       trader,
@@ -708,7 +655,7 @@ export class Market {
     })
   }
 
-  async ixTradePt({
+  ixTradePt({
     trader,
     traderPt,
     syConstraint,
@@ -716,12 +663,12 @@ export class Market {
     tokenPt: tokenPtParam,
     tokenSy: tokenSyParam,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     traderPt: bigint
     syConstraint: bigint
     isBuy: boolean
-    tokenPt?: web3.PublicKey
-    tokenSy?: web3.PublicKey
+    tokenPt?: PublicKey
+    tokenSy?: PublicKey
   }) {
     const tokenPt = tokenPtParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
     const tokenSy = tokenSyParam || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
@@ -735,16 +682,15 @@ export class Market {
       ...this.cpiAccounts.withdrawSy,
     ]
 
-    const netTradePtBN = new BN(traderPt.toString()).mul(isBuy ? new BN(1) : new BN(-1))
-    const syConstraintBN = new BN(syConstraint.toString()).mul(isBuy ? new BN(-1) : new BN(1))
+    const netTraderPt = isBuy ? traderPt : -traderPt
+    const syConstraintSigned = isBuy ? -syConstraint : syConstraint
 
-    const ix = await this.coreProgram.methods
-      .tradePt(netTradePtBN, syConstraintBN)
-      .accountsStrict({
+    const ix = exponentCore.createTradePtInstruction(
+      {
         trader,
         market: this.selfAddress,
-        tokenPtTrader: tokenPt,
         tokenSyTrader: tokenSy,
+        tokenPtTrader: tokenPt,
         tokenSyEscrow: this.tokenSyEscrow,
         tokenPtEscrow: this.tokenPtEscrow,
         addressLookupTable: this.addressLookupTable,
@@ -752,10 +698,11 @@ export class Market {
         syProgram: this.syProgram,
         tokenFeeTreasurySy: this.vault.state.treasurySyTokenAccount,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { netTraderPt, syConstraint: syConstraintSigned },
+    )
+    ix.keys.push(...remainingAccounts)
 
     return { ixs: [ix], setupIxs: [tokenPtAtaIx, tokenSyAtaIx] }
   }
@@ -770,7 +717,7 @@ export class Market {
    *
    * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
    */
-  async ixSellYt({
+  ixSellYt({
     trader,
     ytIn,
     minSyOut,
@@ -778,12 +725,12 @@ export class Market {
     ptSrc: ptSrcParam,
     syDst: syDstParam,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     ytIn: bigint
     minSyOut: bigint
-    ytSrc?: web3.PublicKey
-    ptSrc?: web3.PublicKey
-    syDst?: web3.PublicKey
+    ytSrc?: PublicKey
+    ptSrc?: PublicKey
+    syDst?: PublicKey
   }) {
     const syDst = syDstParam || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
     const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
@@ -799,11 +746,10 @@ export class Market {
       ...this.cpiAccounts.depositSy,
       ...mergeAccounts.remainingAccounts,
     ])
-    remainingAccounts.push({ pubkey: this.coreProgram.programId, isWritable: false, isSigner: false })
+    remainingAccounts.push({ pubkey: exponentCore.EXPONENTCORE_PROGRAM_ID, isWritable: false, isSigner: false })
 
-    const ix = await this.coreProgram.methods
-      .sellYt(new BN(ytIn.toString()), new BN(minSyOut.toString()))
-      .accountsStrict({
+    const ix = exponentCore.createSellYtInstruction(
+      {
         trader,
         market: this.selfAddress,
         tokenYtTrader: ytSrc,
@@ -812,6 +758,7 @@ export class Market {
         tokenSyEscrow: this.tokenSyEscrow,
         tokenPtEscrow: this.tokenPtEscrow,
         addressLookupTable: this.addressLookupTable,
+        tokenFeeTreasurySy: this.vault.state.treasurySyTokenAccount,
         tokenProgram: TOKEN_PROGRAM_ID,
         vault: mergeAccounts.mainAccounts.vault,
         authorityVault: mergeAccounts.mainAccounts.authority,
@@ -821,12 +768,12 @@ export class Market {
         addressLookupTableVault: mergeAccounts.mainAccounts.addressLookupTable,
         yieldPositionVault: mergeAccounts.mainAccounts.yieldPosition,
         syProgram: this.syProgram,
-        tokenFeeTreasurySy: this.vault.state.treasurySyTokenAccount,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { ytIn, minSyOut },
+    )
+    ix.keys.push(...remainingAccounts)
 
     return { ixs: [ix], setupIxs: [syDstAtaIxs, ptSrcAtaIxs, ytSrcAtaIxs] }
   }
@@ -841,7 +788,7 @@ export class Market {
    *
    * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
    */
-  async ixBuyYt({
+  ixBuyYt({
     trader,
     ytOut,
     maxSyIn,
@@ -849,12 +796,12 @@ export class Market {
     ptTrader: ptTraderParam,
     syTrader: syTraderParam,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     ytOut: bigint
     maxSyIn: bigint
-    ytTrader?: web3.PublicKey
-    ptTrader?: web3.PublicKey
-    syTrader?: web3.PublicKey
+    ytTrader?: PublicKey
+    ptTrader?: PublicKey
+    syTrader?: PublicKey
   }) {
     const syTrader = syTraderParam || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
     const ptTrader = ptTraderParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
@@ -877,126 +824,125 @@ export class Market {
       ...this.cpiAccounts.depositSy,
       ...stripAccounts.remainingAccounts,
     ])
-    remainingAccounts.push({ pubkey: this.coreProgram.programId, isWritable: false, isSigner: false })
+    remainingAccounts.push({ pubkey: exponentCore.EXPONENTCORE_PROGRAM_ID, isWritable: false, isSigner: false })
 
-    const ix = await this.coreProgram.methods
-      .buyYt(new BN(maxSyIn.toString()), new BN(ytOut.toString()))
-      .accountsStrict({
+    const ix = exponentCore.createBuyYtInstruction(
+      {
         trader,
         market: this.selfAddress,
+        tokenSyTrader: syTrader,
         tokenYtTrader: ytTrader,
         tokenPtTrader: ptTrader,
-        tokenSyTrader: syTrader,
         tokenSyEscrow: this.tokenSyEscrow,
         tokenPtEscrow: this.tokenPtEscrow,
-        addressLookupTable: this.addressLookupTable,
+        tokenFeeTreasurySy: this.vault.state.treasurySyTokenAccount,
         tokenProgram: TOKEN_PROGRAM_ID,
+        addressLookupTable: this.addressLookupTable,
         syProgram: this.syProgram,
-        vault: stripAccounts.mainAccounts.vault,
         vaultAuthority: stripAccounts.mainAccounts.authority,
+        vault: stripAccounts.mainAccounts.vault,
         tokenSyEscrowVault: stripAccounts.mainAccounts.escrowSy,
         mintYt: this.mintYt,
         mintPt: this.mintPt,
         addressLookupTableVault: stripAccounts.mainAccounts.addressLookupTable,
         yieldPosition: stripAccounts.mainAccounts.yieldPosition,
-        tokenFeeTreasurySy: this.vault.state.treasurySyTokenAccount,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { syIn: maxSyIn, ytOut },
+    )
+    ix.keys.push(...remainingAccounts)
 
     return { ixs: [ix], setupIxs: [syTraderAtaIx, ptTraderAtaIx, ytTraderAtaIx] }
   }
 
-  async ixInitLpPosition({ owner, feePayer }: { owner: web3.PublicKey; feePayer?: web3.PublicKey }) {
+  ixInitLpPosition({ owner, feePayer }: { owner: PublicKey; feePayer?: PublicKey }): TransactionInstruction {
     const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner })
-    return this.coreProgram.methods
-      .initLpPosition()
-      .accountsStrict({
-        owner,
-        feePayer: feePayer || owner,
-        lpPosition,
-        market: this.selfAddress,
-        systemProgram: web3.SystemProgram.programId,
-        eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .instruction()
+    return exponentCore.createInitLpPositionInstruction({
+      feePayer: feePayer || owner,
+      owner,
+      market: this.selfAddress,
+      lpPosition,
+      systemProgram: SystemProgram.programId,
+      eventAuthority: this.vault.eventAuthority,
+      program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+    })
   }
 
   /** Deposit LP tokens into the farming module to earn rewards */
-  async ixDepositLp({
+  ixDepositLp({
     owner,
     amount,
     lpSrc: lpSrcParam,
   }: {
-    owner: web3.PublicKey
+    owner: PublicKey
     amount: bigint
-    lpSrc?: web3.PublicKey
-  }) {
+    lpSrc?: PublicKey
+  }): TransactionInstruction {
     const lpSrc = lpSrcParam || getAssociatedTokenAddressSync(this.mintLp, owner, true, TOKEN_PROGRAM_ID)
     const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner })
 
-    return this.coreProgram.methods
-      .marketDepositLp(new BN(amount.toString()))
-      .accountsStrict({
+    const ix = exponentCore.createMarketDepositLpInstruction(
+      {
         owner,
+        market: this.selfAddress,
         lpPosition,
         tokenLpSrc: lpSrc,
         tokenLpEscrow: this.tokenLpEscrow,
-        market: this.selfAddress,
-        addressLookupTable: this.addressLookupTable,
+        mintLp: this.mintLp,
         syProgram: this.syProgram,
+        addressLookupTable: this.addressLookupTable,
         tokenProgram: TOKEN_PROGRAM_ID,
-        mintLp: this.mintLp,
-        systemProgram: web3.SystemProgram.programId,
+        systemProgram: SystemProgram.programId,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(this.cpiAccounts.getPositionState)
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { amount },
+    )
+    ix.keys.push(...this.cpiAccounts.getPositionState)
+    return ix
   }
 
   /** Withdraw LP tokens from the farming module */
-  async ixWithdrawLp({
+  ixWithdrawLp({
     owner,
     amount,
     lpDst: lpDstParam,
   }: {
-    owner: web3.PublicKey
+    owner: PublicKey
     amount: bigint
-    lpDst?: web3.PublicKey
-  }) {
+    lpDst?: PublicKey
+  }): TransactionInstruction {
     const lpDst = lpDstParam || getAssociatedTokenAddressSync(this.mintLp, owner, true, TOKEN_PROGRAM_ID)
 
     const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner })
-    return this.coreProgram.methods
-      .marketWithdrawLp(new BN(amount.toString()))
-      .accountsStrict({
+    const ix = exponentCore.createMarketWithdrawLpInstruction(
+      {
         owner,
+        market: this.selfAddress,
+        mintLp: this.mintLp,
         lpPosition,
         tokenLpDst: lpDst,
         tokenLpEscrow: this.tokenLpEscrow,
-        market: this.selfAddress,
-        addressLookupTable: this.addressLookupTable,
-        mintLp: this.mintLp,
         syProgram: this.syProgram,
+        addressLookupTable: this.addressLookupTable,
         tokenProgram: TOKEN_PROGRAM_ID,
-        systemProgram: web3.SystemProgram.programId,
+        systemProgram: SystemProgram.programId,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(this.cpiAccounts.getPositionState)
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { amount },
+    )
+    ix.keys.push(...this.cpiAccounts.getPositionState)
+    return ix
   }
 
   async ixWrapperCollectInterest({
     claimer,
     tokenSyDst: tokenSyDstParam,
   }: {
-    claimer: web3.PublicKey
-    tokenSyDst?: web3.PublicKey
+    claimer: PublicKey
+    tokenSyDst?: PublicKey
   }) {
     const yieldPosition = this.xponPda.yieldPosition({ owner: claimer, vault: this.vault.selfAddress })
     const tokenSyDst = tokenSyDstParam || getAssociatedTokenAddressSync(this.mintSy, claimer, true, TOKEN_PROGRAM_ID)
@@ -1034,24 +980,24 @@ export class Market {
       redeemerSyTokenAccount: tokenSyDst,
     })
 
-    const ix = await this.coreProgram.methods
-      .wrapperCollectInterest(redeemSyIx.keys.length)
-      .accountsStrict({
-        addressLookupTable: this.vault.addressLookupTable,
-        authority: this.vault.state.authority,
+    const ix = exponentCore.createWrapperCollectInterestInstruction(
+      {
         claimer,
+        authority: this.vault.state.authority,
+        vault: this.vault.selfAddress,
+        addressLookupTable: this.vault.addressLookupTable,
         escrowSy: this.vault.escrowSy,
         syProgram: this.syProgram,
-        vault: this.vault.selfAddress,
         tokenProgram: TOKEN_PROGRAM_ID,
-        treasurySyTokenAccount: this.vault.state.treasurySyTokenAccount,
-        yieldPosition: yieldPosition,
+        yieldPosition,
         tokenSyDst,
+        treasurySyTokenAccount: this.vault.state.treasurySyTokenAccount,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(redeemSyIx.keys.concat(remainingAccounts))
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { redeemSyAccountsLength: redeemSyIx.keys.length },
+    )
+    ix.keys.push(...redeemSyIx.keys.concat(remainingAccounts))
 
     return {
       ixs: [
@@ -1071,12 +1017,12 @@ export class Market {
     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
   }) {
     const tokenSyTrader =
       tokenSyTraderParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
@@ -1115,10 +1061,8 @@ export class Market {
 
     const mintSyRemAccounts = mintSyIx.keys
 
-    // console.log("mintSyRemAccounts", mintSyRemAccounts)
-
     mintSyRemAccounts.push({
-      pubkey: this.coreProgram.programId,
+      pubkey: exponentCore.EXPONENTCORE_PROGRAM_ID,
       isWritable: false,
       isSigner: false,
     })
@@ -1126,27 +1070,26 @@ export class Market {
     const remainingAccounts = uniqueRemainingAccounts([
       ...this.cpiAccounts.getSyState,
       ...this.cpiAccounts.depositSy,
-      // ...this.cpiAccounts.withdrawSy,
     ])
 
-    const ix = await this.coreProgram.methods
-      .wrapperBuyPt(new BN(ptOut.toString()), new BN(maxBaseIn.toString()), mintSyRemAccounts.length - 1)
-      .accountsStrict({
-        addressLookupTable: this.addressLookupTable,
+    const ix = exponentCore.createWrapperBuyPtInstruction(
+      {
         buyer: owner,
         market: this.selfAddress,
         tokenSyTrader,
         tokenPtTrader,
         tokenSyEscrow: this.tokenSyEscrow,
         tokenPtEscrow: this.tokenPtEscrow,
+        addressLookupTable: this.addressLookupTable,
         tokenProgram: TOKEN_PROGRAM_ID,
         syProgram: this.syProgram,
         tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { ptAmount: ptOut, maxBaseAmount: maxBaseIn, mintSyRemAccountsUntil: mintSyRemAccounts.length - 1 },
+    )
+    ix.keys.push(...mintSyRemAccounts.concat(remainingAccounts))
 
     return {
       ixs: [...(await this.flavor.preIxs({ signer: owner })), ix, ...(await this.flavor.postIxs({ signer: owner }))],
@@ -1162,12 +1105,12 @@ export class Market {
     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
   }) {
     const tokenSyTrader =
       tokenSyTraderParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
@@ -1208,24 +1151,24 @@ export class Market {
 
     const remainingAccounts = uniqueRemainingAccounts([...this.cpiAccounts.getSyState, ...this.cpiAccounts.withdrawSy])
 
-    const ix = await this.coreProgram.methods
-      .wrapperSellPt(new BN(amount.toString()), new BN(minBaseOut.toString()), redeemSyRemAccounts.length)
-      .accountsStrict({
+    const ix = exponentCore.createWrapperSellPtInstruction(
+      {
         seller: owner,
         market: this.selfAddress,
+        tokenSyTrader,
         tokenPtTrader,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
         addressLookupTable: this.addressLookupTable,
         tokenProgram: TOKEN_PROGRAM_ID,
         syProgram: this.syProgram,
-        tokenSyTrader,
-        tokenPtEscrow: this.tokenPtEscrow,
-        tokenSyEscrow: this.tokenSyEscrow,
         tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { amountPt: amount, minBaseAmount: minBaseOut, redeemSyRemAccountsUntil: redeemSyRemAccounts.length },
+    )
+    ix.keys.push(...redeemSyRemAccounts.concat(remainingAccounts))
 
     return {
       ixs: [...(await this.flavor.preIxs({ signer: owner })), ix, ...(await this.flavor.postIxs({ signer: owner }))],
@@ -1242,13 +1185,13 @@ export class Market {
     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
   }) {
     const tokenSyTrader =
       tokenSyTraderParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
@@ -1298,9 +1241,8 @@ 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)
-      .accountsStrict({
+    const ix1 = exponentCore.createWrapperBuyYtInstruction(
+      {
         buyer: owner,
         market: this.selfAddress,
         tokenSyTrader,
@@ -1309,24 +1251,25 @@ export class Market {
         tokenSyEscrow: this.tokenSyEscrow,
         tokenPtEscrow: this.tokenPtEscrow,
         marketAddressLookupTable: this.addressLookupTable,
-        vault: this.vault.selfAddress,
-        vaultAuthority: this.vault.authority,
-        tokenSyEscrowVault: this.vault.escrowSy,
-        vaultAddressLookupTable: this.vault.addressLookupTable,
         tokenProgram: TOKEN_PROGRAM_ID,
         syProgram: this.syProgram,
+        vaultAuthority: this.vault.authority,
+        vault: this.vault.selfAddress,
+        tokenSyEscrowVault: this.vault.escrowSy,
+        mintYt: this.vault.mintYt,
         mintPt: this.vault.mintPt,
+        vaultAddressLookupTable: this.vault.addressLookupTable,
+        userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner }),
         yieldPosition: this.vault.state.yieldPositonAddress,
-        mintYt: this.vault.mintYt,
         escrowYt: this.vault.escrowYt,
-        systemProgram: web3.SystemProgram.programId,
-        userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner }),
+        systemProgram: SystemProgram.programId,
         tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(allRemainingAccounts)
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { ytOut, maxBaseAmount: maxBaseIn, mintSyAccountsLength: mintSyRemAccounts.length },
+    )
+    ix1.keys.push(...allRemainingAccounts)
 
     return {
       ixs: [...(await this.flavor.preIxs({ signer: owner })), ix1, ...(await this.flavor.postIxs({ signer: owner }))],
@@ -1343,13 +1286,13 @@ export class Market {
     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
   }) {
     const tokenBaseTrader =
       tokenBaseTraderParam ||
@@ -1402,60 +1345,52 @@ export class Market {
       ...this.vault.cpiAccounts.depositSy,
     ])
 
-    // console.log(" remaining accounts length", remainingAccounts.length)
-
-    // remainingAccounts.push({
-    //   pubkey: this.coreProgram.programId,
-    //   isWritable: false,
-    //   isSigner: false,
-    // })
-
-    const ix1 = await this.coreProgram.methods
-      .withdrawYt(new BN(amount.toString()))
-      .accountsStrict({
+    const ix1 = exponentCore.createWithdrawYtInstruction(
+      {
+        owner,
+        vault: this.vault.selfAddress,
+        userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner }),
         ytDst: tokenYtTrader,
         escrowYt: this.vault.escrowYt,
         tokenProgram: TOKEN_PROGRAM_ID,
+        authority: this.vault.authority,
         syProgram: this.syProgram,
         addressLookupTable: this.vault.addressLookupTable,
-        systemProgram: web3.SystemProgram.programId,
-        eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
         yieldPosition: this.vault.state.yieldPositonAddress,
-        userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner }),
-        authority: this.vault.authority,
-        owner,
-        vault: this.vault.selfAddress,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction()
+        systemProgram: SystemProgram.programId,
+        eventAuthority: this.vault.eventAuthority,
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { amount },
+    )
+    ix1.keys.push(...remainingAccounts)
 
-    const ix2 = await this.coreProgram.methods
-      .wrapperSellYt(new BN(amount.toString()), new BN(minBaseOut.toString()), redeemSyRemAccounts.length)
-      .accountsStrict({
+    const ix2 = exponentCore.createWrapperSellYtInstruction(
+      {
         seller: owner,
         market: this.selfAddress,
+        tokenSyTrader,
         tokenYtTrader,
-        marketAddressLookupTable: this.addressLookupTable,
-        vault: this.vault.selfAddress,
-        vaultAuthority: this.vault.authority,
         tokenPtTrader,
+        tokenSyEscrow: this.tokenSyEscrow,
         tokenPtEscrow: this.tokenPtEscrow,
+        marketAddressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        vaultAuthority: this.vault.authority,
+        vault: this.vault.selfAddress,
         tokenSyEscrowVault: this.vault.escrowSy,
+        mintYt: this.vault.mintYt,
+        mintPt: this.vault.mintPt,
         vaultAddressLookupTable: this.vault.addressLookupTable,
         yieldPosition: this.vault.state.yieldPositonAddress,
-        mintPt: this.vault.mintPt,
-        mintYt: this.vault.mintYt,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        syProgram: this.syProgram,
-        tokenSyTrader,
-        tokenSyEscrow: this.tokenSyEscrow,
         tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { ytAmount: amount, minBaseAmount: minBaseOut, redeemSyAccountsUntil: redeemSyRemAccounts.length },
+    )
+    ix2.keys.push(...redeemSyRemAccounts.concat(remainingAccounts))
 
     return {
       ixs: [
@@ -1468,14 +1403,14 @@ export class Market {
     }
   }
 
-  async ixCollectMarketEmission({
+  ixCollectMarketEmission({
     owner,
     emissionIndex,
     emissionDst,
   }: {
-    owner: web3.PublicKey
+    owner: PublicKey
     emissionIndex: number
-    emissionDst?: web3.PublicKey
+    emissionDst?: PublicKey
   }) {
     const emission = this.emissions[emissionIndex]
     const tokenEmissionDst =
@@ -1487,22 +1422,22 @@ export class Market {
       owner,
       emission.mint,
     )
-    const ix = await this.coreProgram.methods
-      .marketCollectEmission(emissionIndex)
-      .accountsStrict({
-        addressLookupTable: this.addressLookupTable,
-        lpPosition: this.xponPda.marketLpPosition({ market: this.selfAddress, owner }),
-        market: this.selfAddress,
+    const ix = exponentCore.createMarketCollectEmissionInstruction(
+      {
         owner,
-        syProgram: this.syProgram,
-        tokenEmissionDst,
+        market: this.selfAddress,
+        lpPosition: this.xponPda.marketLpPosition({ market: this.selfAddress, owner }),
         tokenEmissionEscrow: this.marketEmissions.trackers[emissionIndex].tokenEscrow,
+        tokenEmissionDst,
         tokenProgram: emission.tokenProgramAddress,
-        program: this.coreProgram.programId,
+        addressLookupTable: this.addressLookupTable,
+        syProgram: this.syProgram,
         eventAuthority: this.eventAuthority,
-      })
-      .remainingAccounts(this.cpiAccounts.claimEmission[emissionIndex])
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { emissionIndex },
+    )
+    ix.keys.push(...this.cpiAccounts.claimEmission[emissionIndex])
 
     return {
       ixs: [ix],
@@ -1521,14 +1456,14 @@ export class Market {
     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
   }) {
     const tokenSyDepositor =
       tokenSyDepositorParam || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
@@ -1570,8 +1505,7 @@ export class Market {
       this.mintLp,
     )
 
-    const amountBaseBn = new BN(amountBase.toString())
-    const minLpOutBn = new BN(minLpOut.toString())
+    // amountBase and minLpOut are already bigint
 
     // TODO - fix this
     const mintSyIx = await this.flavor.ixMintSy({
@@ -1604,7 +1538,7 @@ export class Market {
     const marketCpiRemainingAccounts = beforeMarketAccounts.filter(
       (account) =>
         account.pubkey.toBase58() !== TOKEN_PROGRAM_ID.toBase58() &&
-        account.pubkey.toBase58() !== web3.SystemProgram.programId.toBase58() &&
+        account.pubkey.toBase58() !== SystemProgram.programId.toBase58() &&
         account.pubkey.toBase58() !== this.selfAddress.toBase58(),
     )
 
@@ -1621,9 +1555,8 @@ export class Market {
 
     const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner: depositor })
 
-    const ix = await this.coreProgram.methods
-      .wrapperProvideLiquidity(amountBaseBn, minLpOutBn, mintSyRemAccounts.length)
-      .accountsStrict({
+    const ix = exponentCore.createWrapperProvideLiquidityInstruction(
+      {
         depositor,
         authority: this.vault.authority,
         vault: this.vault.selfAddress,
@@ -1632,29 +1565,28 @@ export class Market {
         tokenSyEscrow: this.tokenSyEscrow,
         tokenLpDst: tokenLpDepositor,
         mintLp: this.mintLp,
-        escrowSy: this.vault.escrowSy,
-        escrowYt: this.vault.escrowYt,
         tokenSyDepositor,
+        escrowSy: this.vault.escrowSy,
         tokenYtDepositor,
         tokenPtDepositor,
         mintYt: this.vault.mintYt,
         mintPt: this.vault.mintPt,
-        userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner: depositor }),
-        systemProgram: web3.SystemProgram.programId,
         tokenProgram: TOKEN_PROGRAM_ID,
-        syProgram: this.syProgram,
-        marketAddressLookupTable: this.addressLookupTable,
         vaultAddressLookupTable: this.vault.addressLookupTable,
+        marketAddressLookupTable: this.addressLookupTable,
+        syProgram: this.syProgram,
+        userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner: depositor }),
+        escrowYt: this.vault.escrowYt,
+        tokenLpEscrow: this.tokenLpEscrow,
+        lpPosition,
         vaultRobotYieldPosition: this.vault.state.yieldPositonAddress,
+        systemProgram: SystemProgram.programId,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-        lpPosition,
-        tokenLpEscrow: this.tokenLpEscrow,
-      })
-      .remainingAccounts(allRemainingAccounts)
-      .instruction()
-
-    // console.log("ix accounts length", ix.keys.length)
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { amountBase, minLpOut, mintBaseAccountsUntil: mintSyRemAccounts.length },
+    )
+    ix.keys.push(...allRemainingAccounts)
 
     return {
       ixs: [
@@ -1678,16 +1610,16 @@ export class Market {
     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
   }) {
     const tokenSyDepositor =
       tokenSyDepositorParam || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
@@ -1749,35 +1681,29 @@ export class Market {
 
     const mintSyRemAccounts = mintSyIx.keys
 
-    const ix = await this.coreProgram.methods
-      .wrapperProvideLiquidityBase(
-        new BN(amountBase.toString()),
-        new BN(minLpOut.toString()),
-        mintSyRemAccounts.length,
-        new BN(externalPtToBuy.toString()),
-        new BN(externalSyConstraint.toString()),
-      )
-      .accountsStrict({
+    const ix = exponentCore.createWrapperProvideLiquidityBaseInstruction(
+      {
         depositor,
-        lpPosition,
         market: this.selfAddress,
         tokenPtEscrow: this.tokenPtEscrow,
         tokenSyEscrow: this.tokenSyEscrow,
         tokenLpDst: tokenLpDepositor,
         mintLp: this.mintLp,
+        tokenSyDepositor,
+        tokenPtDepositor,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        marketAddressLookupTable: this.addressLookupTable,
         syProgram: this.syProgram,
         tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
         tokenLpEscrow: this.tokenLpEscrow,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        marketAddressLookupTable: this.addressLookupTable,
-        tokenPtDepositor,
-        tokenSyDepositor,
-        systemProgram: web3.SystemProgram.programId,
+        lpPosition,
+        systemProgram: SystemProgram.programId,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { amountBase, minLpOut, mintSyAccountsUntil: mintSyRemAccounts.length, externalPtToBuy, externalSyConstraint },
+    )
+    ix.keys.push(...mintSyRemAccounts.concat(remainingAccounts))
 
     return {
       ixs: [
@@ -1800,15 +1726,15 @@ export class Market {
     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
   }) {
     const tokenSyDepositor =
       tokenSyDepositorParam || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
@@ -1866,33 +1792,28 @@ export class Market {
 
     const mintSyRemAccounts = mintSyIx.keys
 
-    const ix = await this.coreProgram.methods
-      .wrapperProvideLiquidityClassic(
-        new BN(amountBase.toString()),
-        new BN(amountPt.toString()),
-        new BN(minLpOut.toString()),
-        mintSyRemAccounts.length,
-      )
-      .accountsStrict({
+    const ix = exponentCore.createWrapperProvideLiquidityClassicInstruction(
+      {
         depositor,
-        lpPosition,
         market: this.selfAddress,
         tokenPtEscrow: this.tokenPtEscrow,
         tokenSyEscrow: this.tokenSyEscrow,
         tokenLpDst: tokenLpDepositor,
         mintLp: this.mintLp,
-        syProgram: this.syProgram,
-        tokenLpEscrow: this.tokenLpEscrow,
+        tokenSyDepositor,
+        tokenPtDepositor,
         tokenProgram: TOKEN_PROGRAM_ID,
         marketAddressLookupTable: this.addressLookupTable,
-        tokenPtDepositor,
-        tokenSyDepositor,
-        systemProgram: web3.SystemProgram.programId,
+        syProgram: this.syProgram,
+        tokenLpEscrow: this.tokenLpEscrow,
+        lpPosition,
+        systemProgram: SystemProgram.programId,
         eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { amountBase, amountPt, minLpOut, mintSyAccountsUntil: mintSyRemAccounts.length },
+    )
+    ix.keys.push(...mintSyRemAccounts.concat(remainingAccounts))
 
     return {
       ixs: [
@@ -1914,14 +1835,14 @@ export class Market {
     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
   }) {
     const tokenSyWithdrawer =
       tokenSyWithdrawerParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
@@ -1965,33 +1886,29 @@ export class Market {
 
     const minSyOut = Number(minBaseOut) / this.currentSyExchangeRate
 
-    const ix = await this.coreProgram.methods
-      .wrapperWithdrawLiquidity(
-        new BN(amountLp.toString()),
-        new BN(minSyOut.toFixed(0).toString()),
-        redeemSyRemAccounts.length,
-      )
-      .accountsStrict({
+    const ix = exponentCore.createWrapperWithdrawLiquidityInstruction(
+      {
+        withdrawer: owner,
         market: this.selfAddress,
         tokenPtEscrow: this.tokenPtEscrow,
         tokenSyEscrow: this.tokenSyEscrow,
         tokenLpSrc: tokenLpWithdrawer,
-        lpPosition,
+        mintLp: this.mintLp,
+        tokenSyWithdrawer,
+        tokenPtWithdrawer,
+        tokenProgram: TOKEN_PROGRAM_ID,
         marketAddressLookupTable: this.addressLookupTable,
-        eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
         syProgram: this.syProgram,
-        systemProgram: web3.SystemProgram.programId,
-        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
         tokenLpEscrow: this.tokenLpEscrow,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        tokenPtWithdrawer,
-        tokenSyWithdrawer,
-        mintLp: this.mintLp,
-        withdrawer: owner,
-      })
-      .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
-      .instruction()
+        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+        lpPosition,
+        systemProgram: SystemProgram.programId,
+        eventAuthority: this.vault.eventAuthority,
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { amountLp, syConstraint: BigInt(minSyOut.toFixed(0)), redeemSyAccountsLength: redeemSyRemAccounts.length },
+    )
+    ix.keys.push(...redeemSyRemAccounts.concat(remainingAccounts))
 
     return {
       ixs: [...(await this.flavor.preIxs({ signer: owner })), ix, ...(await this.flavor.postIxs({ signer: owner }))],
@@ -2008,13 +1925,13 @@ export class Market {
     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
   }) {
     const tokenSyWithdrawer =
       tokenSyWithdrawerParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
@@ -2056,28 +1973,28 @@ export class Market {
 
     const redeemSyRemAccounts = redeemSyIx.keys
 
-    const ixn = await this.coreProgram.methods
-      .wrapperWithdrawLiquidityClassic(new BN(amountLp.toString()), redeemSyRemAccounts.length)
-      .accountsStrict({
+    const ixn = exponentCore.createWrapperWithdrawLiquidityClassicInstruction(
+      {
+        withdrawer: owner,
         market: this.selfAddress,
         tokenPtEscrow: this.tokenPtEscrow,
         tokenSyEscrow: this.tokenSyEscrow,
         tokenLpSrc: tokenLpWithdrawer,
-        lpPosition,
+        mintLp: this.mintLp,
+        tokenSyWithdrawer,
+        tokenPtWithdrawer,
+        tokenProgram: TOKEN_PROGRAM_ID,
         marketAddressLookupTable: this.addressLookupTable,
-        eventAuthority: this.vault.eventAuthority,
-        program: this.coreProgram.programId,
         syProgram: this.syProgram,
-        systemProgram: web3.SystemProgram.programId,
         tokenLpEscrow: this.tokenLpEscrow,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        tokenPtWithdrawer,
-        tokenSyWithdrawer,
-        mintLp: this.mintLp,
-        withdrawer: owner,
-      })
-      .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
-      .instruction()
+        lpPosition,
+        systemProgram: SystemProgram.programId,
+        eventAuthority: this.vault.eventAuthority,
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { amountLp, redeemSyAccountsLength: redeemSyRemAccounts.length },
+    )
+    ixn.keys.push(...redeemSyRemAccounts.concat(remainingAccounts))
 
     return {
       ixs: [...(await this.flavor.preIxs({ signer: owner })), ixn, ...(await this.flavor.postIxs({ signer: owner }))],
@@ -2085,16 +2002,16 @@ export class Market {
     }
   }
 
-  async claimFarmEmissions({
+  claimFarmEmissions({
     owner,
     mint,
     tokenProgram,
     tokenDst: tokenDstParam,
   }: {
-    owner: web3.PublicKey
-    mint: web3.PublicKey
-    tokenProgram: web3.PublicKey
-    tokenDst?: web3.PublicKey
+    owner: PublicKey
+    mint: PublicKey
+    tokenProgram: PublicKey
+    tokenDst?: PublicKey
   }) {
     const tokenDst = tokenDstParam || getAssociatedTokenAddressSync(mint, owner, true, tokenProgram)
     const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner })
@@ -2102,20 +2019,20 @@ export class Market {
     const tokenFarm = getAssociatedTokenAddressSync(mint, this.selfAddress, true, tokenProgram)
     const tokenAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenDst, owner, mint)
 
-    const ix = await this.coreProgram.methods
-      .claimFarmEmissions({ all: {} })
-      .accountsStrict({
+    const ix = exponentCore.createClaimFarmEmissionsInstruction(
+      {
+        owner,
         market: this.selfAddress,
         lpPosition,
+        tokenDst,
         mint,
         tokenFarm,
-        owner,
-        tokenDst,
         tokenProgram,
         eventAuthority: this.eventAuthority,
-        program: this.coreProgram.programId,
-      })
-      .instruction()
+        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+      },
+      { amount: exponentCore.amount("All") },
+    )
 
     return {
       ixs: [ix],
@@ -2123,35 +2040,35 @@ export class Market {
     }
   }
 
-  async ixAddStandaloneEmission({
+  ixAddStandaloneEmission({
     signer,
     emissionMint,
     emissionTokenProgram = TOKEN_PROGRAM_ID,
     altAddresses,
     cpiAccounts,
   }: {
-    signer: web3.PublicKey
-    emissionMint: web3.PublicKey
-    emissionTokenProgram?: web3.PublicKey
-    altAddresses: web3.PublicKey[]
+    signer: PublicKey
+    emissionMint: PublicKey
+    emissionTokenProgram?: PublicKey
+    altAddresses: PublicKey[]
     cpiAccounts: CpiAccountsRaw
   }) {
     const altUtil = extendAddressLookupTable(altAddresses, cpiAccounts)
 
     const tokenEmission = getAssociatedTokenAddressSync(emissionMint, this.selfAddress, true, emissionTokenProgram)
-    const ix = await this.coreProgram.methods
-      .addMarketEmission(altUtil.cpiAccountIndexes)
-      .accountsStrict({
+    const ix = exponentCore.createAddMarketEmissionInstruction(
+      {
         market: this.selfAddress,
-        adminState: getExponentAdminStatePda(),
+        signer,
         feePayer: signer,
         mintNew: emissionMint,
-        signer,
-        systemProgram: web3.SystemProgram.programId,
+        adminState: getExponentAdminStatePda(),
         tokenEmission,
         tokenProgram: emissionTokenProgram,
-      })
-      .instruction()
+        systemProgram: SystemProgram.programId,
+      },
+      { cpiAccounts: altUtil.cpiAccountIndexes },
+    )
 
     return {
       extendAddressLookupTableExtensionAccounts: altUtil.addressLookupTableExtension,
@@ -2159,7 +2076,7 @@ export class Market {
     }
   }
 
-  async addFarm({
+  addFarm({
     signer,
     farmMint,
     farmRewardTokenProgram,
@@ -2168,40 +2085,40 @@ export class Market {
     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
+    farmRewardSrc?: PublicKey
+    feePayer?: PublicKey
   }) {
     const feePayer = feePayerParam || signer
     const farmRewardEscrow = getAssociatedTokenAddressSync(farmMint, this.selfAddress, true, farmRewardTokenProgram)
     const farmRewardSrc =
       farmRewardSrcParam || getAssociatedTokenAddressSync(farmMint, signer, true, farmRewardTokenProgram)
 
-    const ix = await this.coreProgram.methods
-      .addFarm(new BN(emissionsRate), untilTimestamp)
-      .accountsStrict({
-        adminState: getExponentAdminStatePda(),
+    const ix = exponentCore.createAddFarmInstruction(
+      {
         market: this.selfAddress,
-        feePayer,
         signer,
+        feePayer,
         mintNew: farmMint,
+        adminState: getExponentAdminStatePda(),
+        tokenSource: farmRewardSrc,
         tokenFarm: farmRewardEscrow,
         tokenProgram: farmRewardTokenProgram,
-        systemProgram: web3.SystemProgram.programId,
-        tokenSource: farmRewardSrc,
-      })
-      .instruction()
+        systemProgram: SystemProgram.programId,
+      },
+      { tokenRate: BigInt(emissionsRate), untilTimestamp },
+    )
 
     return {
       ixs: [ix],
     }
   }
 
-  static fromJson(json: MarketJson, env: Environment, connection: web3.Connection): Market {
+  static fromJson(json: MarketJson, env: Environment, connection: Connection): Market {
     const state: MarketArgs = {
       seedId: [json.seedId],
       ptBalance: BigInt(json.ptBalance),
@@ -2213,20 +2130,20 @@ export class Market {
       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),
+      addressLookupTable: new PublicKey(json.addressLookupTable),
+      mintSy: new PublicKey(json.mintSy),
+      mintPt: new PublicKey(json.mintPt),
+      mintLp: new PublicKey(json.mintLp),
+      tokenPtEscrow: new PublicKey(json.tokenPtEscrow),
+      tokenSyEscrow: new PublicKey(json.tokenSyEscrow),
+      tokenLpEscrow: new PublicKey(json.tokenLpEscrow),
+      syProgram: new PublicKey(json.syProgram),
       cpiAccounts: deserializeCpiAccountsRaw(json.cpiAccounts),
       feeTreasurySyBps: json.feeTreasurySyBps,
-      tokenFeeTreasurySy: new web3.PublicKey(json.treasurySyTokenAccount),
+      tokenFeeTreasurySy: new PublicKey(json.treasurySyTokenAccount),
       lpFarm: {
         farmEmissions: json.lpFarm.farmEmissions.map((e) => ({
-          mint: new web3.PublicKey(e.mint),
+          mint: new PublicKey(e.mint),
           tokenRate: new BN(e.tokenRate),
           expiryTimestamp: e.expiryTimestamp,
           index: new PreciseNumber(e.index).anchorify(),
@@ -2242,12 +2159,12 @@ export class Market {
       },
       emissions: {
         trackers: json.emissions.trackers.map((e) => ({
-          tokenEscrow: new web3.PublicKey(e.tokenEscrow),
+          tokenEscrow: new PublicKey(e.tokenEscrow),
           lpShareIndex: e.lpShareIndex,
           lastSeenStaged: e.lastSeenStaged,
         })),
       },
-      vault: Vault.loadFromJson(json.vault, new web3.PublicKey(json.vault.selfAddress), env, connection),
+      vault: Vault.loadFromJson(json.vault, new PublicKey(json.vault.selfAddress), env, connection),
       sySupply: BigInt(json.sySupply),
       statusFlags: json.statusFlags,
       isCurrentFlashSwap: json.isCurrentFlashSwap,
@@ -2255,7 +2172,7 @@ export class Market {
       syPosition: deserializeSyPosition(json.syPosition),
     }
 
-    return new Market(state, new web3.PublicKey(json.address), env, connection)
+    return new Market(state, new PublicKey(json.address), env, connection)
   }
 
   /** Calculate available liquidity for PT trades
@@ -2296,17 +2213,17 @@ export class Market {
    * @param additionalBytes - number of additional bytes to allocate
    * @returns transaction instruction to realloc market
    */
-  async realloc_market({ signer, additionalBytes }: { signer: web3.PublicKey; additionalBytes: number }) {
-    const ix = await this.coreProgram.methods
-      .reallocMarket(new BN(additionalBytes))
-      .accountsStrict({
-        adminState: getExponentAdminStatePda(),
+  realloc_market({ signer, additionalBytes }: { signer: PublicKey; additionalBytes: number }) {
+    const ix = exponentCore.createReallocMarketInstruction(
+      {
         market: this.selfAddress,
-        systemProgram: web3.SystemProgram.programId,
-        signer: signer,
-        rent: web3.SYSVAR_RENT_PUBKEY,
-      })
-      .instruction()
+        signer,
+        adminState: getExponentAdminStatePda(),
+        systemProgram: SystemProgram.programId,
+        rent: SYSVAR_RENT_PUBKEY,
+      },
+      { additionalBytes: BigInt(additionalBytes) },
+    )
 
     return {
       ixs: [ix],