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

package/lib/constants/perpMarkets.js

@@ -244,6 +244,16 @@ exports.DevnetPerpMarkets = [
         launchTs: 1709852537000,
         oracleSource: __1.OracleSource.Prelaunch,
     },
+    {
+        fullName: 'Kamino',
+        category: ['Lending'],
+        symbol: 'KMNO-PERP',
+        baseAssetSymbol: 'KMNO',
+        marketIndex: 24,
+        oracle: new web3_js_1.PublicKey('FkAaa46aYdHn8QxxwmiUnJt3th8radB2GFXDMtyLALCY'),
+        launchTs: 1711475936000,
+        oracleSource: __1.OracleSource.Prelaunch,
+    },
 ];
 exports.MainnetPerpMarkets = [
     {

package/lib/driftClient.d.ts

@@ -329,8 +329,8 @@ export declare class DriftClient {
     getRevertFillIx(fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
     placeSpotOrder(orderParams: OptionalOrderParams, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     getPlaceSpotOrderIx(orderParams: OptionalOrderParams, subAccountId?: number): Promise<TransactionInstruction>;
-    fillSpotOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount | PhoenixV1FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<TransactionSignature>;
-    getFillSpotOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount | PhoenixV1FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo, fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
+    fillSpotOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount | PhoenixV1FulfillmentConfigAccount, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<TransactionSignature>;
+    getFillSpotOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount | PhoenixV1FulfillmentConfigAccount, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
     addSpotFulfillmentAccounts(marketIndex: number, remainingAccounts: AccountMeta[], fulfillmentConfig?: SerumV3FulfillmentConfigAccount | PhoenixV1FulfillmentConfigAccount): void;
     addSerumRemainingAccounts(marketIndex: number, remainingAccounts: AccountMeta[], fulfillmentConfig: SerumV3FulfillmentConfigAccount): void;
     addPhoenixRemainingAccounts(marketIndex: number, remainingAccounts: AccountMeta[], fulfillmentConfig: PhoenixV1FulfillmentConfigAccount): void;

package/lib/driftClient.js

@@ -1934,22 +1934,27 @@ class DriftClient {
         const marketIndex = order
             ? order.marketIndex
             : userAccount.orders.find((order) => order.orderId === userAccount.nextOrderId - 1).marketIndex;
+        makerInfo = Array.isArray(makerInfo)
+            ? makerInfo
+            : makerInfo
+                ? [makerInfo]
+                : [];
         const userAccounts = [userAccount];
-        if (makerInfo !== undefined) {
-            userAccounts.push(makerInfo.makerUserAccount);
+        for (const maker of makerInfo) {
+            userAccounts.push(maker.makerUserAccount);
         }
         const remainingAccounts = this.getRemainingAccounts({
             userAccounts,
             writableSpotMarketIndexes: [marketIndex, numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
         });
-        if (makerInfo) {
+        for (const maker of makerInfo) {
             remainingAccounts.push({
-                pubkey: makerInfo.maker,
+                pubkey: maker.maker,
                 isWritable: true,
                 isSigner: false,
             });
             remainingAccounts.push({
-                pubkey: makerInfo.makerStats,
+                pubkey: maker.makerStats,
                 isWritable: true,
                 isSigner: false,
             });
@@ -1967,9 +1972,8 @@ class DriftClient {
             });
         }
         const orderId = order.orderId;
-        const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
         this.addSpotFulfillmentAccounts(marketIndex, remainingAccounts, fulfillmentConfig);
-        return await this.program.instruction.fillSpotOrder(orderId, fulfillmentConfig ? fulfillmentConfig.fulfillmentType : null, makerOrderId, {
+        return await this.program.instruction.fillSpotOrder(orderId, fulfillmentConfig ? fulfillmentConfig.fulfillmentType : null, null, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 filler,

package/lib/idl/drift.json

@@ -8997,7 +8997,11 @@
                         "name": "ExternalMarket"
                     },
                     {
-                        "name": "Match"
+                        "name": "Match",
+                        "fields": [
+                            "publicKey",
+                            "u16"
+                        ]
                     }
                 ]
             }

package/lib/index.d.ts

@@ -73,6 +73,7 @@ export * from './priorityFee';
 export * from './phoenix/phoenixFulfillmentConfigMap';
 export * from './tx/fastSingleTxSender';
 export * from './tx/retryTxSender';
+export * from './tx/whileValidTxSender';
 export * from './tx/priorityFeeCalculator';
 export * from './tx/types';
 export * from './util/computeUnits';

package/lib/index.js

@@ -96,6 +96,7 @@ __exportStar(require("./priorityFee"), exports);
 __exportStar(require("./phoenix/phoenixFulfillmentConfigMap"), exports);
 __exportStar(require("./tx/fastSingleTxSender"), exports);
 __exportStar(require("./tx/retryTxSender"), exports);
+__exportStar(require("./tx/whileValidTxSender"), exports);
 __exportStar(require("./tx/priorityFeeCalculator"), exports);
 __exportStar(require("./tx/types"), exports);
 __exportStar(require("./util/computeUnits"), exports);

package/lib/tx/baseTxSender.d.ts

@@ -21,7 +21,7 @@ export declare abstract class BaseTxSender implements TxSender {
         additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
     });
     send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean, extraConfirmationOptions?: ExtraConfirmationOptions): Promise<TxSigAndSlot>;
-    prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions): Promise<Transaction>;
+    prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions, preSigned?: boolean): Promise<Transaction>;
     getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions, blockhash?: string): Promise<VersionedTransaction>;
     sendVersionedTransaction(tx: VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean, extraConfirmationOptions?: ExtraConfirmationOptions): Promise<TxSigAndSlot>;
     sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;

package/lib/tx/baseTxSender.js

@@ -28,15 +28,16 @@ class BaseTxSender {
         if (opts === undefined) {
             opts = this.opts;
         }
-        const signedTx = preSigned
-            ? tx
-            : await this.prepareTx(tx, additionalSigners, opts);
+        const signedTx = await this.prepareTx(tx, additionalSigners, opts, preSigned);
         if (extraConfirmationOptions === null || extraConfirmationOptions === void 0 ? void 0 : extraConfirmationOptions.onSignedCb) {
             extraConfirmationOptions.onSignedCb();
         }
         return this.sendRawTransaction(signedTx.serialize(), opts);
     }
-    async prepareTx(tx, additionalSigners, opts) {
+    async prepareTx(tx, additionalSigners, opts, preSigned) {
+        if (preSigned) {
+            return tx;
+        }
         tx.feePayer = this.wallet.publicKey;
         tx.recentBlockhash = (await this.connection.getLatestBlockhash(opts.preflightCommitment)).blockhash;
         additionalSigners

package/lib/tx/fastSingleTxSender.d.ts

@@ -26,7 +26,7 @@ export declare class FastSingleTxSender extends BaseTxSender {
         confirmationStrategy?: ConfirmationStrategy;
     });
     startBlockhashRefreshLoop(): void;
-    prepareTx(tx: Transaction, additionalSigners: Array<Signer>, _opts: ConfirmOptions): Promise<Transaction>;
+    prepareTx(tx: Transaction, additionalSigners: Array<Signer>, _opts: ConfirmOptions, preSigned?: boolean): Promise<Transaction>;
     getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions, blockhash?: string): Promise<VersionedTransaction>;
     sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
 }

package/lib/tx/fastSingleTxSender.js

@@ -38,19 +38,8 @@ class FastSingleTxSender extends baseTxSender_1.BaseTxSender {
             }
         }, this.blockhashRefreshInterval);
     }
-    async prepareTx(tx, additionalSigners, _opts) {
-        var _a;
-        tx.feePayer = this.wallet.publicKey;
-        tx.recentBlockhash =
-            (_a = this.recentBlockhash) !== null && _a !== void 0 ? _a : (await this.connection.getLatestBlockhash(this.blockhashCommitment))
-                .blockhash;
-        additionalSigners
-            .filter((s) => s !== undefined)
-            .forEach((kp) => {
-            tx.partialSign(kp);
-        });
-        const signedTx = await this.wallet.signTransaction(tx);
-        return signedTx;
+    async prepareTx(tx, additionalSigners, _opts, preSigned) {
+        return super.prepareTx(tx, additionalSigners, _opts, preSigned);
     }
     async getVersionedTransaction(ixs, lookupTableAccounts, additionalSigners, opts, blockhash) {
         var _a;

package/lib/tx/whileValidTxSender.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+import { ExtraConfirmationOptions, TxSigAndSlot } from './types';
+import { AddressLookupTableAccount, ConfirmOptions, Connection, Signer, Transaction, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
+import { IWallet } from '../types';
+import { BaseTxSender } from './baseTxSender';
+type ResolveReference = {
+    resolve?: () => void;
+};
+export declare class WhileValidTxSender extends BaseTxSender {
+    connection: Connection;
+    wallet: IWallet;
+    opts: ConfirmOptions;
+    timeout: number;
+    retrySleep: number;
+    additionalConnections: Connection[];
+    timoutCount: number;
+    untilValid: Map<string, {
+        blockhash: string;
+        lastValidBlockHeight: number;
+    }>;
+    constructor({ connection, wallet, opts, retrySleep, additionalConnections, additionalTxSenderCallbacks, }: {
+        connection: Connection;
+        wallet: IWallet;
+        opts?: ConfirmOptions;
+        retrySleep?: number;
+        additionalConnections?: any;
+        additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
+    });
+    sleep(reference: ResolveReference): Promise<void>;
+    prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions, preSigned?: boolean): Promise<Transaction>;
+    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], _additionalSigners?: Array<Signer>, _opts?: ConfirmOptions): Promise<VersionedTransaction>;
+    sendVersionedTransaction(tx: VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean, extraConfirmationOptions?: ExtraConfirmationOptions): Promise<TxSigAndSlot>;
+    sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
+}
+export {};

package/lib/tx/whileValidTxSender.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhileValidTxSender = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@coral-xyz/anchor");
+const baseTxSender_1 = require("./baseTxSender");
+const bs58_1 = __importDefault(require("bs58"));
+const DEFAULT_RETRY = 8000;
+class WhileValidTxSender extends baseTxSender_1.BaseTxSender {
+    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), additionalTxSenderCallbacks = [], }) {
+        super({
+            connection,
+            wallet,
+            opts,
+            additionalConnections,
+            additionalTxSenderCallbacks,
+        });
+        this.timoutCount = 0;
+        this.untilValid = new Map();
+        this.retrySleep = retrySleep;
+    }
+    async sleep(reference) {
+        return new Promise((resolve) => {
+            reference.resolve = resolve;
+            setTimeout(resolve, this.retrySleep);
+        });
+    }
+    async prepareTx(tx, additionalSigners, opts, preSigned) {
+        var _a;
+        const latestBlockhash = await this.connection.getLatestBlockhash(opts.preflightCommitment);
+        // handle tx
+        let signedTx = tx;
+        if (!preSigned) {
+            tx.feePayer = this.wallet.publicKey;
+            tx.recentBlockhash = latestBlockhash.blockhash;
+            additionalSigners
+                .filter((s) => s !== undefined)
+                .forEach((kp) => {
+                tx.partialSign(kp);
+            });
+            signedTx = await this.wallet.signTransaction(tx);
+        }
+        // handle subclass-specific side effects
+        const txSig = bs58_1.default.encode(((_a = tx.signatures[0]) === null || _a === void 0 ? void 0 : _a.signature) || tx.signatures[0]);
+        this.untilValid.set(txSig, latestBlockhash);
+        return signedTx;
+    }
+    async getVersionedTransaction(ixs, lookupTableAccounts, _additionalSigners, _opts) {
+        const message = new web3_js_1.TransactionMessage({
+            payerKey: this.wallet.publicKey,
+            recentBlockhash: '',
+            instructions: ixs,
+        }).compileToV0Message(lookupTableAccounts);
+        const tx = new web3_js_1.VersionedTransaction(message);
+        return tx;
+    }
+    async sendVersionedTransaction(tx, additionalSigners, opts, preSigned, extraConfirmationOptions) {
+        const latestBlockhash = await this.connection.getLatestBlockhash();
+        tx.message.recentBlockhash = latestBlockhash.blockhash;
+        let signedTx;
+        if (preSigned) {
+            signedTx = tx;
+            // @ts-ignore
+        }
+        else if (this.wallet.payer) {
+            // @ts-ignore
+            tx.sign((additionalSigners !== null && additionalSigners !== void 0 ? additionalSigners : []).concat(this.wallet.payer));
+            signedTx = tx;
+        }
+        else {
+            additionalSigners === null || additionalSigners === void 0 ? void 0 : additionalSigners.filter((s) => s !== undefined).forEach((kp) => {
+                tx.sign([kp]);
+            });
+            // @ts-ignore
+            signedTx = await this.wallet.signTransaction(tx);
+        }
+        if (extraConfirmationOptions === null || extraConfirmationOptions === void 0 ? void 0 : extraConfirmationOptions.onSignedCb) {
+            extraConfirmationOptions.onSignedCb();
+        }
+        if (opts === undefined) {
+            opts = this.opts;
+        }
+        const txSig = bs58_1.default.encode(signedTx.signatures[0]);
+        this.untilValid.set(txSig, latestBlockhash);
+        return this.sendRawTransaction(signedTx.serialize(), opts);
+    }
+    async sendRawTransaction(rawTransaction, opts) {
+        const startTime = this.getTimestamp();
+        const txid = await this.connection.sendRawTransaction(rawTransaction, opts);
+        this.sendToAdditionalConnections(rawTransaction, opts);
+        let done = false;
+        const resolveReference = {
+            resolve: undefined,
+        };
+        const stopWaiting = () => {
+            done = true;
+            if (resolveReference.resolve) {
+                resolveReference.resolve();
+            }
+        };
+        (async () => {
+            while (!done && this.getTimestamp() - startTime < this.timeout) {
+                await this.sleep(resolveReference);
+                if (!done) {
+                    this.connection
+                        .sendRawTransaction(rawTransaction, opts)
+                        .catch((e) => {
+                        console.error(e);
+                        stopWaiting();
+                    });
+                    this.sendToAdditionalConnections(rawTransaction, opts);
+                }
+            }
+        })();
+        let slot;
+        try {
+            const { blockhash, lastValidBlockHeight } = this.untilValid.get(txid);
+            const result = await this.connection.confirmTransaction({
+                signature: txid,
+                lastValidBlockHeight,
+                blockhash,
+            }, opts.commitment);
+            slot = result.context.slot;
+            // eslint-disable-next-line no-useless-catch
+        }
+        catch (e) {
+            throw e;
+        }
+        finally {
+            stopWaiting();
+        }
+        return { txSig: txid, slot };
+    }
+}
+exports.WhileValidTxSender = WhileValidTxSender;

package/package.json

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