@exponent-labs/exponent-sdk 0.1.8 → 0.9.0

package/build/market.js

@@ -1,62 +1,56 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Market = exports.MyWallet = void 0;
-const anchor_1 = require("@coral-xyz/anchor");
+exports.Market = void 0;
 const spl_token_1 = require("@solana/spl-token");
 const exponent_fetcher_1 = require("@exponent-labs/exponent-fetcher");
-const exponent_idl_1 = require("@exponent-labs/exponent-idl");
 const exponent_pda_1 = require("@exponent-labs/exponent-pda");
 const exponent_types_1 = require("@exponent-labs/exponent-types");
+const exponent_types_2 = require("@exponent-labs/exponent-types");
 const market_math_1 = require("@exponent-labs/market-math");
 const precise_number_1 = require("@exponent-labs/precise-number");
 const addressLookupTableUtil_1 = require("./addressLookupTableUtil");
 const flavors_1 = require("./flavors");
-const exponent_types_2 = require("@exponent-labs/exponent-types");
 const syPosition_1 = require("./syPosition");
 const syPosition_2 = require("./syPosition");
 const tokenUtil_1 = require("./tokenUtil");
 const utils_1 = require("./utils");
 const altUtil_1 = require("./utils/altUtil");
 const vault_1 = require("./vault");
+const web3_js_1 = require("@solana/web3.js");
+const exponentCore = __importStar(require("./client/core"));
+const bn_js_1 = __importDefault(require("bn.js"));
 const SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
-//TODO Put it in the shared package because this code is repeated in many packages
-class MyWallet {
-    payer;
-    constructor(payer) {
-        this.payer = payer;
-        this.payer = payer;
-    }
-    async signTransaction(tx) {
-        if (tx instanceof anchor_1.web3.Transaction) {
-            tx.partialSign(this.payer);
-        }
-        else {
-            tx.sign([this.payer]);
-        }
-        return tx;
-    }
-    async signAllTransactions(txs) {
-        return txs.map((t) => {
-            if (t instanceof anchor_1.web3.Transaction) {
-                t.partialSign(this.payer);
-            }
-            else if (t instanceof anchor_1.web3.VersionedTransaction) {
-                t.sign([this.payer]);
-            }
-            return t;
-        });
-    }
-    get publicKey() {
-        return this.payer.publicKey;
-    }
-}
-exports.MyWallet = MyWallet;
 class Market {
     state;
     selfAddress;
     env;
     connection;
-    coreProgram;
     xponPda;
     constructor(state, selfAddress, env, connection) {
         this.state = state;
@@ -64,8 +58,6 @@ class Market {
         this.env = env;
         this.connection = connection;
         this.xponPda = new exponent_pda_1.ExponentPDA(env.coreProgramId);
-        const mockWallet = new MyWallet(anchor_1.web3.Keypair.generate());
-        this.coreProgram = new anchor_1.Program(exponent_idl_1.IDL, new anchor_1.AnchorProvider(connection, mockWallet));
     }
     static async load(env, connection, address, vault, options = {}) {
         const fetcher = new exponent_fetcher_1.ExponentFetcher({ connection });
@@ -329,15 +321,12 @@ class Market {
      *
      * The token accounts themselves are optional, and will be derived from the depositor's wallet if not provided
      */
-    async ixDepositLiquidity({ ptInIntent, syInIntent, minLpOut, depositor, ptSrc: ptSrcParam, sySrc: sySrcParam, lpDst: lpDstParam, }) {
-        const tokenProgram = spl_token_1.TOKEN_PROGRAM_ID;
+    ixDepositLiquidity({ ptInIntent, syInIntent, minLpOut, depositor, ptSrc: ptSrcParam, sySrc: sySrcParam, lpDst: lpDstParam, }) {
         const sySrc = sySrcParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
         const ptSrc = ptSrcParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
         const lpDst = lpDstParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintLp, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
         const syRemAccounts = this.cpiAccounts.depositSy;
-        return this.coreProgram.methods
-            .marketTwoDepositLiquidity(new anchor_1.BN(ptInIntent.toString()), new anchor_1.BN(syInIntent.toString()), new anchor_1.BN(minLpOut.toString()))
-            .accountsStrict({
+        const ix = exponentCore.createMarketTwoDepositLiquidityInstruction({
             depositor,
             market: this.selfAddress,
             mintLp: this.mintLp,
@@ -348,39 +337,33 @@ class Market {
             tokenSyEscrow: this.tokenSyEscrow,
             addressLookupTable: this.addressLookupTable,
             syProgram: this.syProgram,
-            tokenProgram,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             eventAuthority: this.vault.eventAuthority,
-            program: this.coreProgram.programId,
-        })
-            .remainingAccounts(syRemAccounts)
-            .instruction();
-    }
-    async ixModifyMarketSetting({ signer, adminAction }) {
-        return this.coreProgram.methods
-            .modifyMarketSetting(adminAction)
-            .accountsStrict({
+            program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+        }, { ptIntent: ptInIntent, syIntent: syInIntent, minLpOut });
+        ix.keys.push(...syRemAccounts);
+        return ix;
+    }
+    ixModifyMarketSetting({ signer, adminAction }) {
+        return exponentCore.createModifyMarketSettingInstruction({
             market: this.selfAddress,
             adminState: (0, utils_1.getExponentAdminStatePda)(),
             signer,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
-        })
-            .instruction();
+            systemProgram: web3_js_1.SystemProgram.programId,
+        }, { action: adminAction });
     }
-    async ixModifyFarm({ newRate, untilTimestamp, signer, farmMint, farmTokenProgram, farmTokenSrc: farmTokenSrcParam, }) {
+    ixModifyFarm({ newRate, untilTimestamp, signer, farmMint, farmTokenProgram, farmTokenSrc: farmTokenSrcParam, }) {
         const farmTokenSrc = farmTokenSrcParam || (0, spl_token_1.getAssociatedTokenAddressSync)(farmMint, signer, true, farmTokenProgram);
         const tokenFarm = (0, spl_token_1.getAssociatedTokenAddressSync)(farmMint, this.selfAddress, true, farmTokenProgram);
-        return this.coreProgram.methods
-            .modifyFarm(untilTimestamp, new anchor_1.BN(newRate.toString()))
-            .accountsStrict({
-            adminState: (0, utils_1.getExponentAdminStatePda)(),
+        return exponentCore.createModifyFarmInstruction({
             market: this.selfAddress,
-            mint: farmMint,
-            tokenFarm: tokenFarm,
             signer,
-            tokenProgram: farmTokenProgram,
+            mint: farmMint,
+            adminState: (0, utils_1.getExponentAdminStatePda)(),
             tokenSource: farmTokenSrc,
-        })
-            .instruction();
+            tokenFarm,
+            tokenProgram: farmTokenProgram,
+        }, { untilTimestamp, newRate });
     }
     /**
      * Redeem LP tokens for PT & SY  (liquidity removal)
@@ -391,7 +374,7 @@ class Market {
      *
      * The token accounts themselves are optional, and will be derived from the withdrawer's wallet if not provided
      */
-    async ixWithdrawLiquidity({ lpIn, withdrawer, minPtOut, minSyOut, ptDst: ptDstParam, syDst: syDstParam, lpSrc: lpSrcParam, }) {
+    ixWithdrawLiquidity({ lpIn, withdrawer, minPtOut, minSyOut, ptDst: ptDstParam, syDst: syDstParam, lpSrc: lpSrcParam, }) {
         const ptDst = ptDstParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, withdrawer, true, spl_token_1.TOKEN_PROGRAM_ID);
         const syDst = syDstParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, withdrawer, true, spl_token_1.TOKEN_PROGRAM_ID);
         const lpSrc = lpSrcParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintLp, withdrawer, true, spl_token_1.TOKEN_PROGRAM_ID);
@@ -399,26 +382,23 @@ class Market {
         const syDstAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(withdrawer, syDst, withdrawer, this.mintSy);
         const lpSrcAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(withdrawer, lpSrc, withdrawer, this.mintLp);
         const syRemAccounts = this.cpiAccounts.withdrawSy;
-        const ixs = await this.coreProgram.methods
-            .marketTwoWithdrawLiquidity(new anchor_1.BN(lpIn.toString()), new anchor_1.BN(minPtOut.toString()), new anchor_1.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: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
             eventAuthority: this.vault.eventAuthority,
-            program: this.coreProgram.programId,
-        })
-            .remainingAccounts(syRemAccounts)
-            .instruction();
-        return { ixs: [ixs], setupIxs: [ptDstAtaIx, syDstAtaIx, lpSrcAtaIx] };
+            program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+        }, { lpIn, minPtOut, minSyOut });
+        ix.keys.push(...syRemAccounts);
+        return { ixs: [ix], setupIxs: [ptDstAtaIx, syDstAtaIx, lpSrcAtaIx] };
     }
     /** Buy PT with SY
      *
@@ -456,7 +436,7 @@ class Market {
             tokenSy,
         });
     }
-    async ixTradePt({ trader, traderPt, syConstraint, isBuy, tokenPt: tokenPtParam, tokenSy: tokenSyParam, }) {
+    ixTradePt({ trader, traderPt, syConstraint, isBuy, tokenPt: tokenPtParam, tokenSy: tokenSyParam, }) {
         const tokenPt = tokenPtParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
         const tokenSy = tokenSyParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
         const tokenSyAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(trader, tokenSy, trader, this.mintSy);
@@ -466,15 +446,13 @@ class Market {
             ...this.cpiAccounts.depositSy,
             ...this.cpiAccounts.withdrawSy,
         ];
-        const netTradePtBN = new anchor_1.BN(traderPt.toString()).mul(isBuy ? new anchor_1.BN(1) : new anchor_1.BN(-1));
-        const syConstraintBN = new anchor_1.BN(syConstraint.toString()).mul(isBuy ? new anchor_1.BN(-1) : new anchor_1.BN(1));
-        const ix = await this.coreProgram.methods
-            .tradePt(netTradePtBN, syConstraintBN)
-            .accountsStrict({
+        const netTraderPt = isBuy ? traderPt : -traderPt;
+        const syConstraintSigned = isBuy ? -syConstraint : syConstraint;
+        const ix = exponentCore.createTradePtInstruction({
             trader,
             market: this.selfAddress,
-            tokenPtTrader: tokenPt,
             tokenSyTrader: tokenSy,
+            tokenPtTrader: tokenPt,
             tokenSyEscrow: this.tokenSyEscrow,
             tokenPtEscrow: this.tokenPtEscrow,
             addressLookupTable: this.addressLookupTable,
@@ -482,10 +460,9 @@ 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] };
     }
     /** Sell YT for SY
@@ -498,7 +475,7 @@ class Market {
      *
      * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
      */
-    async ixSellYt({ trader, ytIn, minSyOut, ytSrc: ytSrcParam, ptSrc: ptSrcParam, syDst: syDstParam, }) {
+    ixSellYt({ trader, ytIn, minSyOut, ytSrc: ytSrcParam, ptSrc: ptSrcParam, syDst: syDstParam, }) {
         const syDst = syDstParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
         const ptSrc = ptSrcParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
         const ytSrc = ytSrcParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
@@ -511,10 +488,8 @@ class Market {
             ...this.cpiAccounts.depositSy,
             ...mergeAccounts.remainingAccounts,
         ]);
-        remainingAccounts.push({ pubkey: this.coreProgram.programId, isWritable: false, isSigner: false });
-        const ix = await this.coreProgram.methods
-            .sellYt(new anchor_1.BN(ytIn.toString()), new anchor_1.BN(minSyOut.toString()))
-            .accountsStrict({
+        remainingAccounts.push({ pubkey: exponentCore.EXPONENTCORE_PROGRAM_ID, isWritable: false, isSigner: false });
+        const ix = exponentCore.createSellYtInstruction({
             trader,
             market: this.selfAddress,
             tokenYtTrader: ytSrc,
@@ -523,6 +498,7 @@ class Market {
             tokenSyEscrow: this.tokenSyEscrow,
             tokenPtEscrow: this.tokenPtEscrow,
             addressLookupTable: this.addressLookupTable,
+            tokenFeeTreasurySy: this.vault.state.treasurySyTokenAccount,
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             vault: mergeAccounts.mainAccounts.vault,
             authorityVault: mergeAccounts.mainAccounts.authority,
@@ -532,12 +508,10 @@ 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] };
     }
     /** Buy YT with SY
@@ -550,7 +524,7 @@ class Market {
      *
      * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
      */
-    async ixBuyYt({ trader, ytOut, maxSyIn, ytTrader: ytTraderParam, ptTrader: ptTraderParam, syTrader: syTraderParam, }) {
+    ixBuyYt({ trader, ytOut, maxSyIn, ytTrader: ytTraderParam, ptTrader: ptTraderParam, syTrader: syTraderParam, }) {
         const syTrader = syTraderParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
         const ptTrader = ptTraderParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
         const ytTrader = ytTraderParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
@@ -569,95 +543,85 @@ class Market {
             ...this.cpiAccounts.depositSy,
             ...stripAccounts.remainingAccounts,
         ]);
-        remainingAccounts.push({ pubkey: this.coreProgram.programId, isWritable: false, isSigner: false });
-        const ix = await this.coreProgram.methods
-            .buyYt(new anchor_1.BN(maxSyIn.toString()), new anchor_1.BN(ytOut.toString()))
-            .accountsStrict({
+        remainingAccounts.push({ pubkey: exponentCore.EXPONENTCORE_PROGRAM_ID, isWritable: false, isSigner: false });
+        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: spl_token_1.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 }) {
+    ixInitLpPosition({ owner, feePayer }) {
         const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner });
-        return this.coreProgram.methods
-            .initLpPosition()
-            .accountsStrict({
-            owner,
+        return exponentCore.createInitLpPositionInstruction({
             feePayer: feePayer || owner,
-            lpPosition,
+            owner,
             market: this.selfAddress,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
+            lpPosition,
+            systemProgram: web3_js_1.SystemProgram.programId,
             eventAuthority: this.vault.eventAuthority,
-            program: this.coreProgram.programId,
-        })
-            .instruction();
+            program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+        });
     }
     /** Deposit LP tokens into the farming module to earn rewards */
-    async ixDepositLp({ owner, amount, lpSrc: lpSrcParam, }) {
+    ixDepositLp({ owner, amount, lpSrc: lpSrcParam, }) {
         const lpSrc = lpSrcParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintLp, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
         const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner });
-        return this.coreProgram.methods
-            .marketDepositLp(new anchor_1.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: spl_token_1.TOKEN_PROGRAM_ID,
-            mintLp: this.mintLp,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
+            systemProgram: web3_js_1.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({ owner, amount, lpDst: lpDstParam, }) {
+    ixWithdrawLp({ owner, amount, lpDst: lpDstParam, }) {
         const lpDst = lpDstParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintLp, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
         const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner });
-        return this.coreProgram.methods
-            .marketWithdrawLp(new anchor_1.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: spl_token_1.TOKEN_PROGRAM_ID,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
+            systemProgram: web3_js_1.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, }) {
         const yieldPosition = this.xponPda.yieldPosition({ owner: claimer, vault: this.vault.selfAddress });
@@ -676,24 +640,21 @@ class Market {
             redeemerBaseTokenAccount: tokenBaseClaimer,
             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: spl_token_1.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: [
                 ...(await this.flavor.preIxs({ signer: claimer })),
@@ -718,35 +679,30 @@ class Market {
             depositorSyTokenAccount: tokenSyTrader,
         });
         const mintSyRemAccounts = mintSyIx.keys;
-        // console.log("mintSyRemAccounts", mintSyRemAccounts)
         mintSyRemAccounts.push({
-            pubkey: this.coreProgram.programId,
+            pubkey: exponentCore.EXPONENTCORE_PROGRAM_ID,
             isWritable: false,
             isSigner: false,
         });
         const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
             ...this.cpiAccounts.getSyState,
             ...this.cpiAccounts.depositSy,
-            // ...this.cpiAccounts.withdrawSy,
         ]);
-        const ix = await this.coreProgram.methods
-            .wrapperBuyPt(new anchor_1.BN(ptOut.toString()), new anchor_1.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: spl_token_1.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 }))],
             setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenBaseTraderAtaIx],
@@ -768,24 +724,21 @@ class Market {
         });
         const redeemSyRemAccounts = redeemSyIx.keys;
         const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([...this.cpiAccounts.getSyState, ...this.cpiAccounts.withdrawSy]);
-        const ix = await this.coreProgram.methods
-            .wrapperSellPt(new anchor_1.BN(amount.toString()), new anchor_1.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: spl_token_1.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 }))],
             setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenBaseTraderAtaIx],
@@ -815,9 +768,7 @@ class Market {
             ...this.cpiAccounts.getPositionState,
         ]);
         const allRemainingAccounts = mintSyRemAccounts.concat(remainingAccounts);
-        const ix1 = await this.coreProgram.methods
-            .wrapperBuyYt(new anchor_1.BN(ytOut.toString()), new anchor_1.BN(maxBaseIn.toString()), mintSyRemAccounts.length)
-            .accountsStrict({
+        const ix1 = exponentCore.createWrapperBuyYtInstruction({
             buyer: owner,
             market: this.selfAddress,
             tokenSyTrader,
@@ -826,24 +777,23 @@ 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: spl_token_1.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: anchor_1.web3.SystemProgram.programId,
-            userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner }),
+            systemProgram: web3_js_1.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 }))],
             setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx],
@@ -871,57 +821,45 @@ class Market {
             ...this.cpiAccounts.withdrawSy,
             ...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 anchor_1.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: spl_token_1.TOKEN_PROGRAM_ID,
+            authority: this.vault.authority,
             syProgram: this.syProgram,
             addressLookupTable: this.vault.addressLookupTable,
-            systemProgram: anchor_1.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();
-        const ix2 = await this.coreProgram.methods
-            .wrapperSellYt(new anchor_1.BN(amount.toString()), new anchor_1.BN(minBaseOut.toString()), redeemSyRemAccounts.length)
-            .accountsStrict({
+            systemProgram: web3_js_1.SystemProgram.programId,
+            eventAuthority: this.vault.eventAuthority,
+            program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+        }, { amount });
+        ix1.keys.push(...remainingAccounts);
+        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: spl_token_1.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: spl_token_1.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: [
                 ix1,
@@ -932,26 +870,23 @@ class Market {
             setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx, tokenBaseTraderAtaIx],
         };
     }
-    async ixCollectMarketEmission({ owner, emissionIndex, emissionDst, }) {
+    ixCollectMarketEmission({ owner, emissionIndex, emissionDst, }) {
         const emission = this.emissions[emissionIndex];
         const tokenEmissionDst = emissionDst || (0, spl_token_1.getAssociatedTokenAddressSync)(emission.mint, owner, true, emission.tokenProgramAddress);
         const tokenEmissionDstIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenEmissionDst, 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],
             setupIxs: [tokenEmissionDstIx],
@@ -970,8 +905,7 @@ class Market {
         const tokenYtDepositorAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, tokenYtDepositor, depositor, this.mintYt);
         const tokenPtDepositorAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, tokenPtDepositor, depositor, this.mintPt);
         const tokenLpDepositorAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, tokenLpDepositor, depositor, this.mintLp);
-        const amountBaseBn = new anchor_1.BN(amountBase.toString());
-        const minLpOutBn = new anchor_1.BN(minLpOut.toString());
+        // amountBase and minLpOut are already bigint
         // TODO - fix this
         const mintSyIx = await this.flavor.ixMintSy({
             // argument does not matter - since we are just getting the keys
@@ -993,7 +927,7 @@ class Market {
         // 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((account) => account.pubkey.toBase58() !== spl_token_1.TOKEN_PROGRAM_ID.toBase58() &&
-            account.pubkey.toBase58() !== anchor_1.web3.SystemProgram.programId.toBase58() &&
+            account.pubkey.toBase58() !== web3_js_1.SystemProgram.programId.toBase58() &&
             account.pubkey.toBase58() !== this.selfAddress.toBase58());
         // Log market accounts after filtering
         // console.log("After filtering market accounts:", marketCpiRemainingAccounts.length, "accounts")
@@ -1004,9 +938,7 @@ class Market {
         ]);
         const allRemainingAccounts = [...mintSyRemAccounts, ...unorderedRemainingAccounts];
         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,
@@ -1015,28 +947,26 @@ 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: anchor_1.web3.SystemProgram.programId,
             tokenProgram: spl_token_1.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: web3_js_1.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: [
                 ...(await this.flavor.preIxs({ signer: depositor })),
@@ -1070,29 +1000,26 @@ class Market {
             depositorSyTokenAccount: tokenSyDepositor,
         });
         const mintSyRemAccounts = mintSyIx.keys;
-        const ix = await this.coreProgram.methods
-            .wrapperProvideLiquidityBase(new anchor_1.BN(amountBase.toString()), new anchor_1.BN(minLpOut.toString()), mintSyRemAccounts.length, new anchor_1.BN(externalPtToBuy.toString()), new anchor_1.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: spl_token_1.TOKEN_PROGRAM_ID,
+            marketAddressLookupTable: this.addressLookupTable,
             syProgram: this.syProgram,
             tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
             tokenLpEscrow: this.tokenLpEscrow,
-            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            marketAddressLookupTable: this.addressLookupTable,
-            tokenPtDepositor,
-            tokenSyDepositor,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
+            lpPosition,
+            systemProgram: web3_js_1.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: [
                 ...(await this.flavor.preIxs({ signer: depositor })),
@@ -1125,28 +1052,25 @@ class Market {
             depositorSyTokenAccount: tokenSyDepositor,
         });
         const mintSyRemAccounts = mintSyIx.keys;
-        const ix = await this.coreProgram.methods
-            .wrapperProvideLiquidityClassic(new anchor_1.BN(amountBase.toString()), new anchor_1.BN(amountPt.toString()), new anchor_1.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: spl_token_1.TOKEN_PROGRAM_ID,
             marketAddressLookupTable: this.addressLookupTable,
-            tokenPtDepositor,
-            tokenSyDepositor,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
+            syProgram: this.syProgram,
+            tokenLpEscrow: this.tokenLpEscrow,
+            lpPosition,
+            systemProgram: web3_js_1.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: [
                 ...(await this.flavor.preIxs({ signer: depositor })),
@@ -1181,29 +1105,26 @@ class Market {
         });
         const redeemSyRemAccounts = redeemSyIx.keys;
         const minSyOut = Number(minBaseOut) / this.currentSyExchangeRate;
-        const ix = await this.coreProgram.methods
-            .wrapperWithdrawLiquidity(new anchor_1.BN(amountLp.toString()), new anchor_1.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: spl_token_1.TOKEN_PROGRAM_ID,
             marketAddressLookupTable: this.addressLookupTable,
-            eventAuthority: this.vault.eventAuthority,
-            program: this.coreProgram.programId,
             syProgram: this.syProgram,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
-            tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
             tokenLpEscrow: this.tokenLpEscrow,
-            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            tokenPtWithdrawer,
-            tokenSyWithdrawer,
-            mintLp: this.mintLp,
-            withdrawer: owner,
-        })
-            .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
-            .instruction();
+            tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+            lpPosition,
+            systemProgram: web3_js_1.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 }))],
             setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx, tokenLpAtaIx],
@@ -1233,96 +1154,84 @@ class Market {
             redeemerSyTokenAccount: tokenSyWithdrawer,
         });
         const redeemSyRemAccounts = redeemSyIx.keys;
-        const ixn = await this.coreProgram.methods
-            .wrapperWithdrawLiquidityClassic(new anchor_1.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: spl_token_1.TOKEN_PROGRAM_ID,
             marketAddressLookupTable: this.addressLookupTable,
-            eventAuthority: this.vault.eventAuthority,
-            program: this.coreProgram.programId,
             syProgram: this.syProgram,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
             tokenLpEscrow: this.tokenLpEscrow,
-            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            tokenPtWithdrawer,
-            tokenSyWithdrawer,
-            mintLp: this.mintLp,
-            withdrawer: owner,
-        })
-            .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
-            .instruction();
+            lpPosition,
+            systemProgram: web3_js_1.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 }))],
             setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx, tokenLpAtaIx],
         };
     }
-    async claimFarmEmissions({ owner, mint, tokenProgram, tokenDst: tokenDstParam, }) {
+    claimFarmEmissions({ owner, mint, tokenProgram, tokenDst: tokenDstParam, }) {
         const tokenDst = tokenDstParam || (0, spl_token_1.getAssociatedTokenAddressSync)(mint, owner, true, tokenProgram);
         const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner });
         const tokenFarm = (0, spl_token_1.getAssociatedTokenAddressSync)(mint, this.selfAddress, true, tokenProgram);
         const tokenAtaIx = (0, spl_token_1.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],
             setupIxs: [tokenAtaIx],
         };
     }
-    async ixAddStandaloneEmission({ signer, emissionMint, emissionTokenProgram = spl_token_1.TOKEN_PROGRAM_ID, altAddresses, cpiAccounts, }) {
+    ixAddStandaloneEmission({ signer, emissionMint, emissionTokenProgram = spl_token_1.TOKEN_PROGRAM_ID, altAddresses, cpiAccounts, }) {
         const altUtil = (0, altUtil_1.extendAddressLookupTable)(altAddresses, cpiAccounts);
         const tokenEmission = (0, spl_token_1.getAssociatedTokenAddressSync)(emissionMint, this.selfAddress, true, emissionTokenProgram);
-        const ix = await this.coreProgram.methods
-            .addMarketEmission(altUtil.cpiAccountIndexes)
-            .accountsStrict({
+        const ix = exponentCore.createAddMarketEmissionInstruction({
             market: this.selfAddress,
-            adminState: (0, utils_1.getExponentAdminStatePda)(),
+            signer,
             feePayer: signer,
             mintNew: emissionMint,
-            signer,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
+            adminState: (0, utils_1.getExponentAdminStatePda)(),
             tokenEmission,
             tokenProgram: emissionTokenProgram,
-        })
-            .instruction();
+            systemProgram: web3_js_1.SystemProgram.programId,
+        }, { cpiAccounts: altUtil.cpiAccountIndexes });
         return {
             extendAddressLookupTableExtensionAccounts: altUtil.addressLookupTableExtension,
             addMarketEmissionIx: ix,
         };
     }
-    async addFarm({ signer, farmMint, farmRewardTokenProgram, emissionsRate, untilTimestamp, farmRewardSrc: farmRewardSrcParam, feePayer: feePayerParam, }) {
+    addFarm({ signer, farmMint, farmRewardTokenProgram, emissionsRate, untilTimestamp, farmRewardSrc: farmRewardSrcParam, feePayer: feePayerParam, }) {
         const feePayer = feePayerParam || signer;
         const farmRewardEscrow = (0, spl_token_1.getAssociatedTokenAddressSync)(farmMint, this.selfAddress, true, farmRewardTokenProgram);
         const farmRewardSrc = farmRewardSrcParam || (0, spl_token_1.getAssociatedTokenAddressSync)(farmMint, signer, true, farmRewardTokenProgram);
-        const ix = await this.coreProgram.methods
-            .addFarm(new anchor_1.BN(emissionsRate), untilTimestamp)
-            .accountsStrict({
-            adminState: (0, utils_1.getExponentAdminStatePda)(),
+        const ix = exponentCore.createAddFarmInstruction({
             market: this.selfAddress,
-            feePayer,
             signer,
+            feePayer,
             mintNew: farmMint,
+            adminState: (0, utils_1.getExponentAdminStatePda)(),
+            tokenSource: farmRewardSrc,
             tokenFarm: farmRewardEscrow,
             tokenProgram: farmRewardTokenProgram,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
-            tokenSource: farmRewardSrc,
-        })
-            .instruction();
+            systemProgram: web3_js_1.SystemProgram.programId,
+        }, { tokenRate: BigInt(emissionsRate), untilTimestamp });
         return {
             ixs: [ix],
         };
@@ -1339,21 +1248,21 @@ class Market {
             lnFeeRateRoot: json.lnFeeRateRoot,
             lastLnImpliedRate: json.lastLnImpliedRate,
             expirationTs: json.expirationTs,
-            addressLookupTable: new anchor_1.web3.PublicKey(json.addressLookupTable),
-            mintSy: new anchor_1.web3.PublicKey(json.mintSy),
-            mintPt: new anchor_1.web3.PublicKey(json.mintPt),
-            mintLp: new anchor_1.web3.PublicKey(json.mintLp),
-            tokenPtEscrow: new anchor_1.web3.PublicKey(json.tokenPtEscrow),
-            tokenSyEscrow: new anchor_1.web3.PublicKey(json.tokenSyEscrow),
-            tokenLpEscrow: new anchor_1.web3.PublicKey(json.tokenLpEscrow),
-            syProgram: new anchor_1.web3.PublicKey(json.syProgram),
+            addressLookupTable: new web3_js_1.PublicKey(json.addressLookupTable),
+            mintSy: new web3_js_1.PublicKey(json.mintSy),
+            mintPt: new web3_js_1.PublicKey(json.mintPt),
+            mintLp: new web3_js_1.PublicKey(json.mintLp),
+            tokenPtEscrow: new web3_js_1.PublicKey(json.tokenPtEscrow),
+            tokenSyEscrow: new web3_js_1.PublicKey(json.tokenSyEscrow),
+            tokenLpEscrow: new web3_js_1.PublicKey(json.tokenLpEscrow),
+            syProgram: new web3_js_1.PublicKey(json.syProgram),
             cpiAccounts: (0, exponent_types_2.deserializeCpiAccountsRaw)(json.cpiAccounts),
             feeTreasurySyBps: json.feeTreasurySyBps,
-            tokenFeeTreasurySy: new anchor_1.web3.PublicKey(json.treasurySyTokenAccount),
+            tokenFeeTreasurySy: new web3_js_1.PublicKey(json.treasurySyTokenAccount),
             lpFarm: {
                 farmEmissions: json.lpFarm.farmEmissions.map((e) => ({
-                    mint: new anchor_1.web3.PublicKey(e.mint),
-                    tokenRate: new anchor_1.BN(e.tokenRate),
+                    mint: new web3_js_1.PublicKey(e.mint),
+                    tokenRate: new bn_js_1.default(e.tokenRate),
                     expiryTimestamp: e.expiryTimestamp,
                     index: new precise_number_1.PreciseNumber(e.index).anchorify(),
                 })),
@@ -1361,26 +1270,26 @@ class Market {
             },
             liquidityNetBalanceLimits: {
                 windowStartTimestamp: json.liquidityNetBalanceLimits.windowStartTimestamp,
-                windowStartNetBalance: new anchor_1.BN(json.liquidityNetBalanceLimits.windowStartNetBalance),
+                windowStartNetBalance: new bn_js_1.default(json.liquidityNetBalanceLimits.windowStartNetBalance),
                 maxNetBalanceChangeNegativePercentage: json.liquidityNetBalanceLimits.maxNetBalanceChangeNegativePercentage,
                 maxNetBalanceChangePositivePercentage: json.liquidityNetBalanceLimits.maxNetBalanceChangePositivePercentage,
                 windowDurationSeconds: json.liquidityNetBalanceLimits.windowDurationSeconds,
             },
             emissions: {
                 trackers: json.emissions.trackers.map((e) => ({
-                    tokenEscrow: new anchor_1.web3.PublicKey(e.tokenEscrow),
+                    tokenEscrow: new web3_js_1.PublicKey(e.tokenEscrow),
                     lpShareIndex: e.lpShareIndex,
                     lastSeenStaged: e.lastSeenStaged,
                 })),
             },
-            vault: vault_1.Vault.loadFromJson(json.vault, new anchor_1.web3.PublicKey(json.vault.selfAddress), env, connection),
+            vault: vault_1.Vault.loadFromJson(json.vault, new web3_js_1.PublicKey(json.vault.selfAddress), env, connection),
             sySupply: BigInt(json.sySupply),
             statusFlags: json.statusFlags,
             isCurrentFlashSwap: json.isCurrentFlashSwap,
             flavor: (0, flavors_1.deserializeFlavor)(json.flavor),
             syPosition: (0, syPosition_1.deserializeSyPosition)(json.syPosition),
         };
-        return new Market(state, new anchor_1.web3.PublicKey(json.address), env, connection);
+        return new Market(state, new web3_js_1.PublicKey(json.address), env, connection);
     }
     /** Calculate available liquidity for PT trades
      * @param isBuy - true if buying PT with SY, false if selling PT for SY
@@ -1419,17 +1328,14 @@ class Market {
      * @param additionalBytes - number of additional bytes to allocate
      * @returns transaction instruction to realloc market
      */
-    async realloc_market({ signer, additionalBytes }) {
-        const ix = await this.coreProgram.methods
-            .reallocMarket(new anchor_1.BN(additionalBytes))
-            .accountsStrict({
-            adminState: (0, utils_1.getExponentAdminStatePda)(),
+    realloc_market({ signer, additionalBytes }) {
+        const ix = exponentCore.createReallocMarketInstruction({
             market: this.selfAddress,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
-            signer: signer,
-            rent: anchor_1.web3.SYSVAR_RENT_PUBKEY,
-        })
-            .instruction();
+            signer,
+            adminState: (0, utils_1.getExponentAdminStatePda)(),
+            systemProgram: web3_js_1.SystemProgram.programId,
+            rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+        }, { additionalBytes: BigInt(additionalBytes) });
         return {
             ixs: [ix],
         };