@drift-labs/sdk-browser 2.163.0-beta.12 → 2.163.0-beta.13

package/lib/browser/core/index.js

@@ -0,0 +1,28 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DriftCore"), exports);
+__exportStar(require("./remainingAccounts"), exports);
+__exportStar(require("./signedMsg"), exports);
+__exportStar(require("./instructions/deposit"), exports);
+__exportStar(require("./instructions/withdraw"), exports);
+__exportStar(require("./instructions/orders"), exports);
+__exportStar(require("./instructions/fill"), exports);
+__exportStar(require("./instructions/trigger"), exports);
+__exportStar(require("./instructions/settlement"), exports);
+__exportStar(require("./instructions/liquidation"), exports);
+__exportStar(require("./instructions/perpOrders"), exports);
+__exportStar(require("./instructions/funding"), exports);

package/lib/browser/core/instructions/deposit.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="bn.js" />
+import type { AccountMeta, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import type { BN } from '../../isomorphic/anchor';
+import type { DriftProgram } from '../../config';
+export declare function buildDepositInstruction(args: {
+    program: DriftProgram;
+    marketIndex: number;
+    amount: BN;
+    reduceOnly: boolean;
+    state: PublicKey;
+    spotMarket: PublicKey;
+    spotMarketVault: PublicKey;
+    user: PublicKey;
+    userStats: PublicKey;
+    userTokenAccount: PublicKey;
+    authority: PublicKey;
+    tokenProgram: PublicKey;
+    remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction>;

package/lib/browser/core/instructions/deposit.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDepositInstruction = void 0;
+async function buildDepositInstruction(args) {
+    return await args.program.instruction.deposit(args.marketIndex, args.amount, args.reduceOnly, {
+        accounts: {
+            state: args.state,
+            spotMarket: args.spotMarket,
+            spotMarketVault: args.spotMarketVault,
+            user: args.user,
+            userStats: args.userStats,
+            userTokenAccount: args.userTokenAccount,
+            authority: args.authority,
+            tokenProgram: args.tokenProgram,
+        },
+        remainingAccounts: args.remainingAccounts,
+    });
+}
+exports.buildDepositInstruction = buildDepositInstruction;

package/lib/browser/core/instructions/fill.d.ts

@@ -0,0 +1,13 @@
+import type { AccountMeta, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import type { DriftProgram } from '../../config';
+export declare function buildFillPerpOrderInstruction(args: {
+    program: DriftProgram;
+    orderId: number | null;
+    state: PublicKey;
+    filler: PublicKey;
+    fillerStats: PublicKey;
+    user: PublicKey;
+    userStats: PublicKey;
+    authority: PublicKey;
+    remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction>;

package/lib/browser/core/instructions/fill.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFillPerpOrderInstruction = void 0;
+async function buildFillPerpOrderInstruction(args) {
+    return await args.program.instruction.fillPerpOrder(args.orderId, null, {
+        accounts: {
+            state: args.state,
+            filler: args.filler,
+            fillerStats: args.fillerStats,
+            user: args.user,
+            userStats: args.userStats,
+            authority: args.authority,
+        },
+        remainingAccounts: args.remainingAccounts,
+    });
+}
+exports.buildFillPerpOrderInstruction = buildFillPerpOrderInstruction;

package/lib/browser/core/instructions/funding.d.ts

@@ -0,0 +1,9 @@
+import type { PublicKey, TransactionInstruction } from '@solana/web3.js';
+import type { DriftProgram } from '../../config';
+export declare function buildUpdateFundingRateInstruction(args: {
+    program: DriftProgram;
+    perpMarketIndex: number;
+    state: PublicKey;
+    perpMarket: PublicKey;
+    oracle: PublicKey;
+}): Promise<TransactionInstruction>;

package/lib/browser/core/instructions/funding.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUpdateFundingRateInstruction = void 0;
+async function buildUpdateFundingRateInstruction(args) {
+    return await args.program.instruction.updateFundingRate(args.perpMarketIndex, {
+        accounts: {
+            state: args.state,
+            perpMarket: args.perpMarket,
+            oracle: args.oracle,
+        },
+    });
+}
+exports.buildUpdateFundingRateInstruction = buildUpdateFundingRateInstruction;

package/lib/browser/core/instructions/liquidation.d.ts

@@ -0,0 +1,15 @@
+import type { AccountMeta, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import type { DriftProgram } from '../../config';
+export declare function buildLiquidatePerpInstruction(args: {
+    program: DriftProgram;
+    marketIndex: number;
+    maxBaseAssetAmount: any;
+    limitPrice: any | null;
+    state: PublicKey;
+    authority: PublicKey;
+    user: PublicKey;
+    userStats: PublicKey;
+    liquidator: PublicKey;
+    liquidatorStats: PublicKey;
+    remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction>;

package/lib/browser/core/instructions/liquidation.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildLiquidatePerpInstruction = void 0;
+async function buildLiquidatePerpInstruction(args) {
+    return await args.program.instruction.liquidatePerp(args.marketIndex, args.maxBaseAssetAmount, args.limitPrice, {
+        accounts: {
+            state: args.state,
+            authority: args.authority,
+            user: args.user,
+            userStats: args.userStats,
+            liquidator: args.liquidator,
+            liquidatorStats: args.liquidatorStats,
+        },
+        remainingAccounts: args.remainingAccounts,
+    });
+}
+exports.buildLiquidatePerpInstruction = buildLiquidatePerpInstruction;

package/lib/browser/core/instructions/orders.d.ts

@@ -0,0 +1,22 @@
+import type { AccountMeta, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import type { DriftProgram } from '../../config';
+export declare function buildPlaceOrdersInstruction(args: {
+    program: DriftProgram;
+    formattedParams: any[];
+    state: PublicKey;
+    user: PublicKey;
+    userStats: PublicKey;
+    authority: PublicKey;
+    remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction>;
+export declare function buildCancelOrdersInstruction(args: {
+    program: DriftProgram;
+    marketType: any;
+    marketIndex: number | null;
+    direction: any;
+    user: PublicKey;
+    state: PublicKey;
+    userStats: PublicKey;
+    authority: PublicKey;
+    remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction>;

package/lib/browser/core/instructions/orders.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCancelOrdersInstruction = exports.buildPlaceOrdersInstruction = void 0;
+async function buildPlaceOrdersInstruction(args) {
+    return await args.program.instruction.placeOrders(args.formattedParams, {
+        accounts: {
+            state: args.state,
+            user: args.user,
+            userStats: args.userStats,
+            authority: args.authority,
+        },
+        remainingAccounts: args.remainingAccounts,
+    });
+}
+exports.buildPlaceOrdersInstruction = buildPlaceOrdersInstruction;
+async function buildCancelOrdersInstruction(args) {
+    return await args.program.instruction.cancelOrders(args.marketType, args.marketIndex, args.direction, {
+        accounts: {
+            state: args.state,
+            user: args.user,
+            userStats: args.userStats,
+            authority: args.authority,
+        },
+        remainingAccounts: args.remainingAccounts,
+    });
+}
+exports.buildCancelOrdersInstruction = buildCancelOrdersInstruction;

package/lib/browser/core/instructions/perpOrders.d.ts

@@ -0,0 +1,78 @@
+import type { AccountMeta, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import type { DriftProgram } from '../../config';
+export declare function buildPlacePerpOrderInstruction(args: {
+    program: DriftProgram;
+    orderParams: any;
+    state: PublicKey;
+    user: PublicKey;
+    userStats: PublicKey;
+    authority: PublicKey;
+    remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction>;
+export declare function buildPlaceAndTakePerpOrderInstruction(args: {
+    program: DriftProgram;
+    orderParams: any;
+    optionalParams: number | null;
+    state: PublicKey;
+    user: PublicKey;
+    userStats: PublicKey;
+    authority: PublicKey;
+    remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction>;
+export declare function buildPlaceAndMakePerpOrderInstruction(args: {
+    program: DriftProgram;
+    orderParams: any;
+    takerOrderId: number;
+    state: PublicKey;
+    user: PublicKey;
+    userStats: PublicKey;
+    taker: PublicKey;
+    takerStats: PublicKey;
+    authority: PublicKey;
+    remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction>;
+export declare function buildCancelOrderInstruction(args: {
+    program: DriftProgram;
+    orderId: number | null;
+    state: PublicKey;
+    user: PublicKey;
+    authority: PublicKey;
+    remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction>;
+export declare function buildCancelOrderByUserIdInstruction(args: {
+    program: DriftProgram;
+    userOrderId: number;
+    state: PublicKey;
+    user: PublicKey;
+    authority: PublicKey;
+    oracle: PublicKey;
+    remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction>;
+export declare function buildCancelOrdersByIdsInstruction(args: {
+    program: DriftProgram;
+    orderIds: number[] | undefined;
+    state: PublicKey;
+    user: PublicKey;
+    authority: PublicKey;
+    remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction>;
+export declare function buildModifyOrderInstruction(args: {
+    program: DriftProgram;
+    orderId: number;
+    modifyParams: any;
+    state: PublicKey;
+    user: PublicKey;
+    userStats: PublicKey;
+    authority: PublicKey;
+    remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction>;
+export declare function buildModifyOrderByUserIdInstruction(args: {
+    program: DriftProgram;
+    userOrderId: number;
+    modifyParams: any;
+    state: PublicKey;
+    user: PublicKey;
+    userStats: PublicKey;
+    authority: PublicKey;
+    remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction>;

package/lib/browser/core/instructions/perpOrders.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildModifyOrderByUserIdInstruction = exports.buildModifyOrderInstruction = exports.buildCancelOrdersByIdsInstruction = exports.buildCancelOrderByUserIdInstruction = exports.buildCancelOrderInstruction = exports.buildPlaceAndMakePerpOrderInstruction = exports.buildPlaceAndTakePerpOrderInstruction = exports.buildPlacePerpOrderInstruction = void 0;
+async function buildPlacePerpOrderInstruction(args) {
+    return await args.program.instruction.placePerpOrder(args.orderParams, {
+        accounts: {
+            state: args.state,
+            user: args.user,
+            userStats: args.userStats,
+            authority: args.authority,
+        },
+        remainingAccounts: args.remainingAccounts,
+    });
+}
+exports.buildPlacePerpOrderInstruction = buildPlacePerpOrderInstruction;
+async function buildPlaceAndTakePerpOrderInstruction(args) {
+    return await args.program.instruction.placeAndTakePerpOrder(args.orderParams, args.optionalParams, {
+        accounts: {
+            state: args.state,
+            user: args.user,
+            userStats: args.userStats,
+            authority: args.authority,
+        },
+        remainingAccounts: args.remainingAccounts,
+    });
+}
+exports.buildPlaceAndTakePerpOrderInstruction = buildPlaceAndTakePerpOrderInstruction;
+async function buildPlaceAndMakePerpOrderInstruction(args) {
+    return await args.program.instruction.placeAndMakePerpOrder(args.orderParams, args.takerOrderId, {
+        accounts: {
+            state: args.state,
+            user: args.user,
+            userStats: args.userStats,
+            taker: args.taker,
+            takerStats: args.takerStats,
+            authority: args.authority,
+        },
+        remainingAccounts: args.remainingAccounts,
+    });
+}
+exports.buildPlaceAndMakePerpOrderInstruction = buildPlaceAndMakePerpOrderInstruction;
+async function buildCancelOrderInstruction(args) {
+    return await args.program.instruction.cancelOrder(args.orderId, {
+        accounts: {
+            state: args.state,
+            user: args.user,
+            authority: args.authority,
+        },
+        remainingAccounts: args.remainingAccounts,
+    });
+}
+exports.buildCancelOrderInstruction = buildCancelOrderInstruction;
+async function buildCancelOrderByUserIdInstruction(args) {
+    return await args.program.instruction.cancelOrderByUserId(args.userOrderId, {
+        accounts: {
+            state: args.state,
+            user: args.user,
+            authority: args.authority,
+            oracle: args.oracle,
+        },
+        remainingAccounts: args.remainingAccounts,
+    });
+}
+exports.buildCancelOrderByUserIdInstruction = buildCancelOrderByUserIdInstruction;
+async function buildCancelOrdersByIdsInstruction(args) {
+    return await args.program.instruction.cancelOrdersByIds(args.orderIds, {
+        accounts: {
+            state: args.state,
+            user: args.user,
+            authority: args.authority,
+        },
+        remainingAccounts: args.remainingAccounts,
+    });
+}
+exports.buildCancelOrdersByIdsInstruction = buildCancelOrdersByIdsInstruction;
+async function buildModifyOrderInstruction(args) {
+    return await args.program.instruction.modifyOrder(args.orderId, args.modifyParams, {
+        accounts: {
+            state: args.state,
+            user: args.user,
+            userStats: args.userStats,
+            authority: args.authority,
+        },
+        remainingAccounts: args.remainingAccounts,
+    });
+}
+exports.buildModifyOrderInstruction = buildModifyOrderInstruction;
+async function buildModifyOrderByUserIdInstruction(args) {
+    return await args.program.instruction.modifyOrderByUserId(args.userOrderId, args.modifyParams, {
+        accounts: {
+            state: args.state,
+            user: args.user,
+            userStats: args.userStats,
+            authority: args.authority,
+        },
+        remainingAccounts: args.remainingAccounts,
+    });
+}
+exports.buildModifyOrderByUserIdInstruction = buildModifyOrderByUserIdInstruction;

package/lib/browser/core/instructions/settlement.d.ts

@@ -0,0 +1,11 @@
+import type { AccountMeta, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import type { DriftProgram } from '../../config';
+export declare function buildSettlePnlInstruction(args: {
+    program: DriftProgram;
+    marketIndex: number;
+    state: PublicKey;
+    authority: PublicKey;
+    user: PublicKey;
+    spotMarketVault: PublicKey;
+    remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction>;

package/lib/browser/core/instructions/settlement.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSettlePnlInstruction = void 0;
+async function buildSettlePnlInstruction(args) {
+    return await args.program.instruction.settlePnl(args.marketIndex, {
+        accounts: {
+            state: args.state,
+            authority: args.authority,
+            user: args.user,
+            spotMarketVault: args.spotMarketVault,
+        },
+        remainingAccounts: args.remainingAccounts,
+    });
+}
+exports.buildSettlePnlInstruction = buildSettlePnlInstruction;

package/lib/browser/core/instructions/trigger.d.ts

@@ -0,0 +1,11 @@
+import type { AccountMeta, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import type { DriftProgram } from '../../config';
+export declare function buildTriggerOrderInstruction(args: {
+    program: DriftProgram;
+    orderId: number;
+    state: PublicKey;
+    filler: PublicKey;
+    user: PublicKey;
+    authority: PublicKey;
+    remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction>;

package/lib/browser/core/instructions/trigger.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTriggerOrderInstruction = void 0;
+async function buildTriggerOrderInstruction(args) {
+    return await args.program.instruction.triggerOrder(args.orderId, {
+        accounts: {
+            state: args.state,
+            filler: args.filler,
+            user: args.user,
+            authority: args.authority,
+        },
+        remainingAccounts: args.remainingAccounts,
+    });
+}
+exports.buildTriggerOrderInstruction = buildTriggerOrderInstruction;

package/lib/browser/core/instructions/withdraw.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="bn.js" />
+import type { AccountMeta, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import type { BN } from '../../isomorphic/anchor';
+import type { DriftProgram } from '../../config';
+export declare function buildWithdrawInstruction(args: {
+    program: DriftProgram;
+    marketIndex: number;
+    amount: BN;
+    reduceOnly: boolean;
+    state: PublicKey;
+    spotMarket: PublicKey;
+    spotMarketVault: PublicKey;
+    driftSigner: PublicKey;
+    user: PublicKey;
+    userStats: PublicKey;
+    userTokenAccount: PublicKey;
+    authority: PublicKey;
+    tokenProgram: PublicKey;
+    remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction>;

package/lib/browser/core/instructions/withdraw.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildWithdrawInstruction = void 0;
+async function buildWithdrawInstruction(args) {
+    return await args.program.instruction.withdraw(args.marketIndex, args.amount, args.reduceOnly, {
+        accounts: {
+            state: args.state,
+            spotMarket: args.spotMarket,
+            spotMarketVault: args.spotMarketVault,
+            driftSigner: args.driftSigner,
+            user: args.user,
+            userStats: args.userStats,
+            userTokenAccount: args.userTokenAccount,
+            authority: args.authority,
+            tokenProgram: args.tokenProgram,
+        },
+        remainingAccounts: args.remainingAccounts,
+    });
+}
+exports.buildWithdrawInstruction = buildWithdrawInstruction;

package/lib/browser/core/remainingAccounts.d.ts

@@ -0,0 +1,27 @@
+import { PublicKey, type AccountMeta } from '@solana/web3.js';
+import type { UserAccount, SpotMarketAccount, PerpMarketAccount } from '../types';
+export type RemainingAccountParams = {
+    userAccounts: UserAccount[];
+    writablePerpMarketIndexes?: number[];
+    writableSpotMarketIndexes?: number[];
+    readablePerpMarketIndex?: number | number[];
+    readableSpotMarketIndexes?: number[];
+    useMarketLastSlotCache?: boolean;
+};
+export type RemainingAccountsContext = {
+    /** Used to resolve market accounts. */
+    getPerpMarketAccount: (marketIndex: number) => PerpMarketAccount;
+    getSpotMarketAccount: (marketIndex: number) => SpotMarketAccount;
+    /** Used to resolve user's last slot for cache invalidation. */
+    getUserAccountAndSlot: (subAccountId: number, authority: PublicKey) => {
+        slot: number;
+    } | undefined;
+    activeSubAccountId: number;
+    authority: PublicKey;
+    /** Mutable caches + forced-market sets (owned by caller). */
+    perpMarketLastSlotCache: Map<number, number>;
+    spotMarketLastSlotCache: Map<number, number>;
+    mustIncludePerpMarketIndexes: Set<number>;
+    mustIncludeSpotMarketIndexes: Set<number>;
+};
+export declare function getRemainingAccounts(ctx: RemainingAccountsContext, params: RemainingAccountParams): AccountMeta[];

package/lib/browser/core/remainingAccounts.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRemainingAccounts = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const types_1 = require("../types");
+const numericConstants_1 = require("../constants/numericConstants");
+const spotPosition_1 = require("../math/spotPosition");
+const position_1 = require("../math/position");
+function getRemainingAccounts(ctx, params) {
+    var _a;
+    const { oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap } = getRemainingAccountMapsForUsers(ctx, params.userAccounts);
+    if (params.useMarketLastSlotCache) {
+        const lastUserSlot = (_a = ctx.getUserAccountAndSlot(params.userAccounts.length > 0
+            ? params.userAccounts[0].subAccountId
+            : ctx.activeSubAccountId, params.userAccounts.length > 0
+            ? params.userAccounts[0].authority
+            : ctx.authority)) === null || _a === void 0 ? void 0 : _a.slot;
+        for (const [marketIndex, slot] of ctx.perpMarketLastSlotCache.entries()) {
+            if (slot > lastUserSlot) {
+                addPerpMarketToRemainingAccountMaps(ctx, marketIndex, false, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
+            }
+            else {
+                ctx.perpMarketLastSlotCache.delete(marketIndex);
+            }
+        }
+        for (const [marketIndex, slot] of ctx.spotMarketLastSlotCache.entries()) {
+            if (slot > lastUserSlot) {
+                addSpotMarketToRemainingAccountMaps(ctx, marketIndex, false, oracleAccountMap, spotMarketAccountMap);
+            }
+            else {
+                ctx.spotMarketLastSlotCache.delete(marketIndex);
+            }
+        }
+    }
+    if (params.readablePerpMarketIndex !== undefined) {
+        const readablePerpMarketIndexes = Array.isArray(params.readablePerpMarketIndex)
+            ? params.readablePerpMarketIndex
+            : [params.readablePerpMarketIndex];
+        for (const marketIndex of readablePerpMarketIndexes) {
+            addPerpMarketToRemainingAccountMaps(ctx, marketIndex, false, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
+        }
+    }
+    for (const perpMarketIndex of ctx.mustIncludePerpMarketIndexes.values()) {
+        addPerpMarketToRemainingAccountMaps(ctx, perpMarketIndex, false, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
+    }
+    if (params.readableSpotMarketIndexes !== undefined) {
+        for (const readableSpotMarketIndex of params.readableSpotMarketIndexes) {
+            addSpotMarketToRemainingAccountMaps(ctx, readableSpotMarketIndex, false, oracleAccountMap, spotMarketAccountMap);
+        }
+    }
+    for (const spotMarketIndex of ctx.mustIncludeSpotMarketIndexes.values()) {
+        addSpotMarketToRemainingAccountMaps(ctx, spotMarketIndex, false, oracleAccountMap, spotMarketAccountMap);
+    }
+    if (params.writablePerpMarketIndexes !== undefined) {
+        for (const writablePerpMarketIndex of params.writablePerpMarketIndexes) {
+            addPerpMarketToRemainingAccountMaps(ctx, writablePerpMarketIndex, true, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
+        }
+    }
+    if (params.writableSpotMarketIndexes !== undefined) {
+        for (const writableSpotMarketIndex of params.writableSpotMarketIndexes) {
+            addSpotMarketToRemainingAccountMaps(ctx, writableSpotMarketIndex, true, oracleAccountMap, spotMarketAccountMap);
+        }
+    }
+    return [
+        ...oracleAccountMap.values(),
+        ...spotMarketAccountMap.values(),
+        ...perpMarketAccountMap.values(),
+    ];
+}
+exports.getRemainingAccounts = getRemainingAccounts;
+function addPerpMarketToRemainingAccountMaps(ctx, marketIndex, writable, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap) {
+    const perpMarketAccount = ctx.getPerpMarketAccount(marketIndex);
+    perpMarketAccountMap.set(marketIndex, {
+        pubkey: perpMarketAccount.pubkey,
+        isSigner: false,
+        isWritable: writable,
+    });
+    const oracleWritable = writable && (0, types_1.isVariant)(perpMarketAccount.amm.oracleSource, 'prelaunch');
+    oracleAccountMap.set(perpMarketAccount.amm.oracle.toString(), {
+        pubkey: perpMarketAccount.amm.oracle,
+        isSigner: false,
+        isWritable: oracleWritable,
+    });
+    addSpotMarketToRemainingAccountMaps(ctx, perpMarketAccount.quoteSpotMarketIndex, false, oracleAccountMap, spotMarketAccountMap);
+}
+function addSpotMarketToRemainingAccountMaps(ctx, marketIndex, writable, oracleAccountMap, spotMarketAccountMap) {
+    const spotMarketAccount = ctx.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,
+        });
+    }
+}
+function getRemainingAccountMapsForUsers(ctx, userAccounts) {
+    const oracleAccountMap = new Map();
+    const spotMarketAccountMap = new Map();
+    const perpMarketAccountMap = new Map();
+    for (const userAccount of userAccounts) {
+        for (const spotPosition of userAccount.spotPositions) {
+            if (!(0, spotPosition_1.isSpotPositionAvailable)(spotPosition)) {
+                addSpotMarketToRemainingAccountMaps(ctx, spotPosition.marketIndex, false, oracleAccountMap, spotMarketAccountMap);
+                if (!spotPosition.openAsks.eq(numericConstants_1.ZERO) ||
+                    !spotPosition.openBids.eq(numericConstants_1.ZERO)) {
+                    addSpotMarketToRemainingAccountMaps(ctx, numericConstants_1.QUOTE_SPOT_MARKET_INDEX, false, oracleAccountMap, spotMarketAccountMap);
+                }
+            }
+        }
+        for (const position of userAccount.perpPositions) {
+            if (!(0, position_1.positionIsAvailable)(position)) {
+                addPerpMarketToRemainingAccountMaps(ctx, position.marketIndex, false, oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap);
+            }
+        }
+    }
+    return { oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap };
+}

package/lib/browser/core/signedMsg.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { SignedMsgOrderParamsDelegateMessage, SignedMsgOrderParamsMessage } from '../types';
+export type AnchorTypesCoder = {
+    encode: (typeName: string, value: any) => Buffer;
+    decode: (typeName: string, buffer: Buffer) => any;
+};
+export declare function encodeSignedMsgOrderParamsMessage(args: {
+    coderTypes: AnchorTypesCoder;
+    orderParamsMessage: SignedMsgOrderParamsMessage | SignedMsgOrderParamsDelegateMessage;
+    delegateSigner?: boolean;
+}): Buffer;
+export declare function decodeSignedMsgOrderParamsMessage(args: {
+    coderTypes: AnchorTypesCoder;
+    encodedMessage: Buffer;
+    delegateSigner?: boolean;
+}): SignedMsgOrderParamsMessage | SignedMsgOrderParamsDelegateMessage;