@drift-labs/common 1.0.0 → 1.0.2

package/lib/drift/base/actions/trade/openPerpOrder/openPerpMarketOrder/index.d.ts

@@ -1,45 +1,50 @@
-import { DriftClient, User, BN, PositionDirection, MarketType } from '@drift-labs/sdk';
+import { DriftClient, User, BN, PositionDirection, ReferrerInfo } from '@drift-labs/sdk';
 import { Transaction, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
-import { OptionalTriggerOrderParams, SwiftOrderOptions, SwiftOrderResult } from '../openSwiftOrder';
-export interface AuctionParamsRequestOptions {
-    maxLeverageSelected?: boolean;
-    maxLeverageOrderSize?: BN;
-    reduceOnly?: boolean;
-    auctionDuration?: number;
-    auctionStartPriceOffset?: number;
-    auctionEndPriceOffset?: number;
-    auctionStartPriceOffsetFrom?: string;
-    auctionEndPriceOffsetFrom?: string;
-    slippageTolerance?: number | 'dynamic';
-    auctionPriceCaps?: {
-        min: BN;
-        max: BN;
-    };
-    isOracleOrder?: boolean;
-    additionalEndPriceBuffer?: BN;
-    forceUpToSlippage?: boolean;
-    orderType?: 'market' | 'oracle';
-}
-export type OpenPerpMarketOrderParams<T extends boolean = boolean> = {
+import { SwiftOrderOptions } from '../openSwiftOrder';
+import { OptionalAuctionParamsRequestInputs } from '../dlobServer';
+import { TxnOrSwiftResult, WithTxnParams } from '../types';
+import { PlaceAndTakeParams, OptionalTriggerOrderParams } from '../types';
+export interface OpenPerpMarketOrderBaseParams {
     driftClient: DriftClient;
     user: User;
     assetType: 'base' | 'quote';
     marketIndex: number;
     direction: PositionDirection;
     amount: BN;
-    auctionParamsOptions?: AuctionParamsRequestOptions;
     dlobServerHttpUrl: string;
+    userOrderId?: number;
+    placeAndTake?: PlaceAndTakeParams;
+    optionalAuctionParamsInputs?: OptionalAuctionParamsRequestInputs;
     bracketOrders?: {
         takeProfit?: OptionalTriggerOrderParams;
         stopLoss?: OptionalTriggerOrderParams;
     };
-    marketType?: MarketType;
-    useSwift: T;
-} & (T extends true ? {
+}
+export interface OpenPerpMarketOrderBaseParamsWithSwift extends Omit<OpenPerpMarketOrderBaseParams, 'placeAndTake'> {
     swiftOptions: SwiftOrderOptions;
-} : {
-    swiftOptions?: never;
-});
+}
+export interface OpenPerpMarketOrderParams<T extends boolean = boolean> extends OpenPerpMarketOrderBaseParams {
+    useSwift: T;
+    swiftOptions?: T extends true ? SwiftOrderOptions : never;
+    placeAndTake?: T extends true ? never : PlaceAndTakeParams;
+}
+/**
+ * Creates and submits a Swift (signed message) order. Only available for perp orders.
+ */
+export declare function createSwiftMarketOrder({ driftClient, user, assetType, marketIndex, direction, amount, bracketOrders, dlobServerHttpUrl, optionalAuctionParamsInputs, swiftOptions, userOrderId, }: OpenPerpMarketOrderBaseParamsWithSwift): Promise<void>;
+/**
+ * Creates a placeAndTake transaction instruction.
+ * Fallbacks to a regular market order if no top makers are found.
+ */
+export declare const createPlaceAndTakePerpMarketOrderIx: ({ assetType, direction, dlobServerHttpUrl, marketIndex, driftClient, user, userOrderId, amount, referrerInfo, auctionDurationPercentage, optionalAuctionParamsInputs, }: OpenPerpMarketOrderBaseParams & {
+    direction: PositionDirection;
+    dlobServerHttpUrl: string;
+    marketIndex: number;
+    driftClient: DriftClient;
+    user: User;
+    referrerInfo?: ReferrerInfo;
+    auctionDurationPercentage?: number;
+}) => Promise<TransactionInstruction>;
 /**
  * Creates transaction instructions for opening a perp market order.
  * If swiftOptions is provided, it will create a Swift (signed message) order instead.
@@ -51,13 +56,11 @@ export type OpenPerpMarketOrderParams<T extends boolean = boolean> = {
  * @param direction - The direction of the trade (long/short)
  * @param amount - The amount to trade
  * @param dlobServerHttpUrl - Server URL for the auction params endpoint
- * @param auctionParamsOptions - Optional parameters for auction params endpoint and order configuration
- * @param useSwift - Whether to use Swift (signed message) orders instead of regular transactions
- * @param swiftOptions - Options for Swift (signed message) orders. Required if useSwift is true
+ * @param optionalAuctionParamsInputs - Optional parameters for auction params endpoint and order configuration
  *
- * @returns Promise resolving to an array of transaction instructions for regular orders, or empty array for Swift orders
+ * @returns Promise resolving to an array of transaction instructions for regular orders
  */
-export declare const createOpenPerpMarketOrderIx: ({ driftClient, user, assetType, marketIndex, direction, amount, dlobServerHttpUrl, auctionParamsOptions, useSwift, swiftOptions, }: OpenPerpMarketOrderParams) => Promise<TransactionInstruction[]>;
+export declare const createOpenPerpMarketOrderIxs: ({ driftClient, user, assetType, marketIndex, direction, amount, bracketOrders, dlobServerHttpUrl, placeAndTake, userOrderId, optionalAuctionParamsInputs, }: OpenPerpMarketOrderBaseParams) => Promise<TransactionInstruction[]>;
 /**
  * Creates a complete transaction for opening a perp market order.
  *
@@ -66,19 +69,26 @@ export declare const createOpenPerpMarketOrderIx: ({ driftClient, user, assetTyp
  * @param marketIndex - The perp market index to trade
  * @param direction - The direction of the trade (long/short)
  * @param amount - The amount to trade
- * @param auctionParamsOptions - Optional parameters for auction params endpoint and order configuration
+ * @param optionalAuctionParamsInputs - Optional parameters for auction params endpoint and order configuration
  * @param dlobServerHttpUrl - Server URL for the auction params endpoint
  *
  * @returns Promise resolving to a built transaction ready for signing (Transaction or VersionedTransaction)
  */
-export declare const createOpenPerpMarketOrderTxn: <T extends boolean>({ driftClient, user, assetType, marketIndex, direction, amount, dlobServerHttpUrl, auctionParamsOptions, bracketOrders, useSwift, swiftOptions, }: OpenPerpMarketOrderParams<T>) => Promise<T extends true ? SwiftOrderResult : Transaction | VersionedTransaction>;
+export declare const createOpenPerpMarketOrderTxn: (params: WithTxnParams<OpenPerpMarketOrderBaseParams>) => Promise<Transaction | VersionedTransaction>;
 /**
- * Creates a Swift (signed message) order directly.
- * This is a convenience function for when you only want to create Swift orders.
+ * Creates a transaction or swift order for a perp market order.
+ *
+ * @param driftClient - The Drift client instance for interacting with the protocol
+ * @param user - The user account that will place the order
+ * @param marketIndex - The perp market index to trade
+ * @param direction - The direction of the trade (long/short)
+ * @param amount - The amount to trade
+ * @param optionalAuctionParamsInputs - Optional parameters for auction params endpoint and order configuration
+ * @param dlobServerHttpUrl - Server URL for the auction params endpoint
+ * @param useSwift - Whether to use Swift (signed message) orders instead of regular transactions
+ * @param swiftOptions - Options for Swift (signed message) orders. Required if useSwift is true
+ * @param userOrderId - The user order id for UI identification
  *
- * @param params - All the parameters needed for creating a Swift order
- * @returns Promise resolving to SwiftOrderResult with observable and order UUID
+ * @returns Promise resolving to a built transaction ready for signing (Transaction or VersionedTransaction)
  */
-export declare const createSwiftPerpMarketOrder: (params: Omit<OpenPerpMarketOrderParams, 'useSwift'> & {
-    swiftOptions: SwiftOrderOptions;
-}) => Promise<SwiftOrderResult>;
+export declare const createOpenPerpMarketOrder: <T extends boolean>(params: WithTxnParams<OpenPerpMarketOrderParams<T>>) => Promise<TxnOrSwiftResult<T>>;

package/lib/drift/base/actions/trade/openPerpOrder/openPerpMarketOrder/index.js

@@ -1,85 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSwiftPerpMarketOrder = exports.createOpenPerpMarketOrderTxn = exports.createOpenPerpMarketOrderIx = void 0;
+exports.createOpenPerpMarketOrder = exports.createOpenPerpMarketOrderTxn = exports.createOpenPerpMarketOrderIxs = exports.createPlaceAndTakePerpMarketOrderIx = exports.createSwiftMarketOrder = void 0;
 const sdk_1 = require("@drift-labs/sdk");
 const utils_1 = require("../../../../../../utils");
-const auctionParamsResponseMapper_1 = require("../../../../../utils/auctionParamsResponseMapper");
 const openSwiftOrder_1 = require("../openSwiftOrder");
-const types_1 = require("../../../../../../types");
-const swiftClient_1 = require("../../../../../../clients/swiftClient");
 const orderParams_1 = require("../../../../../utils/orderParams");
-/**
- * Fetches order parameters from the auction params server
- */
-async function fetchOrderParamsFromServer({ assetType, marketIndex, marketType = sdk_1.MarketType.PERP, direction, amount, dlobServerHttpUrl, auctionParamsOptions = {}, }) {
-    var _a;
-    // Extract optional parameters (no defaults except for what's required by server)
-    const { maxLeverageSelected, maxLeverageOrderSize, reduceOnly, auctionDuration, auctionStartPriceOffset, auctionEndPriceOffset, auctionStartPriceOffsetFrom, auctionEndPriceOffsetFrom, slippageTolerance, isOracleOrder, orderType, ...restOptions } = auctionParamsOptions;
-    // Build URL parameters for server request
-    const urlParamsObject = {
-        // Required fields
-        assetType,
-        marketType: utils_1.ENUM_UTILS.toStr(marketType),
-        marketIndex: marketIndex.toString(),
-        direction: utils_1.ENUM_UTILS.toStr(direction),
-        amount: amount.toString(),
-    };
-    // Add optional parameters only if they are provided
-    const optionalParams = {
-        maxLeverageSelected,
-        maxLeverageOrderSize,
-        reduceOnly,
-        auctionDuration,
-        auctionStartPriceOffset,
-        auctionEndPriceOffset,
-        auctionStartPriceOffsetFrom,
-        auctionEndPriceOffsetFrom,
-        slippageTolerance,
-        isOracleOrder,
-        orderType,
-        additionalEndPriceBuffer: restOptions.additionalEndPriceBuffer,
-        forceUpToSlippage: restOptions.forceUpToSlippage,
-    };
-    // Add defined optional parameters
-    Object.entries(optionalParams).forEach(([key, value]) => {
-        if (value !== undefined) {
-            urlParamsObject[key] = value.toString();
-        }
-    });
-    const urlParams = new URLSearchParams(urlParamsObject);
-    // Get order params from server
-    const requestUrl = `${dlobServerHttpUrl}/auctionParams?${urlParams.toString()}`;
-    const response = await fetch(requestUrl);
-    if (!response.ok) {
-        throw new Error(`Server responded with ${response.status}: ${response.statusText}`);
-    }
-    const serverResponse = await response.json();
-    const mappedParams = (0, auctionParamsResponseMapper_1.mapAuctionParamsResponse)(serverResponse);
-    // Convert MappedAuctionParams to OptionalOrderParams
-    return {
-        orderType: mappedParams.orderType,
-        marketType: mappedParams.marketType,
-        userOrderId: mappedParams.userOrderId,
-        direction: mappedParams.direction,
-        baseAssetAmount: mappedParams.baseAssetAmount,
-        marketIndex: mappedParams.marketIndex,
-        reduceOnly: mappedParams.reduceOnly,
-        postOnly: mappedParams.postOnly,
-        triggerPrice: mappedParams.triggerPrice,
-        triggerCondition: mappedParams.triggerCondition,
-        oraclePriceOffset: ((_a = mappedParams.oraclePriceOffset) === null || _a === void 0 ? void 0 : _a.toNumber()) || null,
-        auctionDuration: mappedParams.auctionDuration,
-        maxTs: mappedParams.maxTs,
-        auctionStartPrice: mappedParams.auctionStartPrice,
-        auctionEndPrice: mappedParams.auctionEndPrice,
-    };
-}
+const dlobServer_1 = require("../dlobServer");
+const order_1 = require("../../../../../../common-ui-utils/order");
+const errors_1 = require("../../../../../Drift/constants/errors");
 /**
  * Creates and submits a Swift (signed message) order. Only available for perp orders.
  */
-async function createSwiftOrder({ driftClient, user, assetType, marketIndex, direction, amount, bracketOrders, dlobServerHttpUrl, auctionParamsOptions, swiftOptions, }) {
+async function createSwiftMarketOrder({ driftClient, user, assetType, marketIndex, direction, amount, bracketOrders, dlobServerHttpUrl, optionalAuctionParamsInputs, swiftOptions, userOrderId = 0, }) {
+    if (amount.isZero()) {
+        throw new Error('Amount must be greater than zero');
+    }
     // Get order parameters from server
-    const orderParams = await fetchOrderParamsFromServer({
+    const fetchedOrderParams = await (0, dlobServer_1.fetchAuctionOrderParams)({
         driftClient,
         user,
         assetType,
@@ -88,166 +25,163 @@ async function createSwiftOrder({ driftClient, user, assetType, marketIndex, dir
         direction,
         amount,
         dlobServerHttpUrl,
-        auctionParamsOptions,
+        optionalAuctionParamsInputs,
     });
-    // Fetch current slot programmatically
-    const currentSlot = await driftClient.connection.getSlot();
+    const oraclePrice = driftClient.getOracleDataForPerpMarket(marketIndex).price;
+    const totalQuoteAmount = amount.mul(oraclePrice).div(sdk_1.PRICE_PRECISION);
+    const bitFlags = order_1.ORDER_COMMON_UTILS.getPerpOrderParamsBitFlags(marketIndex, driftClient, user, totalQuoteAmount, direction);
+    const orderParams = {
+        ...fetchedOrderParams,
+        userOrderId,
+        bitFlags,
+    };
     const userAccount = user.getUserAccount();
-    // Use the existing prepSwiftOrder helper function
-    const { hexEncodedSwiftOrderMessage, signedMsgOrderUuid } = (0, openSwiftOrder_1.prepSwiftOrder)({
+    const slotBuffer = swiftOptions.signedMessageOrderSlotBuffer || 7;
+    await (0, openSwiftOrder_1.prepSignAndSendSwiftOrder)({
         driftClient,
-        takerUserAccount: {
-            pubKey: swiftOptions.wallet.publicKey,
-            subAccountId: userAccount.subAccountId,
-        },
-        currentSlot,
-        isDelegate: swiftOptions.isDelegate || false,
+        subAccountId: userAccount.subAccountId,
+        marketIndex,
+        slotBuffer,
+        swiftOptions,
         orderParams: {
             main: orderParams,
             takeProfit: bracketOrders === null || bracketOrders === void 0 ? void 0 : bracketOrders.takeProfit,
             stopLoss: bracketOrders === null || bracketOrders === void 0 ? void 0 : bracketOrders.stopLoss,
         },
-        slotBuffer: swiftOptions.signedMessageOrderSlotBuffer || 30,
     });
-    // Sign the message
-    const signedMessage = await swiftOptions.wallet.signMessage(hexEncodedSwiftOrderMessage.uInt8Array);
-    // Initialize SwiftClient (required before using sendSwiftOrder)
-    swiftClient_1.SwiftClient.init(swiftOptions.swiftServerUrl);
-    const swiftOrderResult = (0, openSwiftOrder_1.sendSwiftOrder)({
-        driftClient,
-        marketId: types_1.MarketId.createPerpMarket(marketIndex),
-        hexEncodedSwiftOrderMessageString: hexEncodedSwiftOrderMessage.string,
-        signedMessage,
-        signedMsgOrderUuid,
-        takerAuthority: swiftOptions.wallet.publicKey,
-        signingAuthority: swiftOptions.wallet.publicKey,
-        auctionDurationSlot: orderParams.auctionDuration || undefined,
-        swiftConfirmationSlotBuffer: 15,
-    });
-    return swiftOrderResult;
 }
+exports.createSwiftMarketOrder = createSwiftMarketOrder;
 /**
- * Creates transaction instructions for opening a perp market order.
- * If swiftOptions is provided, it will create a Swift (signed message) order instead.
- *
- * @param driftClient - The Drift client instance for interacting with the protocol
- * @param user - The user account that will place the order
- * @param assetType - Whether the amount is in base or quote units
- * @param marketIndex - The perp market index to trade
- * @param direction - The direction of the trade (long/short)
- * @param amount - The amount to trade
- * @param dlobServerHttpUrl - Server URL for the auction params endpoint
- * @param auctionParamsOptions - Optional parameters for auction params endpoint and order configuration
- * @param useSwift - Whether to use Swift (signed message) orders instead of regular transactions
- * @param swiftOptions - Options for Swift (signed message) orders. Required if useSwift is true
- *
- * @returns Promise resolving to an array of transaction instructions for regular orders, or empty array for Swift orders
+ * Creates a placeAndTake transaction instruction.
+ * Fallbacks to a regular market order if no top makers are found.
  */
-const createOpenPerpMarketOrderIx = async ({ driftClient, user, assetType, marketIndex, direction, amount, dlobServerHttpUrl, auctionParamsOptions = {}, useSwift = false, swiftOptions, }) => {
-    if (!amount || amount.isZero()) {
-        throw new Error('Amount must be greater than zero');
-    }
-    // First, get order parameters from server (same for both Swift and regular orders)
-    const orderParams = await fetchOrderParamsFromServer({
-        driftClient,
-        user,
-        assetType,
-        marketIndex,
-        marketType: sdk_1.MarketType.PERP,
-        direction,
-        amount,
-        dlobServerHttpUrl,
-        auctionParamsOptions,
-    });
-    // If useSwift is true, use prepSwiftOrder and return empty array
-    if (useSwift) {
-        if (!swiftOptions) {
-            throw new Error('swiftOptions is required when useSwift is true');
-        }
-        const currentSlot = await driftClient.connection.getSlot();
-        const userAccount = user.getUserAccount();
-        // Use the existing prepSwiftOrder helper function
-        (0, openSwiftOrder_1.prepSwiftOrder)({
+const createPlaceAndTakePerpMarketOrderIx = async ({ assetType, direction, dlobServerHttpUrl, marketIndex, driftClient, user, userOrderId, amount, referrerInfo, auctionDurationPercentage, optionalAuctionParamsInputs, }) => {
+    const counterPartySide = utils_1.ENUM_UTILS.match(direction, sdk_1.PositionDirection.LONG)
+        ? 'ask'
+        : 'bid';
+    const [fetchedOrderParams, topMakersResult] = await Promise.all([
+        (0, dlobServer_1.fetchAuctionOrderParams)({
             driftClient,
-            takerUserAccount: {
-                pubKey: swiftOptions.wallet.publicKey,
-                subAccountId: userAccount.subAccountId,
-            },
-            currentSlot,
-            isDelegate: swiftOptions.isDelegate || false,
-            orderParams: {
-                main: orderParams,
-                // TODO: Add support for stopLoss and takeProfit
-            },
-            slotBuffer: swiftOptions.signedMessageOrderSlotBuffer || 30,
-        });
-        // Swift orders don't return transaction instructions
-        return [];
+            user,
+            assetType,
+            marketIndex,
+            marketType: sdk_1.MarketType.PERP,
+            direction,
+            amount,
+            dlobServerHttpUrl,
+            optionalAuctionParamsInputs,
+        }),
+        (0, dlobServer_1.fetchTopMakers)({
+            dlobServerHttpUrl,
+            marketIndex,
+            marketType: sdk_1.MarketType.PERP,
+            side: counterPartySide,
+            limit: 4,
+        }),
+    ]);
+    const oraclePrice = driftClient.getOracleDataForPerpMarket(marketIndex).price;
+    const totalQuoteAmount = amount.mul(oraclePrice).div(sdk_1.PRICE_PRECISION);
+    const bitFlags = order_1.ORDER_COMMON_UTILS.getPerpOrderParamsBitFlags(marketIndex, driftClient, user, totalQuoteAmount, direction);
+    fetchedOrderParams.bitFlags = bitFlags;
+    fetchedOrderParams.userOrderId = userOrderId;
+    if (!topMakersResult || topMakersResult.length === 0) {
+        throw new errors_1.NoTopMakersError('No top makers found', fetchedOrderParams);
     }
-    // Regular order flow - create transaction instruction
-    const placeOrderIx = await driftClient.getPlaceOrdersIx([orderParams]);
-    return [placeOrderIx];
+    const topMakersInfo = topMakersResult.map((maker) => ({
+        maker: maker.userAccountPubKey,
+        makerUserAccount: maker.userAccount,
+        makerStats: (0, sdk_1.getUserStatsAccountPublicKey)(driftClient.program.programId, maker.userAccount.authority),
+    }));
+    const placeAndTakeIx = await driftClient.getPlaceAndTakePerpOrderIx(fetchedOrderParams, topMakersInfo, referrerInfo, undefined, auctionDurationPercentage, user.getUserAccount().subAccountId);
+    return placeAndTakeIx;
 };
-exports.createOpenPerpMarketOrderIx = createOpenPerpMarketOrderIx;
+exports.createPlaceAndTakePerpMarketOrderIx = createPlaceAndTakePerpMarketOrderIx;
 /**
- * Creates a complete transaction for opening a perp market order.
+ * Creates transaction instructions for opening a perp market order.
+ * If swiftOptions is provided, it will create a Swift (signed message) order instead.
  *
  * @param driftClient - The Drift client instance for interacting with the protocol
  * @param user - The user account that will place the order
+ * @param assetType - Whether the amount is in base or quote units
  * @param marketIndex - The perp market index to trade
  * @param direction - The direction of the trade (long/short)
  * @param amount - The amount to trade
- * @param auctionParamsOptions - Optional parameters for auction params endpoint and order configuration
  * @param dlobServerHttpUrl - Server URL for the auction params endpoint
+ * @param optionalAuctionParamsInputs - Optional parameters for auction params endpoint and order configuration
  *
- * @returns Promise resolving to a built transaction ready for signing (Transaction or VersionedTransaction)
+ * @returns Promise resolving to an array of transaction instructions for regular orders
  */
-const createOpenPerpMarketOrderTxn = async ({ driftClient, user, assetType, marketIndex, direction, amount, dlobServerHttpUrl, auctionParamsOptions, bracketOrders, useSwift, swiftOptions, }) => {
+const createOpenPerpMarketOrderIxs = async ({ driftClient, user, assetType, marketIndex, direction, amount, bracketOrders, dlobServerHttpUrl, placeAndTake, userOrderId, optionalAuctionParamsInputs = {}, }) => {
+    var _a, _b, _c, _d;
     if (!amount || amount.isZero()) {
         throw new Error('Amount must be greater than zero');
     }
-    // First, get order parameters from server (same for both Swift and regular orders)
-    const orderParams = await fetchOrderParamsFromServer({
-        driftClient,
-        user,
-        assetType,
-        marketIndex,
-        marketType: sdk_1.MarketType.PERP,
-        direction,
-        amount,
-        dlobServerHttpUrl,
-        auctionParamsOptions,
-    });
-    // If useSwift is true, return the Swift result directly
-    if (useSwift) {
-        if (!swiftOptions) {
-            throw new Error('swiftOptions is required when useSwift is true');
+    const allOrders = [];
+    const allIxs = [];
+    if (placeAndTake === null || placeAndTake === void 0 ? void 0 : placeAndTake.enable) {
+        try {
+            const placeAndTakeIx = await (0, exports.createPlaceAndTakePerpMarketOrderIx)({
+                assetType,
+                amount,
+                direction,
+                dlobServerHttpUrl,
+                marketIndex,
+                driftClient,
+                user,
+                userOrderId,
+                referrerInfo: placeAndTake.referrerInfo,
+                auctionDurationPercentage: placeAndTake.auctionDurationPercentage,
+                optionalAuctionParamsInputs,
+            });
+            allIxs.push(placeAndTakeIx);
         }
-        return (await createSwiftOrder({
+        catch (e) {
+            if (e instanceof errors_1.NoTopMakersError) {
+                // fallback to regular order
+                allOrders.push(e.orderParams);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    else {
+        const fetchedOrderParams = await (0, dlobServer_1.fetchAuctionOrderParams)({
             driftClient,
             user,
             assetType,
             marketIndex,
+            marketType: sdk_1.MarketType.PERP,
             direction,
             amount,
             dlobServerHttpUrl,
-            bracketOrders,
-            auctionParamsOptions,
-            swiftOptions,
-        }));
+            optionalAuctionParamsInputs,
+        });
+        const oraclePrice = driftClient.getOracleDataForPerpMarket(marketIndex).price;
+        const totalQuoteAmount = amount.mul(oraclePrice).div(sdk_1.PRICE_PRECISION);
+        const bitFlags = order_1.ORDER_COMMON_UTILS.getPerpOrderParamsBitFlags(marketIndex, driftClient, user, totalQuoteAmount, direction);
+        const orderParams = {
+            ...fetchedOrderParams,
+            userOrderId,
+            bitFlags,
+        };
+        allOrders.push(orderParams);
     }
-    const allOrders = [orderParams];
+    const bracketOrdersDirection = utils_1.ENUM_UTILS.match(direction, sdk_1.PositionDirection.LONG)
+        ? sdk_1.PositionDirection.SHORT
+        : sdk_1.PositionDirection.LONG;
     if (bracketOrders === null || bracketOrders === void 0 ? void 0 : bracketOrders.takeProfit) {
         const takeProfitParams = (0, orderParams_1.buildNonMarketOrderParams)({
             marketIndex,
             marketType: sdk_1.MarketType.PERP,
-            direction: bracketOrders.takeProfit.direction,
-            baseAssetAmount: amount,
+            direction: bracketOrdersDirection,
+            baseAssetAmount: (_a = bracketOrders.takeProfit.baseAssetAmount) !== null && _a !== void 0 ? _a : amount,
             orderConfig: {
                 orderType: 'takeProfit',
                 triggerPrice: bracketOrders.takeProfit.triggerPrice,
+                limitPrice: bracketOrders.takeProfit.limitPrice,
             },
-            reduceOnly: true,
+            reduceOnly: (_b = bracketOrders.takeProfit.reduceOnly) !== null && _b !== void 0 ? _b : true,
         });
         allOrders.push(takeProfitParams);
     }
@@ -255,39 +189,84 @@ const createOpenPerpMarketOrderTxn = async ({ driftClient, user, assetType, mark
         const stopLossParams = (0, orderParams_1.buildNonMarketOrderParams)({
             marketIndex,
             marketType: sdk_1.MarketType.PERP,
-            direction: bracketOrders.stopLoss.direction,
-            baseAssetAmount: amount,
+            direction: bracketOrdersDirection,
+            baseAssetAmount: (_c = bracketOrders.stopLoss.baseAssetAmount) !== null && _c !== void 0 ? _c : amount,
             orderConfig: {
                 orderType: 'stopLoss',
                 triggerPrice: bracketOrders.stopLoss.triggerPrice,
+                limitPrice: bracketOrders.stopLoss.limitPrice,
             },
-            reduceOnly: true,
+            reduceOnly: (_d = bracketOrders.stopLoss.reduceOnly) !== null && _d !== void 0 ? _d : true,
         });
         allOrders.push(stopLossParams);
     }
+    // Regular order flow - create transaction instruction
+    if (allOrders.length > 0) {
+        const placeOrderIx = await driftClient.getPlaceOrdersIx(allOrders);
+        allIxs.push(placeOrderIx);
+    }
+    return allIxs;
+};
+exports.createOpenPerpMarketOrderIxs = createOpenPerpMarketOrderIxs;
+/**
+ * Creates a complete transaction for opening a perp market order.
+ *
+ * @param driftClient - The Drift client instance for interacting with the protocol
+ * @param user - The user account that will place the order
+ * @param marketIndex - The perp market index to trade
+ * @param direction - The direction of the trade (long/short)
+ * @param amount - The amount to trade
+ * @param optionalAuctionParamsInputs - Optional parameters for auction params endpoint and order configuration
+ * @param dlobServerHttpUrl - Server URL for the auction params endpoint
+ *
+ * @returns Promise resolving to a built transaction ready for signing (Transaction or VersionedTransaction)
+ */
+const createOpenPerpMarketOrderTxn = async (params) => {
+    const { driftClient } = params;
     // Regular order flow - create transaction instruction and build transaction
-    const placeOrderIx = await driftClient.getPlaceOrdersIx(allOrders);
+    const placeOrderIx = await (0, exports.createOpenPerpMarketOrderIxs)(params);
     const openPerpMarketOrderTxn = await driftClient.txHandler.buildTransaction({
-        instructions: [placeOrderIx],
+        instructions: placeOrderIx,
         txVersion: 0,
         connection: driftClient.connection,
         preFlightCommitment: 'confirmed',
         fetchAllMarketLookupTableAccounts: driftClient.fetchAllLookupTableAccounts.bind(driftClient),
+        txParams: params.txParams,
     });
     return openPerpMarketOrderTxn;
 };
 exports.createOpenPerpMarketOrderTxn = createOpenPerpMarketOrderTxn;
 /**
- * Creates a Swift (signed message) order directly.
- * This is a convenience function for when you only want to create Swift orders.
+ * Creates a transaction or swift order for a perp market order.
  *
- * @param params - All the parameters needed for creating a Swift order
- * @returns Promise resolving to SwiftOrderResult with observable and order UUID
+ * @param driftClient - The Drift client instance for interacting with the protocol
+ * @param user - The user account that will place the order
+ * @param marketIndex - The perp market index to trade
+ * @param direction - The direction of the trade (long/short)
+ * @param amount - The amount to trade
+ * @param optionalAuctionParamsInputs - Optional parameters for auction params endpoint and order configuration
+ * @param dlobServerHttpUrl - Server URL for the auction params endpoint
+ * @param useSwift - Whether to use Swift (signed message) orders instead of regular transactions
+ * @param swiftOptions - Options for Swift (signed message) orders. Required if useSwift is true
+ * @param userOrderId - The user order id for UI identification
+ *
+ * @returns Promise resolving to a built transaction ready for signing (Transaction or VersionedTransaction)
  */
-const createSwiftPerpMarketOrder = async (params) => {
-    return await createSwiftOrder({
-        ...params,
-    });
+const createOpenPerpMarketOrder = async (params) => {
+    const { useSwift, swiftOptions, ...rest } = params;
+    // If useSwift is true, return the Swift result directly
+    if (useSwift) {
+        if (!swiftOptions) {
+            throw new Error('swiftOptions is required when useSwift is true');
+        }
+        const swiftOrderResult = await createSwiftMarketOrder({
+            ...rest,
+            swiftOptions,
+        });
+        return swiftOrderResult;
+    }
+    const openPerpMarketOrderTxn = await (0, exports.createOpenPerpMarketOrderTxn)(rest);
+    return openPerpMarketOrderTxn;
 };
-exports.createSwiftPerpMarketOrder = createSwiftPerpMarketOrder;
+exports.createOpenPerpMarketOrder = createOpenPerpMarketOrder;
 //# sourceMappingURL=index.js.map