@drift-labs/sdk 2.31.1-beta.10 → 2.31.1-beta.12

package/VERSION

@@ -1 +1 @@
-2.31.1-beta.10
+2.31.1-beta.12

package/lib/driftClient.d.ts

@@ -19,7 +19,7 @@ type RemainingAccountParams = {
     userAccounts: UserAccount[];
     writablePerpMarketIndexes?: number[];
     writableSpotMarketIndexes?: number[];
-    readablePerpMarketIndex?: number;
+    readablePerpMarketIndex?: number | number[];
     readableSpotMarketIndexes?: number[];
     useMarketLastSlotCache?: boolean;
 };
@@ -44,6 +44,8 @@ export declare class DriftClient {
     txSender: TxSender;
     perpMarketLastSlotCache: Map<number, number>;
     spotMarketLastSlotCache: Map<number, number>;
+    mustIncludePerpMarketIndexes: Set<number>;
+    mustIncludeSpotMarketIndexes: Set<number>;
     authority: PublicKey;
     marketLookupTable: PublicKey;
     lookupTableAccount: AddressLookupTableAccount;
@@ -162,7 +164,20 @@ export declare class DriftClient {
      * @param amount
      */
     convertToPricePrecision(amount: BN | number): BN;
+    /**
+     * Each drift instruction must include perp and sport market accounts in the ix remaining accounts.
+     * Use this function to force a subset of markets to be included in the remaining accounts for every ix
+     *
+     * @param perpMarketIndexes
+     * @param spotMarketIndexes
+     */
+    mustIncludeMarketsInIx({ perpMarketIndexes, spotMarketIndexes, }: {
+        perpMarketIndexes: number[];
+        spotMarketIndexes: number[];
+    }): void;
     getRemainingAccounts(params: RemainingAccountParams): AccountMeta[];
+    addPerpMarketToRemainingAccountMaps(marketIndex: number, writable: boolean, oracleAccountMap: Map<string, AccountMeta>, spotMarketAccountMap: Map<number, AccountMeta>, perpMarketAccountMap: Map<number, AccountMeta>): void;
+    addSpotMarketToRemainingAccountMaps(marketIndex: number, writable: boolean, oracleAccountMap: Map<string, AccountMeta>, spotMarketAccountMap: Map<number, AccountMeta>): void;
     getRemainingAccountMapsForUsers(userAccounts: UserAccount[]): {
         oracleAccountMap: Map<string, AccountMeta>;
         spotMarketAccountMap: Map<number, AccountMeta>;
@@ -271,6 +286,8 @@ export declare class DriftClient {
         marketIndex?: number;
         direction?: PositionDirection;
     }, placeOrderParams: OrderParams[], txParams?: TxParams): Promise<TransactionSignature>;
+    placeOrders(params: OrderParams[], txParams?: TxParams): Promise<TransactionSignature>;
+    getPlaceOrdersIx(params: OrderParams[]): Promise<TransactionInstruction>;
     fillPerpOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<TransactionSignature>;
     getFillPerpOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
     getRevertFillIx(): Promise<TransactionInstruction>;
@@ -328,6 +345,12 @@ export declare class DriftClient {
         beginSwapIx: TransactionInstruction;
         endSwapIx: TransactionInstruction;
     }>;
+    stakeForMSOL({ amount }: {
+        amount: BN;
+    }): Promise<TxSigAndSlot>;
+    getStakeForMSOLIx({ amount, }: {
+        amount: BN;
+    }): Promise<TransactionInstruction[]>;
     triggerOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order, txParams?: TxParams): Promise<TransactionSignature>;
     getTriggerOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order): Promise<TransactionInstruction>;
     forceCancelOrders(userAccountPublicKey: PublicKey, user: UserAccount, txParams?: TxParams): Promise<TransactionSignature>;

package/lib/driftClient.js

@@ -52,6 +52,7 @@ const market_1 = require("./math/market");
 const fetch_1 = require("./accounts/fetch");
 const spotMarket_1 = require("./math/spotMarket");
 const memcmp_1 = require("./memcmp");
+const marinade_1 = require("./marinade");
 /**
  * # DriftClient
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
@@ -69,6 +70,8 @@ class DriftClient {
         this._isSubscribed = false;
         this.perpMarketLastSlotCache = new Map();
         this.spotMarketLastSlotCache = new Map();
+        this.mustIncludePerpMarketIndexes = new Set();
+        this.mustIncludeSpotMarketIndexes = new Set();
         this.connection = config.connection;
         this.wallet = config.wallet;
         this.opts = config.opts || anchor_1.AnchorProvider.defaultOptions();
@@ -716,6 +719,21 @@ class DriftClient {
         amount = typeof amount === 'number' ? new anchor_1.BN(amount) : amount;
         return amount.mul(numericConstants_1.PRICE_PRECISION);
     }
+    /**
+     * Each drift instruction must include perp and sport market accounts in the ix remaining accounts.
+     * Use this function to force a subset of markets to be included in the remaining accounts for every ix
+     *
+     * @param perpMarketIndexes
+     * @param spotMarketIndexes
+     */
+    mustIncludeMarketsInIx({ perpMarketIndexes, spotMarketIndexes, }) {
+        perpMarketIndexes.forEach((perpMarketIndex) => {
+            this.mustIncludePerpMarketIndexes.add(perpMarketIndex);
+        });
+        spotMarketIndexes.forEach((spotMarketIndex) => {
+            this.mustIncludeSpotMarketIndexes.add(spotMarketIndex);
+        });
+    }
     getRemainingAccounts(params) {
         var _a;
         const { oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap } = this.getRemainingAccountMapsForUsers(params.userAccounts);
@@ -725,30 +743,7 @@ class DriftClient {
                 // if cache has more recent slot than user positions account slot, add market to remaining accounts
                 // otherwise remove from slot
                 if (slot > lastUserSlot) {
-                    const perpMarketAccount = this.getPerpMarketAccount(marketIndex);
-                    perpMarketAccountMap.set(marketIndex, {
-                        pubkey: perpMarketAccount.pubkey,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                    oracleAccountMap.set(perpMarketAccount.amm.oracle.toString(), {
-                        pubkey: perpMarketAccount.amm.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                    const spotMarketAccount = this.getSpotMarketAccount(perpMarketAccount.quoteSpotMarketIndex);
-                    spotMarketAccountMap.set(perpMarketAccount.quoteSpotMarketIndex, {
-                        pubkey: spotMarketAccount.pubkey,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                    if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                        oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                            pubkey: spotMarketAccount.oracle,
-                            isSigner: false,
-                            isWritable: false,
-                        });
-                    }
+                    this.addPerpMarketToRemainingAccountMaps(marketIndex, false, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
                 }
                 else {
                     this.perpMarketLastSlotCache.delete(marketIndex);
@@ -758,19 +753,7 @@ class DriftClient {
                 // if cache has more recent slot than user positions account slot, add market to remaining accounts
                 // otherwise remove from slot
                 if (slot > lastUserSlot) {
-                    const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
-                    spotMarketAccountMap.set(marketIndex, {
-                        pubkey: spotMarketAccount.pubkey,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                    if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                        oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                            pubkey: spotMarketAccount.oracle,
-                            isSigner: false,
-                            isWritable: false,
-                        });
-                    }
+                    this.addSpotMarketToRemainingAccountMaps(marketIndex, false, oracleAccountMap, spotMarketAccountMap);
                 }
                 else {
                     this.spotMarketLastSlotCache.delete(marketIndex);
@@ -778,91 +761,32 @@ class DriftClient {
             }
         }
         if (params.readablePerpMarketIndex !== undefined) {
-            const perpMarketAccount = this.getPerpMarketAccount(params.readablePerpMarketIndex);
-            perpMarketAccountMap.set(params.readablePerpMarketIndex, {
-                pubkey: perpMarketAccount.pubkey,
-                isSigner: false,
-                isWritable: false,
-            });
-            oracleAccountMap.set(perpMarketAccount.amm.oracle.toString(), {
-                pubkey: perpMarketAccount.amm.oracle,
-                isSigner: false,
-                isWritable: false,
-            });
-            const spotMarketAccount = this.getSpotMarketAccount(perpMarketAccount.quoteSpotMarketIndex);
-            spotMarketAccountMap.set(perpMarketAccount.quoteSpotMarketIndex, {
-                pubkey: spotMarketAccount.pubkey,
-                isSigner: false,
-                isWritable: false,
-            });
-            if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                    pubkey: spotMarketAccount.oracle,
-                    isSigner: false,
-                    isWritable: false,
-                });
+            const readablePerpMarketIndexes = Array.isArray(params.readablePerpMarketIndex)
+                ? params.readablePerpMarketIndex
+                : [params.readablePerpMarketIndex];
+            for (const marketIndex of readablePerpMarketIndexes) {
+                this.addPerpMarketToRemainingAccountMaps(marketIndex, false, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
             }
         }
+        for (const perpMarketIndex of this.mustIncludePerpMarketIndexes.values()) {
+            this.addPerpMarketToRemainingAccountMaps(perpMarketIndex, false, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
+        }
         if (params.readableSpotMarketIndexes !== undefined) {
             for (const readableSpotMarketIndex of params.readableSpotMarketIndexes) {
-                const spotMarketAccount = this.getSpotMarketAccount(readableSpotMarketIndex);
-                spotMarketAccountMap.set(readableSpotMarketIndex, {
-                    pubkey: spotMarketAccount.pubkey,
-                    isSigner: false,
-                    isWritable: false,
-                });
-                if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                        pubkey: spotMarketAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
+                this.addSpotMarketToRemainingAccountMaps(readableSpotMarketIndex, false, oracleAccountMap, spotMarketAccountMap);
             }
         }
+        for (const spotMarketIndex of this.mustIncludeSpotMarketIndexes.values()) {
+            this.addSpotMarketToRemainingAccountMaps(spotMarketIndex, false, oracleAccountMap, spotMarketAccountMap);
+        }
         if (params.writablePerpMarketIndexes !== undefined) {
             for (const writablePerpMarketIndex of params.writablePerpMarketIndexes) {
-                const perpMarketAccount = this.getPerpMarketAccount(writablePerpMarketIndex);
-                perpMarketAccountMap.set(writablePerpMarketIndex, {
-                    pubkey: perpMarketAccount.pubkey,
-                    isSigner: false,
-                    isWritable: true,
-                });
-                oracleAccountMap.set(perpMarketAccount.amm.oracle.toString(), {
-                    pubkey: perpMarketAccount.amm.oracle,
-                    isSigner: false,
-                    isWritable: false,
-                });
-                const spotMarketAccount = this.getSpotMarketAccount(perpMarketAccount.quoteSpotMarketIndex);
-                spotMarketAccountMap.set(perpMarketAccount.quoteSpotMarketIndex, {
-                    pubkey: spotMarketAccount.pubkey,
-                    isSigner: false,
-                    isWritable: false,
-                });
-                if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                        pubkey: spotMarketAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
+                this.addPerpMarketToRemainingAccountMaps(writablePerpMarketIndex, true, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
             }
         }
         if (params.writableSpotMarketIndexes !== undefined) {
             for (const writableSpotMarketIndex of params.writableSpotMarketIndexes) {
-                const spotMarketAccount = this.getSpotMarketAccount(writableSpotMarketIndex);
-                spotMarketAccountMap.set(spotMarketAccount.marketIndex, {
-                    pubkey: spotMarketAccount.pubkey,
-                    isSigner: false,
-                    isWritable: true,
-                });
-                if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                    oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                        pubkey: spotMarketAccount.oracle,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                }
+                this.addSpotMarketToRemainingAccountMaps(writableSpotMarketIndex, true, oracleAccountMap, spotMarketAccountMap);
             }
         }
         return [
@@ -871,6 +795,35 @@ class DriftClient {
             ...perpMarketAccountMap.values(),
         ];
     }
+    addPerpMarketToRemainingAccountMaps(marketIndex, writable, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap) {
+        const perpMarketAccount = this.getPerpMarketAccount(marketIndex);
+        perpMarketAccountMap.set(marketIndex, {
+            pubkey: perpMarketAccount.pubkey,
+            isSigner: false,
+            isWritable: writable,
+        });
+        oracleAccountMap.set(perpMarketAccount.amm.oracle.toString(), {
+            pubkey: perpMarketAccount.amm.oracle,
+            isSigner: false,
+            isWritable: false,
+        });
+        this.addSpotMarketToRemainingAccountMaps(perpMarketAccount.quoteSpotMarketIndex, false, oracleAccountMap, spotMarketAccountMap);
+    }
+    addSpotMarketToRemainingAccountMaps(marketIndex, writable, oracleAccountMap, spotMarketAccountMap) {
+        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+        spotMarketAccountMap.set(spotMarketAccount.marketIndex, {
+            pubkey: spotMarketAccount.pubkey,
+            isSigner: false,
+            isWritable: writable,
+        });
+        if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
+            oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+                pubkey: spotMarketAccount.oracle,
+                isSigner: false,
+                isWritable: false,
+            });
+        }
+    }
     getRemainingAccountMapsForUsers(userAccounts) {
         const oracleAccountMap = new Map();
         const spotMarketAccountMap = new Map();
@@ -878,63 +831,16 @@ class DriftClient {
         for (const userAccount of userAccounts) {
             for (const spotPosition of userAccount.spotPositions) {
                 if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
-                    const spotMarket = this.getSpotMarketAccount(spotPosition.marketIndex);
-                    spotMarketAccountMap.set(spotPosition.marketIndex, {
-                        pubkey: spotMarket.pubkey,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                    if (!spotMarket.oracle.equals(web3_js_1.PublicKey.default)) {
-                        oracleAccountMap.set(spotMarket.oracle.toString(), {
-                            pubkey: spotMarket.oracle,
-                            isSigner: false,
-                            isWritable: false,
-                        });
-                    }
+                    this.addSpotMarketToRemainingAccountMaps(spotPosition.marketIndex, false, oracleAccountMap, spotMarketAccountMap);
                     if (!spotPosition.openAsks.eq(numericConstants_1.ZERO) ||
                         !spotPosition.openBids.eq(numericConstants_1.ZERO)) {
-                        const quoteSpotMarket = this.getQuoteSpotMarketAccount();
-                        spotMarketAccountMap.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, {
-                            pubkey: quoteSpotMarket.pubkey,
-                            isSigner: false,
-                            isWritable: false,
-                        });
-                        if (!quoteSpotMarket.oracle.equals(web3_js_1.PublicKey.default)) {
-                            oracleAccountMap.set(quoteSpotMarket.oracle.toString(), {
-                                pubkey: quoteSpotMarket.oracle,
-                                isSigner: false,
-                                isWritable: false,
-                            });
-                        }
+                        this.addSpotMarketToRemainingAccountMaps(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, false, oracleAccountMap, spotMarketAccountMap);
                     }
                 }
             }
             for (const position of userAccount.perpPositions) {
                 if (!(0, position_1.positionIsAvailable)(position)) {
-                    const perpMarketAccount = this.getPerpMarketAccount(position.marketIndex);
-                    perpMarketAccountMap.set(position.marketIndex, {
-                        pubkey: perpMarketAccount.pubkey,
-                        isWritable: false,
-                        isSigner: false,
-                    });
-                    oracleAccountMap.set(perpMarketAccount.amm.oracle.toString(), {
-                        pubkey: perpMarketAccount.amm.oracle,
-                        isWritable: false,
-                        isSigner: false,
-                    });
-                    const spotMarketAccount = this.getSpotMarketAccount(perpMarketAccount.quoteSpotMarketIndex);
-                    spotMarketAccountMap.set(perpMarketAccount.quoteSpotMarketIndex, {
-                        pubkey: spotMarketAccount.pubkey,
-                        isSigner: false,
-                        isWritable: false,
-                    });
-                    if (!spotMarketAccount.oracle.equals(web3_js_1.PublicKey.default)) {
-                        oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
-                            pubkey: spotMarketAccount.oracle,
-                            isSigner: false,
-                            isWritable: false,
-                        });
-                    }
+                    this.addPerpMarketToRemainingAccountMaps(position.marketIndex, false, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
                 }
             }
         }
@@ -1645,23 +1551,45 @@ class DriftClient {
         });
     }
     async cancelAndPlaceOrders(cancelOrderParams, placeOrderParams, txParams) {
-        const tx = (0, utils_1.wrapInTx)(await this.getCancelOrdersIx(cancelOrderParams.marketType, cancelOrderParams.marketIndex, cancelOrderParams.direction), txParams === null || txParams === void 0 ? void 0 : txParams.computeUnits, txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsPrice);
-        for (const placeOrderParam of placeOrderParams) {
-            const marketType = placeOrderParam.marketType;
-            if (!marketType) {
-                throw new Error('marketType must be set on placeOrderParams');
-            }
-            let ix;
-            if ((0, types_1.isVariant)(marketType, 'perp')) {
-                ix = this.getPlacePerpOrderIx(placeOrderParam);
+        const ixs = [
+            await this.getCancelOrdersIx(cancelOrderParams.marketType, cancelOrderParams.marketIndex, cancelOrderParams.direction),
+            await this.getPlaceOrdersIx(placeOrderParams),
+        ];
+        const tx = await this.buildTransaction(ixs, txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async placeOrders(params, txParams) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceOrdersIx(params), txParams), [], this.opts);
+        return txSig;
+    }
+    async getPlaceOrdersIx(params) {
+        const userAccountPublicKey = await this.getUserAccountPublicKey();
+        const readablePerpMarketIndex = [];
+        const readableSpotMarketIndexes = [];
+        for (const param of params) {
+            if ((0, types_1.isVariant)(param.marketType, 'perp')) {
+                readablePerpMarketIndex.push(param.marketIndex);
             }
             else {
-                ix = this.getPlaceSpotOrderIx(placeOrderParam);
+                readableSpotMarketIndexes.push(param.marketIndex);
             }
-            tx.add(ix);
         }
-        const { txSig } = await this.sendTransaction(tx, [], this.opts);
-        return txSig;
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount()],
+            readablePerpMarketIndex,
+            readableSpotMarketIndexes,
+            useMarketLastSlotCache: true,
+        });
+        return await this.program.instruction.placeOrders(params, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: userAccountPublicKey,
+                userStats: this.getUserStatsAccountPublicKey(),
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts,
+        });
     }
     async fillPerpOrder(userAccountPublicKey, user, order, makerInfo, referrerInfo, txParams) {
         const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getFillPerpOrderIx(userAccountPublicKey, user, order, makerInfo, referrerInfo), txParams), [], this.opts);
@@ -2112,6 +2040,39 @@ class DriftClient {
         });
         return { beginSwapIx, endSwapIx };
     }
+    async stakeForMSOL({ amount }) {
+        const ixs = await this.getStakeForMSOLIx({ amount });
+        const tx = await this.buildTransaction(ixs);
+        return this.sendTransaction(tx);
+    }
+    async getStakeForMSOLIx({ amount, }) {
+        const wSOLMint = this.getSpotMarketAccount(1).mint;
+        const mSOLAccount = await this.getAssociatedTokenAccount(2);
+        const wSOLAccount = await this.getAssociatedTokenAccount(1, false);
+        const wSOLAccountExists = await this.checkIfAccountExists(wSOLAccount);
+        const closeWSOLIx = (0, spl_token_1.createCloseAccountInstruction)(wSOLAccount, this.wallet.publicKey, this.wallet.publicKey);
+        const createWSOLIx = await this.createAssociatedTokenAccountIdempotentInstruction(wSOLAccount, this.wallet.publicKey, this.wallet.publicKey, wSOLMint);
+        const { beginSwapIx, endSwapIx } = await this.getSwapIx({
+            inMarketIndex: 1,
+            outMarketIndex: 2,
+            amountIn: amount,
+            inTokenAccount: wSOLAccount,
+            outTokenAccount: mSOLAccount,
+        });
+        const program = (0, marinade_1.getMarinadeFinanceProgram)(this.provider);
+        const depositIx = await (0, marinade_1.getMarinadeDepositIx)({
+            program,
+            mSOLAccount: mSOLAccount,
+            transferFrom: this.wallet.publicKey,
+            amount,
+        });
+        const ixs = [];
+        if (!wSOLAccountExists) {
+            ixs.push(createWSOLIx);
+        }
+        ixs.push(beginSwapIx, closeWSOLIx, depositIx, createWSOLIx, endSwapIx);
+        return ixs;
+    }
     async triggerOrder(userAccountPublicKey, user, order, txParams) {
         const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getTriggerOrderIx(userAccountPublicKey, user, order), txParams), [], this.opts);
         return txSig;

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.31.1-beta.9",
+    "version": "2.31.1-beta.11",
     "name": "drift",
     "instructions": [
         {
@@ -710,6 +710,36 @@
                 }
             ]
         },
+        {
+            "name": "placeOrders",
+            "accounts": [
+                {
+                    "name": "state",
+                    "isMut": false,
+                    "isSigner": false
+                },
+                {
+                    "name": "user",
+                    "isMut": true,
+                    "isSigner": false
+                },
+                {
+                    "name": "authority",
+                    "isMut": false,
+                    "isSigner": true
+                }
+            ],
+            "args": [
+                {
+                    "name": "params",
+                    "type": {
+                        "vec": {
+                            "defined": "OrderParams"
+                        }
+                    }
+                }
+            ]
+        },
         {
             "name": "beginSwap",
             "accounts": [

package/lib/index.d.ts

@@ -45,6 +45,7 @@ export * from './math/orders';
 export * from './math/repeg';
 export * from './math/margin';
 export * from './math/insurance';
+export * from './marinade';
 export * from './orderParams';
 export * from './slot/SlotSubscriber';
 export * from './wallet';

package/lib/index.js

@@ -68,6 +68,7 @@ __exportStar(require("./math/orders"), exports);
 __exportStar(require("./math/repeg"), exports);
 __exportStar(require("./math/margin"), exports);
 __exportStar(require("./math/insurance"), exports);
+__exportStar(require("./marinade"), exports);
 __exportStar(require("./orderParams"), exports);
 __exportStar(require("./slot/SlotSubscriber"), exports);
 __exportStar(require("./wallet"), exports);

package/lib/marinade/index.d.ts

@@ -0,0 +1,11 @@
+import { AnchorProvider, BN, Program } from '@coral-xyz/anchor';
+import { MarinadeFinance } from './types';
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+export declare function getMarinadeFinanceProgram(provider: AnchorProvider): Program<MarinadeFinance>;
+export declare function getMarinadeDepositIx({ program, amount, mSOLAccount, transferFrom, }: {
+    amount: BN;
+    mSOLAccount: PublicKey;
+    transferFrom: PublicKey;
+    program: Program<MarinadeFinance>;
+}): Promise<TransactionInstruction>;
+export declare function getMarinadeMSolPrice(program: Program<MarinadeFinance>): Promise<number>;

package/lib/marinade/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarinadeMSolPrice = exports.getMarinadeDepositIx = exports.getMarinadeFinanceProgram = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const types_1 = require("./types");
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const marinadeFinanceProgramId = new web3_js_1.PublicKey('MarBmsSgKXdrN1egZf5sqe1TMai9K1rChYNDJgjq7aD');
+function getMarinadeFinanceProgram(provider) {
+    return new anchor_1.Program(types_1.IDL, marinadeFinanceProgramId, provider);
+}
+exports.getMarinadeFinanceProgram = getMarinadeFinanceProgram;
+function getMarinadeDepositIx({ program, amount, mSOLAccount, transferFrom, }) {
+    return program.methods
+        .deposit(amount)
+        .accountsStrict({
+        reservePda: new web3_js_1.PublicKey('Du3Ysj1wKbxPKkuPPnvzQLQh8oMSVifs3jGZjJWXFmHN'),
+        state: new web3_js_1.PublicKey('8szGkuLTAux9XMgZ2vtY39jVSowEcpBfFfD8hXSEqdGC'),
+        msolMint: new web3_js_1.PublicKey('mSoLzYCxHdYgdzU16g5QSh3i5K3z3KZK7ytfqcJm7So'),
+        msolMintAuthority: new web3_js_1.PublicKey('3JLPCS1qM2zRw3Dp6V4hZnYHd4toMNPkNesXdX9tg6KM'),
+        liqPoolMsolLegAuthority: new web3_js_1.PublicKey('EyaSjUtSgo9aRD1f8LWXwdvkpDTmXAW54yoSHZRF14WL'),
+        liqPoolMsolLeg: new web3_js_1.PublicKey('7GgPYjS5Dza89wV6FpZ23kUJRG5vbQ1GM25ezspYFSoE'),
+        liqPoolSolLegPda: new web3_js_1.PublicKey('UefNb6z6yvArqe4cJHTXCqStRsKmWhGxnZzuHbikP5Q'),
+        mintTo: mSOLAccount,
+        transferFrom,
+        systemProgram: web3_js_1.SystemProgram.programId,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+    })
+        .instruction();
+}
+exports.getMarinadeDepositIx = getMarinadeDepositIx;
+async function getMarinadeMSolPrice(program) {
+    const state = await program.account.state.fetch(new web3_js_1.PublicKey('8szGkuLTAux9XMgZ2vtY39jVSowEcpBfFfD8hXSEqdGC'));
+    return state.msolPrice.toNumber() / 4294967296;
+}
+exports.getMarinadeMSolPrice = getMarinadeMSolPrice;