@drift-labs/sdk 2.107.0-beta.0 → 2.107.0-beta.2

package/VERSION

@@ -1 +1 @@
-2.107.0-beta.0
+2.107.0-beta.2

package/lib/browser/constants/perpMarkets.js

@@ -1004,6 +1004,17 @@ exports.MainnetPerpMarkets = [
         oracleSource: __1.OracleSource.PYTH_PULL,
         pythFeedId: '0xbed3097008b9b5e3c93bec20be79cb43986b85a996475589351a21e67bae9b61',
     },
+    {
+        fullName: 'AI16Z',
+        category: ['AI'],
+        symbol: 'AI16Z-PERP',
+        baseAssetSymbol: 'AI16Z',
+        marketIndex: 63,
+        oracle: new web3_js_1.PublicKey('3gdGkrmBdYR7B1MRRdRVysqhZCvYvLGHonr9b7o9WVki'),
+        launchTs: 1736384970000,
+        oracleSource: __1.OracleSource.PYTH_PULL,
+        pythFeedId: '0x2551eca7784671173def2c41e6f3e51e11cd87494863f1d208fdd8c64a1f85ae',
+    },
 ];
 exports.PerpMarkets = {
     devnet: exports.DevnetPerpMarkets,

package/lib/browser/constants/spotMarkets.js

@@ -513,6 +513,18 @@ exports.MainnetSpotMarkets = [
         pythFeedId: '0xeaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a',
         launchTs: 1735255852000,
     },
+    {
+        symbol: 'AI16Z',
+        marketIndex: 35,
+        poolId: 0,
+        oracle: new web3_js_1.PublicKey('3gdGkrmBdYR7B1MRRdRVysqhZCvYvLGHonr9b7o9WVki'),
+        oracleSource: __1.OracleSource.PYTH_PULL,
+        mint: new web3_js_1.PublicKey('HeLp6NuQkmYB4pYWo2zYs22mESHXPQYzXbB8n4V98jwC'),
+        precision: new __1.BN(10).pow(numericConstants_1.NINE),
+        precisionExp: numericConstants_1.NINE,
+        pythFeedId: '0x2551eca7784671173def2c41e6f3e51e11cd87494863f1d208fdd8c64a1f85ae',
+        launchTs: 1736384970000,
+    },
 ];
 exports.SpotMarkets = {
     devnet: exports.DevnetSpotMarkets,

package/lib/browser/driftClient.d.ts

@@ -24,6 +24,7 @@ import { TxHandler } from './tx/txHandler';
 import { WormholeCoreBridgeSolana } from '@pythnetwork/pyth-solana-receiver/lib/idl/wormhole_core_bridge_solana';
 import { PythSolanaReceiver } from '@pythnetwork/pyth-solana-receiver/lib/idl/pyth_solana_receiver';
 import { Slothash } from './slot/SlothashSubscriber';
+import { SignedSwiftOrderParams } from './swift/types';
 type RemainingAccountParams = {
     userAccounts: UserAccount[];
     writablePerpMarketIndexes?: number[];
@@ -532,26 +533,26 @@ export declare class DriftClient {
     getPlaceAndTakePerpOrderIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, successCondition?: PlaceAndTakeOrderSuccessCondition, auctionDurationPercentage?: number, subAccountId?: number): Promise<TransactionInstruction>;
     placeAndMakePerpOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     getPlaceAndMakePerpOrderIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo, subAccountId?: number): Promise<TransactionInstruction>;
-    signSwiftOrderParamsMessage(orderParamsMessage: SwiftOrderParamsMessage): Buffer;
+    signSwiftOrderParamsMessage(orderParamsMessage: SwiftOrderParamsMessage): SignedSwiftOrderParams;
     encodeSwiftOrderParamsMessage(orderParamsMessage: SwiftOrderParamsMessage): Buffer;
     decodeSwiftOrderParamsMessage(encodedMessage: Buffer): SwiftOrderParamsMessage;
     signMessage(message: Uint8Array, keypair?: Keypair): Buffer;
-    placeSwiftTakerOrder(swiftOrderParamsMessage: Buffer, swiftOrderParamsSignature: Buffer, marketIndex: number, takerInfo: {
+    placeSwiftTakerOrder(signedSwiftOrderParams: SignedSwiftOrderParams, marketIndex: number, takerInfo: {
         taker: PublicKey;
         takerStats: PublicKey;
         takerUserAccount: UserAccount;
     }, precedingIxs?: TransactionInstruction[], overrideIxCount?: number, txParams?: TxParams): Promise<TransactionSignature>;
-    getPlaceSwiftTakerPerpOrderIxs(encodedSwiftOrderParamsMessage: Buffer, swiftOrderParamsSignature: Buffer, marketIndex: number, takerInfo: {
+    getPlaceSwiftTakerPerpOrderIxs(signedSwiftOrderParams: SignedSwiftOrderParams, marketIndex: number, takerInfo: {
         taker: PublicKey;
         takerStats: PublicKey;
         takerUserAccount: UserAccount;
     }, authority?: PublicKey, precedingIxs?: TransactionInstruction[], overrideIxCount?: number): Promise<TransactionInstruction[]>;
-    placeAndMakeSwiftPerpOrder(encodedSwiftOrderParamsMessage: Buffer, swiftOrderParamsSignature: Buffer, swiftOrderUuid: Uint8Array, takerInfo: {
+    placeAndMakeSwiftPerpOrder(signedSwiftOrderParams: SignedSwiftOrderParams, swiftOrderUuid: Uint8Array, takerInfo: {
         taker: PublicKey;
         takerStats: PublicKey;
         takerUserAccount: UserAccount;
     }, orderParams: OptionalOrderParams, referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number, precedingIxs?: TransactionInstruction[], overrideIxCount?: number): Promise<TransactionSignature>;
-    getPlaceAndMakeSwiftPerpOrderIxs(encodedSwiftOrderParamsMessage: Buffer, swiftOrderParamsSignature: Buffer, swiftOrderUuid: Uint8Array, takerInfo: {
+    getPlaceAndMakeSwiftPerpOrderIxs(signedSwiftOrderParams: SignedSwiftOrderParams, swiftOrderUuid: Uint8Array, takerInfo: {
         taker: PublicKey;
         takerStats: PublicKey;
         takerUserAccount: UserAccount;

package/lib/browser/driftClient.js

@@ -3181,26 +3181,34 @@ class DriftClient {
         });
     }
     signSwiftOrderParamsMessage(orderParamsMessage) {
-        const takerOrderParamsMessage = this.encodeSwiftOrderParamsMessage(orderParamsMessage);
-        return this.signMessage(takerOrderParamsMessage);
+        const borshBuf = this.encodeSwiftOrderParamsMessage(orderParamsMessage);
+        const orderParams = Buffer.from(borshBuf.toString('hex'));
+        return {
+            orderParams,
+            signature: this.signMessage(Buffer.from(borshBuf.toString('hex'))),
+        };
     }
-    // encode the swift order for use in program Ix/signing
+    /*
+     * Borsh encode swift taker order params
+     */
     encodeSwiftOrderParamsMessage(orderParamsMessage) {
-        const borshBuf = this.program.coder.types.encode('SwiftOrderParamsMessage', orderParamsMessage);
-        return Buffer.from(borshBuf.toString('hex'));
+        return this.program.coder.types.encode('SwiftOrderParamsMessage', orderParamsMessage);
     }
+    /*
+     * Decode swift taker order params from borsh buffer
+     */
     decodeSwiftOrderParamsMessage(encodedMessage) {
         return this.program.coder.types.decode('SwiftOrderParamsMessage', encodedMessage);
     }
     signMessage(message, keypair = this.wallet.payer) {
         return Buffer.from(tweetnacl_1.default.sign.detached(message, keypair.secretKey));
     }
-    async placeSwiftTakerOrder(swiftOrderParamsMessage, swiftOrderParamsSignature, marketIndex, takerInfo, precedingIxs = [], overrideIxCount, txParams) {
-        const ixs = await this.getPlaceSwiftTakerPerpOrderIxs(swiftOrderParamsMessage, swiftOrderParamsSignature, marketIndex, takerInfo, undefined, precedingIxs, overrideIxCount);
+    async placeSwiftTakerOrder(signedSwiftOrderParams, marketIndex, takerInfo, precedingIxs = [], overrideIxCount, txParams) {
+        const ixs = await this.getPlaceSwiftTakerPerpOrderIxs(signedSwiftOrderParams, marketIndex, takerInfo, undefined, precedingIxs, overrideIxCount);
         const { txSig } = await this.sendTransaction(await this.buildTransaction(ixs, txParams), [], this.opts);
         return txSig;
     }
-    async getPlaceSwiftTakerPerpOrderIxs(encodedSwiftOrderParamsMessage, swiftOrderParamsSignature, marketIndex, takerInfo, authority, precedingIxs = [], overrideIxCount) {
+    async getPlaceSwiftTakerPerpOrderIxs(signedSwiftOrderParams, marketIndex, takerInfo, authority, precedingIxs = [], overrideIxCount) {
         if (!authority && !takerInfo.takerUserAccount) {
             throw new Error('authority or takerUserAccount must be provided');
         }
@@ -3211,12 +3219,12 @@ class DriftClient {
         });
         const authorityToUse = authority || takerInfo.takerUserAccount.authority;
         const messageLengthBuffer = Buffer.alloc(2);
-        messageLengthBuffer.writeUInt16LE(encodedSwiftOrderParamsMessage.length);
+        messageLengthBuffer.writeUInt16LE(signedSwiftOrderParams.orderParams.length);
         const swiftIxData = Buffer.concat([
-            swiftOrderParamsSignature,
+            signedSwiftOrderParams.signature,
             authorityToUse.toBytes(),
             messageLengthBuffer,
-            encodedSwiftOrderParamsMessage,
+            signedSwiftOrderParams.orderParams,
         ]);
         const swiftOrderParamsSignatureIx = (0, pythOracleUtils_1.createMinimalEd25519VerifyIx)(overrideIxCount || precedingIxs.length + 1, 12, swiftIxData, 0);
         const placeTakerSwiftPerpOrderIx = this.program.instruction.placeSwiftTakerOrder(swiftIxData, {
@@ -3232,14 +3240,14 @@ class DriftClient {
         });
         return [swiftOrderParamsSignatureIx, placeTakerSwiftPerpOrderIx];
     }
-    async placeAndMakeSwiftPerpOrder(encodedSwiftOrderParamsMessage, swiftOrderParamsSignature, swiftOrderUuid, takerInfo, orderParams, referrerInfo, txParams, subAccountId, precedingIxs = [], overrideIxCount) {
-        const ixs = await this.getPlaceAndMakeSwiftPerpOrderIxs(encodedSwiftOrderParamsMessage, swiftOrderParamsSignature, swiftOrderUuid, takerInfo, orderParams, referrerInfo, subAccountId, precedingIxs, overrideIxCount);
+    async placeAndMakeSwiftPerpOrder(signedSwiftOrderParams, swiftOrderUuid, takerInfo, orderParams, referrerInfo, txParams, subAccountId, precedingIxs = [], overrideIxCount) {
+        const ixs = await this.getPlaceAndMakeSwiftPerpOrderIxs(signedSwiftOrderParams, swiftOrderUuid, takerInfo, orderParams, referrerInfo, subAccountId, precedingIxs, overrideIxCount);
         const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(ixs, txParams), [], this.opts);
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
-    async getPlaceAndMakeSwiftPerpOrderIxs(encodedSwiftOrderParamsMessage, swiftOrderParamsSignature, swiftOrderUuid, takerInfo, orderParams, referrerInfo, subAccountId, precedingIxs = [], overrideIxCount) {
-        const [swiftOrderSignatureIx, placeTakerSwiftPerpOrderIx] = await this.getPlaceSwiftTakerPerpOrderIxs(encodedSwiftOrderParamsMessage, swiftOrderParamsSignature, orderParams.marketIndex, takerInfo, undefined, precedingIxs, overrideIxCount);
+    async getPlaceAndMakeSwiftPerpOrderIxs(signedSwiftOrderParams, swiftOrderUuid, takerInfo, orderParams, referrerInfo, subAccountId, precedingIxs = [], overrideIxCount) {
+        const [swiftOrderSignatureIx, placeTakerSwiftPerpOrderIx] = await this.getPlaceSwiftTakerPerpOrderIxs(signedSwiftOrderParams, orderParams.marketIndex, takerInfo, undefined, precedingIxs, overrideIxCount);
         orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.PERP });
         const userStatsPublicKey = this.getUserStatsAccountPublicKey();
         const user = await this.getUserAccountPublicKey(subAccountId);

package/lib/browser/idl/drift.json

@@ -14651,5 +14651,8 @@
             "name": "InvalidLiquidateSpotWithSwap",
             "msg": "InvalidLiquidateSpotWithSwap"
         }
-    ]
+    ],
+    "metadata": {
+        "address": "dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH"
+    }
 }

package/lib/browser/swift/swiftOrderSubscriber.js

@@ -71,7 +71,7 @@ class SwiftOrderSubscriber {
                 }
                 if (message['order']) {
                     const order = JSON.parse(message['order']);
-                    const swiftOrderParamsBuf = Buffer.from(order['order_message'], 'base64');
+                    const swiftOrderParamsBuf = Buffer.from(order['order_message'], 'hex');
                     const swiftOrderParamsMessage = this.driftClient.program.coder.types.decode('SwiftOrderParamsMessage', swiftOrderParamsBuf);
                     if (!swiftOrderParamsMessage.swiftOrderParams.price) {
                         console.error(`order has no price: ${JSON.stringify(swiftOrderParamsMessage.swiftOrderParams)}`);
@@ -91,11 +91,13 @@ class SwiftOrderSubscriber {
         });
     }
     async getPlaceAndMakeSwiftOrderIxs(orderMessageRaw, swiftOrderParamsMessage, makerOrderParams) {
-        const swiftOrderParamsBuf = Buffer.from(orderMessageRaw['order_message'], 'base64');
         const takerAuthority = new web3_js_1.PublicKey(orderMessageRaw['taker_authority']);
         const takerUserPubkey = await (0, __1.getUserAccountPublicKey)(this.driftClient.program.programId, takerAuthority, swiftOrderParamsMessage.subAccountId);
         const takerUserAccount = (await this.userMap.mustGet(takerUserPubkey.toString())).getUserAccount();
-        const ixs = await this.driftClient.getPlaceAndMakeSwiftPerpOrderIxs(swiftOrderParamsBuf, Buffer.from(orderMessageRaw['order_signature'], 'base64'), (0, tweetnacl_util_1.decodeUTF8)(orderMessageRaw['uuid']), {
+        const ixs = await this.driftClient.getPlaceAndMakeSwiftPerpOrderIxs({
+            orderParams: orderMessageRaw['order_message'],
+            signature: Buffer.from(orderMessageRaw['order_signature'], 'base64'),
+        }, (0, tweetnacl_util_1.decodeUTF8)(orderMessageRaw['uuid']), {
             taker: takerUserPubkey,
             takerUserAccount,
             takerStats: (0, __1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, takerUserAccount.authority),

package/lib/browser/swift/types.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Buffer } from 'buffer';
+/**
+ * Represents proof of a swift taker order
+ * It can be provided to drift program to fill a swift order
+ */
+export interface SignedSwiftOrderParams {
+    /**
+     * The encoded order params that were signed (borsh encoded then hexified).
+     */
+    orderParams: Buffer;
+    /**
+     * The signature generated for the orderParams
+     */
+    signature: Buffer;
+}

package/lib/browser/swift/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/node/constants/perpMarkets.js

@@ -1004,6 +1004,17 @@ exports.MainnetPerpMarkets = [
         oracleSource: __1.OracleSource.PYTH_PULL,
         pythFeedId: '0xbed3097008b9b5e3c93bec20be79cb43986b85a996475589351a21e67bae9b61',
     },
+    {
+        fullName: 'AI16Z',
+        category: ['AI'],
+        symbol: 'AI16Z-PERP',
+        baseAssetSymbol: 'AI16Z',
+        marketIndex: 63,
+        oracle: new web3_js_1.PublicKey('3gdGkrmBdYR7B1MRRdRVysqhZCvYvLGHonr9b7o9WVki'),
+        launchTs: 1736384970000,
+        oracleSource: __1.OracleSource.PYTH_PULL,
+        pythFeedId: '0x2551eca7784671173def2c41e6f3e51e11cd87494863f1d208fdd8c64a1f85ae',
+    },
 ];
 exports.PerpMarkets = {
     devnet: exports.DevnetPerpMarkets,

package/lib/node/constants/spotMarkets.js

@@ -513,6 +513,18 @@ exports.MainnetSpotMarkets = [
         pythFeedId: '0xeaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a',
         launchTs: 1735255852000,
     },
+    {
+        symbol: 'AI16Z',
+        marketIndex: 35,
+        poolId: 0,
+        oracle: new web3_js_1.PublicKey('3gdGkrmBdYR7B1MRRdRVysqhZCvYvLGHonr9b7o9WVki'),
+        oracleSource: __1.OracleSource.PYTH_PULL,
+        mint: new web3_js_1.PublicKey('HeLp6NuQkmYB4pYWo2zYs22mESHXPQYzXbB8n4V98jwC'),
+        precision: new __1.BN(10).pow(numericConstants_1.NINE),
+        precisionExp: numericConstants_1.NINE,
+        pythFeedId: '0x2551eca7784671173def2c41e6f3e51e11cd87494863f1d208fdd8c64a1f85ae',
+        launchTs: 1736384970000,
+    },
 ];
 exports.SpotMarkets = {
     devnet: exports.DevnetSpotMarkets,

package/lib/node/driftClient.d.ts

@@ -24,6 +24,7 @@ import { TxHandler } from './tx/txHandler';
 import { WormholeCoreBridgeSolana } from '@pythnetwork/pyth-solana-receiver/lib/idl/wormhole_core_bridge_solana';
 import { PythSolanaReceiver } from '@pythnetwork/pyth-solana-receiver/lib/idl/pyth_solana_receiver';
 import { Slothash } from './slot/SlothashSubscriber';
+import { SignedSwiftOrderParams } from './swift/types';
 type RemainingAccountParams = {
     userAccounts: UserAccount[];
     writablePerpMarketIndexes?: number[];
@@ -532,26 +533,26 @@ export declare class DriftClient {
     getPlaceAndTakePerpOrderIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, successCondition?: PlaceAndTakeOrderSuccessCondition, auctionDurationPercentage?: number, subAccountId?: number): Promise<TransactionInstruction>;
     placeAndMakePerpOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     getPlaceAndMakePerpOrderIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo, subAccountId?: number): Promise<TransactionInstruction>;
-    signSwiftOrderParamsMessage(orderParamsMessage: SwiftOrderParamsMessage): Buffer;
+    signSwiftOrderParamsMessage(orderParamsMessage: SwiftOrderParamsMessage): SignedSwiftOrderParams;
     encodeSwiftOrderParamsMessage(orderParamsMessage: SwiftOrderParamsMessage): Buffer;
     decodeSwiftOrderParamsMessage(encodedMessage: Buffer): SwiftOrderParamsMessage;
     signMessage(message: Uint8Array, keypair?: Keypair): Buffer;
-    placeSwiftTakerOrder(swiftOrderParamsMessage: Buffer, swiftOrderParamsSignature: Buffer, marketIndex: number, takerInfo: {
+    placeSwiftTakerOrder(signedSwiftOrderParams: SignedSwiftOrderParams, marketIndex: number, takerInfo: {
         taker: PublicKey;
         takerStats: PublicKey;
         takerUserAccount: UserAccount;
     }, precedingIxs?: TransactionInstruction[], overrideIxCount?: number, txParams?: TxParams): Promise<TransactionSignature>;
-    getPlaceSwiftTakerPerpOrderIxs(encodedSwiftOrderParamsMessage: Buffer, swiftOrderParamsSignature: Buffer, marketIndex: number, takerInfo: {
+    getPlaceSwiftTakerPerpOrderIxs(signedSwiftOrderParams: SignedSwiftOrderParams, marketIndex: number, takerInfo: {
         taker: PublicKey;
         takerStats: PublicKey;
         takerUserAccount: UserAccount;
     }, authority?: PublicKey, precedingIxs?: TransactionInstruction[], overrideIxCount?: number): Promise<TransactionInstruction[]>;
-    placeAndMakeSwiftPerpOrder(encodedSwiftOrderParamsMessage: Buffer, swiftOrderParamsSignature: Buffer, swiftOrderUuid: Uint8Array, takerInfo: {
+    placeAndMakeSwiftPerpOrder(signedSwiftOrderParams: SignedSwiftOrderParams, swiftOrderUuid: Uint8Array, takerInfo: {
         taker: PublicKey;
         takerStats: PublicKey;
         takerUserAccount: UserAccount;
     }, orderParams: OptionalOrderParams, referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number, precedingIxs?: TransactionInstruction[], overrideIxCount?: number): Promise<TransactionSignature>;
-    getPlaceAndMakeSwiftPerpOrderIxs(encodedSwiftOrderParamsMessage: Buffer, swiftOrderParamsSignature: Buffer, swiftOrderUuid: Uint8Array, takerInfo: {
+    getPlaceAndMakeSwiftPerpOrderIxs(signedSwiftOrderParams: SignedSwiftOrderParams, swiftOrderUuid: Uint8Array, takerInfo: {
         taker: PublicKey;
         takerStats: PublicKey;
         takerUserAccount: UserAccount;

package/lib/node/driftClient.js

@@ -3181,26 +3181,34 @@ class DriftClient {
         });
     }
     signSwiftOrderParamsMessage(orderParamsMessage) {
-        const takerOrderParamsMessage = this.encodeSwiftOrderParamsMessage(orderParamsMessage);
-        return this.signMessage(takerOrderParamsMessage);
+        const borshBuf = this.encodeSwiftOrderParamsMessage(orderParamsMessage);
+        const orderParams = Buffer.from(borshBuf.toString('hex'));
+        return {
+            orderParams,
+            signature: this.signMessage(Buffer.from(borshBuf.toString('hex'))),
+        };
     }
-    // encode the swift order for use in program Ix/signing
+    /*
+     * Borsh encode swift taker order params
+     */
     encodeSwiftOrderParamsMessage(orderParamsMessage) {
-        const borshBuf = this.program.coder.types.encode('SwiftOrderParamsMessage', orderParamsMessage);
-        return Buffer.from(borshBuf.toString('hex'));
+        return this.program.coder.types.encode('SwiftOrderParamsMessage', orderParamsMessage);
     }
+    /*
+     * Decode swift taker order params from borsh buffer
+     */
     decodeSwiftOrderParamsMessage(encodedMessage) {
         return this.program.coder.types.decode('SwiftOrderParamsMessage', encodedMessage);
     }
     signMessage(message, keypair = this.wallet.payer) {
         return Buffer.from(tweetnacl_1.default.sign.detached(message, keypair.secretKey));
     }
-    async placeSwiftTakerOrder(swiftOrderParamsMessage, swiftOrderParamsSignature, marketIndex, takerInfo, precedingIxs = [], overrideIxCount, txParams) {
-        const ixs = await this.getPlaceSwiftTakerPerpOrderIxs(swiftOrderParamsMessage, swiftOrderParamsSignature, marketIndex, takerInfo, undefined, precedingIxs, overrideIxCount);
+    async placeSwiftTakerOrder(signedSwiftOrderParams, marketIndex, takerInfo, precedingIxs = [], overrideIxCount, txParams) {
+        const ixs = await this.getPlaceSwiftTakerPerpOrderIxs(signedSwiftOrderParams, marketIndex, takerInfo, undefined, precedingIxs, overrideIxCount);
         const { txSig } = await this.sendTransaction(await this.buildTransaction(ixs, txParams), [], this.opts);
         return txSig;
     }
-    async getPlaceSwiftTakerPerpOrderIxs(encodedSwiftOrderParamsMessage, swiftOrderParamsSignature, marketIndex, takerInfo, authority, precedingIxs = [], overrideIxCount) {
+    async getPlaceSwiftTakerPerpOrderIxs(signedSwiftOrderParams, marketIndex, takerInfo, authority, precedingIxs = [], overrideIxCount) {
         if (!authority && !takerInfo.takerUserAccount) {
             throw new Error('authority or takerUserAccount must be provided');
         }
@@ -3211,12 +3219,12 @@ class DriftClient {
         });
         const authorityToUse = authority || takerInfo.takerUserAccount.authority;
         const messageLengthBuffer = Buffer.alloc(2);
-        messageLengthBuffer.writeUInt16LE(encodedSwiftOrderParamsMessage.length);
+        messageLengthBuffer.writeUInt16LE(signedSwiftOrderParams.orderParams.length);
         const swiftIxData = Buffer.concat([
-            swiftOrderParamsSignature,
+            signedSwiftOrderParams.signature,
             authorityToUse.toBytes(),
             messageLengthBuffer,
-            encodedSwiftOrderParamsMessage,
+            signedSwiftOrderParams.orderParams,
         ]);
         const swiftOrderParamsSignatureIx = (0, pythOracleUtils_1.createMinimalEd25519VerifyIx)(overrideIxCount || precedingIxs.length + 1, 12, swiftIxData, 0);
         const placeTakerSwiftPerpOrderIx = this.program.instruction.placeSwiftTakerOrder(swiftIxData, {
@@ -3232,14 +3240,14 @@ class DriftClient {
         });
         return [swiftOrderParamsSignatureIx, placeTakerSwiftPerpOrderIx];
     }
-    async placeAndMakeSwiftPerpOrder(encodedSwiftOrderParamsMessage, swiftOrderParamsSignature, swiftOrderUuid, takerInfo, orderParams, referrerInfo, txParams, subAccountId, precedingIxs = [], overrideIxCount) {
-        const ixs = await this.getPlaceAndMakeSwiftPerpOrderIxs(encodedSwiftOrderParamsMessage, swiftOrderParamsSignature, swiftOrderUuid, takerInfo, orderParams, referrerInfo, subAccountId, precedingIxs, overrideIxCount);
+    async placeAndMakeSwiftPerpOrder(signedSwiftOrderParams, swiftOrderUuid, takerInfo, orderParams, referrerInfo, txParams, subAccountId, precedingIxs = [], overrideIxCount) {
+        const ixs = await this.getPlaceAndMakeSwiftPerpOrderIxs(signedSwiftOrderParams, swiftOrderUuid, takerInfo, orderParams, referrerInfo, subAccountId, precedingIxs, overrideIxCount);
         const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(ixs, txParams), [], this.opts);
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
-    async getPlaceAndMakeSwiftPerpOrderIxs(encodedSwiftOrderParamsMessage, swiftOrderParamsSignature, swiftOrderUuid, takerInfo, orderParams, referrerInfo, subAccountId, precedingIxs = [], overrideIxCount) {
-        const [swiftOrderSignatureIx, placeTakerSwiftPerpOrderIx] = await this.getPlaceSwiftTakerPerpOrderIxs(encodedSwiftOrderParamsMessage, swiftOrderParamsSignature, orderParams.marketIndex, takerInfo, undefined, precedingIxs, overrideIxCount);
+    async getPlaceAndMakeSwiftPerpOrderIxs(signedSwiftOrderParams, swiftOrderUuid, takerInfo, orderParams, referrerInfo, subAccountId, precedingIxs = [], overrideIxCount) {
+        const [swiftOrderSignatureIx, placeTakerSwiftPerpOrderIx] = await this.getPlaceSwiftTakerPerpOrderIxs(signedSwiftOrderParams, orderParams.marketIndex, takerInfo, undefined, precedingIxs, overrideIxCount);
         orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.PERP });
         const userStatsPublicKey = this.getUserStatsAccountPublicKey();
         const user = await this.getUserAccountPublicKey(subAccountId);

package/lib/node/idl/drift.json

@@ -14651,5 +14651,8 @@
             "name": "InvalidLiquidateSpotWithSwap",
             "msg": "InvalidLiquidateSpotWithSwap"
         }
-    ]
+    ],
+    "metadata": {
+        "address": "dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH"
+    }
 }

package/lib/node/swift/swiftOrderSubscriber.js

@@ -71,7 +71,7 @@ class SwiftOrderSubscriber {
                 }
                 if (message['order']) {
                     const order = JSON.parse(message['order']);
-                    const swiftOrderParamsBuf = Buffer.from(order['order_message'], 'base64');
+                    const swiftOrderParamsBuf = Buffer.from(order['order_message'], 'hex');
                     const swiftOrderParamsMessage = this.driftClient.program.coder.types.decode('SwiftOrderParamsMessage', swiftOrderParamsBuf);
                     if (!swiftOrderParamsMessage.swiftOrderParams.price) {
                         console.error(`order has no price: ${JSON.stringify(swiftOrderParamsMessage.swiftOrderParams)}`);
@@ -91,11 +91,13 @@ class SwiftOrderSubscriber {
         });
     }
     async getPlaceAndMakeSwiftOrderIxs(orderMessageRaw, swiftOrderParamsMessage, makerOrderParams) {
-        const swiftOrderParamsBuf = Buffer.from(orderMessageRaw['order_message'], 'base64');
         const takerAuthority = new web3_js_1.PublicKey(orderMessageRaw['taker_authority']);
         const takerUserPubkey = await (0, __1.getUserAccountPublicKey)(this.driftClient.program.programId, takerAuthority, swiftOrderParamsMessage.subAccountId);
         const takerUserAccount = (await this.userMap.mustGet(takerUserPubkey.toString())).getUserAccount();
-        const ixs = await this.driftClient.getPlaceAndMakeSwiftPerpOrderIxs(swiftOrderParamsBuf, Buffer.from(orderMessageRaw['order_signature'], 'base64'), (0, tweetnacl_util_1.decodeUTF8)(orderMessageRaw['uuid']), {
+        const ixs = await this.driftClient.getPlaceAndMakeSwiftPerpOrderIxs({
+            orderParams: orderMessageRaw['order_message'],
+            signature: Buffer.from(orderMessageRaw['order_signature'], 'base64'),
+        }, (0, tweetnacl_util_1.decodeUTF8)(orderMessageRaw['uuid']), {
             taker: takerUserPubkey,
             takerUserAccount,
             takerStats: (0, __1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, takerUserAccount.authority),

package/lib/node/swift/types.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Buffer } from 'buffer';
+/**
+ * Represents proof of a swift taker order
+ * It can be provided to drift program to fill a swift order
+ */
+export interface SignedSwiftOrderParams {
+    /**
+     * The encoded order params that were signed (borsh encoded then hexified).
+     */
+    orderParams: Buffer;
+    /**
+     * The signature generated for the orderParams
+     */
+    signature: Buffer;
+}

package/lib/node/swift/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.107.0-beta.0",
+	"version": "2.107.0-beta.2",
 	"main": "lib/node/index.js",
 	"types": "lib/node/index.d.ts",
 	"browser": "./lib/browser/index.js",

package/src/constants/perpMarkets.ts

@@ -1092,6 +1092,18 @@ export const MainnetPerpMarkets: PerpMarketConfig[] = [
 		pythFeedId:
 			'0xbed3097008b9b5e3c93bec20be79cb43986b85a996475589351a21e67bae9b61',
 	},
+	{
+		fullName: 'AI16Z',
+		category: ['AI'],
+		symbol: 'AI16Z-PERP',
+		baseAssetSymbol: 'AI16Z',
+		marketIndex: 63,
+		oracle: new PublicKey('3gdGkrmBdYR7B1MRRdRVysqhZCvYvLGHonr9b7o9WVki'),
+		launchTs: 1736384970000,
+		oracleSource: OracleSource.PYTH_PULL,
+		pythFeedId:
+			'0x2551eca7784671173def2c41e6f3e51e11cd87494863f1d208fdd8c64a1f85ae',
+	},
 ];
 
 export const PerpMarkets: { [key in DriftEnv]: PerpMarketConfig[] } = {

package/src/constants/spotMarkets.ts

@@ -615,6 +615,19 @@ export const MainnetSpotMarkets: SpotMarketConfig[] = [
 			'0xeaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a',
 		launchTs: 1735255852000,
 	},
+	{
+		symbol: 'AI16Z',
+		marketIndex: 35,
+		poolId: 0,
+		oracle: new PublicKey('3gdGkrmBdYR7B1MRRdRVysqhZCvYvLGHonr9b7o9WVki'),
+		oracleSource: OracleSource.PYTH_PULL,
+		mint: new PublicKey('HeLp6NuQkmYB4pYWo2zYs22mESHXPQYzXbB8n4V98jwC'),
+		precision: new BN(10).pow(NINE),
+		precisionExp: NINE,
+		pythFeedId:
+			'0x2551eca7784671173def2c41e6f3e51e11cd87494863f1d208fdd8c64a1f85ae',
+		launchTs: 1736384970000,
+	},
 ];
 
 export const SpotMarkets: { [key in DriftEnv]: SpotMarketConfig[] } = {

package/src/driftClient.ts

@@ -181,6 +181,7 @@ import { gprcDriftClientAccountSubscriber } from './accounts/grpcDriftClientAcco
 import nacl from 'tweetnacl';
 import { Slothash } from './slot/SlothashSubscriber';
 import { getOracleId } from './oracles/oracleId';
+import { SignedSwiftOrderParams } from './swift/types';
 
 type RemainingAccountParams = {
 	userAccounts: UserAccount[];
@@ -5882,23 +5883,30 @@ export class DriftClient {
 
 	public signSwiftOrderParamsMessage(
 		orderParamsMessage: SwiftOrderParamsMessage
-	): Buffer {
-		const takerOrderParamsMessage =
-			this.encodeSwiftOrderParamsMessage(orderParamsMessage);
-		return this.signMessage(takerOrderParamsMessage);
+	): SignedSwiftOrderParams {
+		const borshBuf = this.encodeSwiftOrderParamsMessage(orderParamsMessage);
+		const orderParams = Buffer.from(borshBuf.toString('hex'));
+		return {
+			orderParams,
+			signature: this.signMessage(Buffer.from(borshBuf.toString('hex'))),
+		};
 	}
 
-	// encode the swift order for use in program Ix/signing
+	/*
+	 * Borsh encode swift taker order params
+	 */
 	public encodeSwiftOrderParamsMessage(
 		orderParamsMessage: SwiftOrderParamsMessage
 	): Buffer {
-		const borshBuf = this.program.coder.types.encode(
+		return this.program.coder.types.encode(
 			'SwiftOrderParamsMessage',
 			orderParamsMessage
 		);
-		return Buffer.from(borshBuf.toString('hex'));
 	}
 
+	/*
+	 * Decode swift taker order params from borsh buffer
+	 */
 	public decodeSwiftOrderParamsMessage(
 		encodedMessage: Buffer
 	): SwiftOrderParamsMessage {
@@ -5916,8 +5924,7 @@ export class DriftClient {
 	}
 
 	public async placeSwiftTakerOrder(
-		swiftOrderParamsMessage: Buffer,
-		swiftOrderParamsSignature: Buffer,
+		signedSwiftOrderParams: SignedSwiftOrderParams,
 		marketIndex: number,
 		takerInfo: {
 			taker: PublicKey;
@@ -5929,8 +5936,7 @@ export class DriftClient {
 		txParams?: TxParams
 	): Promise<TransactionSignature> {
 		const ixs = await this.getPlaceSwiftTakerPerpOrderIxs(
-			swiftOrderParamsMessage,
-			swiftOrderParamsSignature,
+			signedSwiftOrderParams,
 			marketIndex,
 			takerInfo,
 			undefined,
@@ -5946,8 +5952,7 @@ export class DriftClient {
 	}
 
 	public async getPlaceSwiftTakerPerpOrderIxs(
-		encodedSwiftOrderParamsMessage: Buffer,
-		swiftOrderParamsSignature: Buffer,
+		signedSwiftOrderParams: SignedSwiftOrderParams,
 		marketIndex: number,
 		takerInfo: {
 			taker: PublicKey;
@@ -5971,13 +5976,15 @@ export class DriftClient {
 		const authorityToUse = authority || takerInfo.takerUserAccount.authority;
 
 		const messageLengthBuffer = Buffer.alloc(2);
-		messageLengthBuffer.writeUInt16LE(encodedSwiftOrderParamsMessage.length);
+		messageLengthBuffer.writeUInt16LE(
+			signedSwiftOrderParams.orderParams.length
+		);
 
 		const swiftIxData = Buffer.concat([
-			swiftOrderParamsSignature,
+			signedSwiftOrderParams.signature,
 			authorityToUse.toBytes(),
 			messageLengthBuffer,
-			encodedSwiftOrderParamsMessage,
+			signedSwiftOrderParams.orderParams,
 		]);
 
 		const swiftOrderParamsSignatureIx = createMinimalEd25519VerifyIx(
@@ -6007,8 +6014,7 @@ export class DriftClient {
 	}
 
 	public async placeAndMakeSwiftPerpOrder(
-		encodedSwiftOrderParamsMessage: Buffer,
-		swiftOrderParamsSignature: Buffer,
+		signedSwiftOrderParams: SignedSwiftOrderParams,
 		swiftOrderUuid: Uint8Array,
 		takerInfo: {
 			taker: PublicKey;
@@ -6023,8 +6029,7 @@ export class DriftClient {
 		overrideIxCount?: number
 	): Promise<TransactionSignature> {
 		const ixs = await this.getPlaceAndMakeSwiftPerpOrderIxs(
-			encodedSwiftOrderParamsMessage,
-			swiftOrderParamsSignature,
+			signedSwiftOrderParams,
 			swiftOrderUuid,
 			takerInfo,
 			orderParams,
@@ -6044,8 +6049,7 @@ export class DriftClient {
 	}
 
 	public async getPlaceAndMakeSwiftPerpOrderIxs(
-		encodedSwiftOrderParamsMessage: Buffer,
-		swiftOrderParamsSignature: Buffer,
+		signedSwiftOrderParams: SignedSwiftOrderParams,
 		swiftOrderUuid: Uint8Array,
 		takerInfo: {
 			taker: PublicKey;
@@ -6060,8 +6064,7 @@ export class DriftClient {
 	): Promise<TransactionInstruction[]> {
 		const [swiftOrderSignatureIx, placeTakerSwiftPerpOrderIx] =
 			await this.getPlaceSwiftTakerPerpOrderIxs(
-				encodedSwiftOrderParamsMessage,
-				swiftOrderParamsSignature,
+				signedSwiftOrderParams,
 				orderParams.marketIndex,
 				takerInfo,
 				undefined,

package/src/idl/drift.json

@@ -14651,5 +14651,8 @@
       "name": "InvalidLiquidateSpotWithSwap",
       "msg": "InvalidLiquidateSpotWithSwap"
     }
-  ]
+  ],
+  "metadata": {
+    "address": "dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH"
+  }
 }

package/src/swift/swiftOrderSubscriber.ts

@@ -115,7 +115,7 @@ export class SwiftOrderSubscriber {
 					const order = JSON.parse(message['order']);
 					const swiftOrderParamsBuf = Buffer.from(
 						order['order_message'],
-						'base64'
+						'hex'
 					);
 					const swiftOrderParamsMessage: SwiftOrderParamsMessage =
 						this.driftClient.program.coder.types.decode(
@@ -153,10 +153,6 @@ export class SwiftOrderSubscriber {
 		swiftOrderParamsMessage: SwiftOrderParamsMessage,
 		makerOrderParams: OptionalOrderParams
 	): Promise<TransactionInstruction[]> {
-		const swiftOrderParamsBuf = Buffer.from(
-			orderMessageRaw['order_message'],
-			'base64'
-		);
 		const takerAuthority = new PublicKey(orderMessageRaw['taker_authority']);
 		const takerUserPubkey = await getUserAccountPublicKey(
 			this.driftClient.program.programId,
@@ -167,8 +163,10 @@ export class SwiftOrderSubscriber {
 			await this.userMap.mustGet(takerUserPubkey.toString())
 		).getUserAccount();
 		const ixs = await this.driftClient.getPlaceAndMakeSwiftPerpOrderIxs(
-			swiftOrderParamsBuf,
-			Buffer.from(orderMessageRaw['order_signature'], 'base64'),
+			{
+				orderParams: orderMessageRaw['order_message'],
+				signature: Buffer.from(orderMessageRaw['order_signature'], 'base64'),
+			},
 			decodeUTF8(orderMessageRaw['uuid']),
 			{
 				taker: takerUserPubkey,

package/src/swift/types.ts

@@ -0,0 +1,16 @@
+import { Buffer } from 'buffer';
+
+/**
+ * Represents proof of a swift taker order
+ * It can be provided to drift program to fill a swift order
+ */
+export interface SignedSwiftOrderParams {
+	/**
+	 * The encoded order params that were signed (borsh encoded then hexified).
+	 */
+	orderParams: Buffer;
+	/**
+	 * The signature generated for the orderParams
+	 */
+	signature: Buffer;
+}

package/tests/dlob/test.ts

@@ -159,11 +159,16 @@ function printOrderNode(
 	slot: number | undefined
 ) {
 	console.log(
-		` . vAMMNode? ${node.isVammNode()},\t${node.order ? getVariant(node.order?.orderType) : '~'
-		} ${node.order ? getVariant(node.order?.direction) : '~'}\t, slot: ${node.order?.slot.toString() || '~'
-		}, orderId: ${node.order?.orderId.toString() || '~'},\tnode.getPrice: ${oracle ? node.getPrice(oracle, slot!) : '~'
-		}, node.price: ${node.order?.price.toString() || '~'}, priceOffset: ${node.order?.oraclePriceOffset.toString() || '~'
-		} quantity: ${node.order?.baseAssetAmountFilled.toString() || '~'}/${node.order?.baseAssetAmount.toString() || '~'
+		` . vAMMNode? ${node.isVammNode()},\t${
+			node.order ? getVariant(node.order?.orderType) : '~'
+		} ${node.order ? getVariant(node.order?.direction) : '~'}\t, slot: ${
+			node.order?.slot.toString() || '~'
+		}, orderId: ${node.order?.orderId.toString() || '~'},\tnode.getPrice: ${
+			oracle ? node.getPrice(oracle, slot!) : '~'
+		}, node.price: ${node.order?.price.toString() || '~'}, priceOffset: ${
+			node.order?.oraclePriceOffset.toString() || '~'
+		} quantity: ${node.order?.baseAssetAmountFilled.toString() || '~'}/${
+			node.order?.baseAssetAmount.toString() || '~'
 		}`
 	);
 }
@@ -210,7 +215,8 @@ function printBookState(
 
 function printCrossedNodes(n: NodeToFill, slot: number) {
 	console.log(
-		`Cross Found, takerExists: ${n.node.order !== undefined}, makerExists: ${n.makerNodes !== undefined
+		`Cross Found, takerExists: ${n.node.order !== undefined}, makerExists: ${
+			n.makerNodes !== undefined
 		}`
 	);
 	console.log(
@@ -232,8 +238,10 @@ function printCrossedNodes(n: NodeToFill, slot: number) {
 		console.log(
 			`  orderId: ${o.orderId}, ${getVariant(o.orderType)}, ${getVariant(
 				o.direction
-			)},\texpired: ${isOrderExpired(o, slot)}, postOnly: ${o.postOnly
-			}, reduceOnly: ${o.reduceOnly
+			)},\texpired: ${isOrderExpired(o, slot)}, postOnly: ${
+				o.postOnly
+			}, reduceOnly: ${
+				o.reduceOnly
 			}, price: ${o.price.toString()}, priceOffset: ${o.oraclePriceOffset.toString()}, baseAmtFileld: ${o.baseAssetAmountFilled.toString()}/${o.baseAssetAmount.toString()}`
 		);
 	};