@drift-labs/sdk 2.37.1-beta.0 → 2.37.1-beta.10

package/VERSION

@@ -1 +1 @@
-2.37.1-beta.0
+2.37.1-beta.10

package/lib/adminClient.d.ts

@@ -26,6 +26,7 @@ export declare class AdminClient extends DriftClient {
     updateAmmJitIntensity(perpMarketIndex: number, ammJitIntensity: number): Promise<TransactionSignature>;
     updatePerpMarketName(perpMarketIndex: number, name: string): Promise<TransactionSignature>;
     updateSpotMarketName(spotMarketIndex: number, name: string): Promise<TransactionSignature>;
+    updatePerpMarketPerLpBase(perpMarketIndex: number, perLpBase: number): Promise<TransactionSignature>;
     updatePerpMarketMaxSpread(perpMarketIndex: number, maxSpread: number): Promise<TransactionSignature>;
     updatePerpFeeStructure(feeStructure: FeeStructure): Promise<TransactionSignature>;
     updateSpotFeeStructure(feeStructure: FeeStructure): Promise<TransactionSignature>;

package/lib/adminClient.js

@@ -365,6 +365,16 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
+    async updatePerpMarketPerLpBase(perpMarketIndex, perLpBase) {
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
+        return await this.program.rpc.updatePerpMarketPerLpBase(perLpBase, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                perpMarket: perpMarketPublicKey,
+            },
+        });
+    }
     async updatePerpMarketMaxSpread(perpMarketIndex, maxSpread) {
         const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, perpMarketIndex);
         return await this.program.rpc.updatePerpMarketMaxSpread(maxSpread, {

package/lib/constants/perpMarkets.js

@@ -144,6 +144,16 @@ exports.DevnetPerpMarkets = [
         launchTs: 1689270550000,
         oracleSource: __1.OracleSource.PYTH,
     },
+    {
+        fullName: 'HNT',
+        category: ['IoT'],
+        symbol: 'HNT-PERP',
+        baseAssetSymbol: 'HNT',
+        marketIndex: 14,
+        oracle: new web3_js_1.PublicKey('6Eg8YdfFJQF2HHonzPUBSCCmyUEhrStg9VBLK957sBe6'),
+        launchTs: 16922949550000,
+        oracleSource: __1.OracleSource.PYTH,
+    },
 ];
 exports.MainnetPerpMarkets = [
     {
@@ -286,6 +296,16 @@ exports.MainnetPerpMarkets = [
         launchTs: 1689270550000,
         oracleSource: __1.OracleSource.PYTH,
     },
+    {
+        fullName: 'HNT',
+        category: ['IoT'],
+        symbol: 'HNT-PERP',
+        baseAssetSymbol: 'HNT',
+        marketIndex: 14,
+        oracle: new web3_js_1.PublicKey('7moA1i5vQUpfDwSpK6Pw9s56ahB7WFGidtbL2ujWrVvm'),
+        launchTs: 16922949550000,
+        oracleSource: __1.OracleSource.PYTH,
+    },
 ];
 exports.PerpMarkets = {
     devnet: exports.DevnetPerpMarkets,

package/lib/events/eventSubscriber.js

@@ -101,6 +101,7 @@ class EventSubscriber {
         const records = [];
         // @ts-ignore
         const events = (0, parse_1.parseLogs)(this.program, slot, logs);
+        let runningEventIndex = 0;
         for (const event of events) {
             // @ts-ignore
             const expectRecordType = this.eventListMap.has(event.name);
@@ -108,8 +109,10 @@ class EventSubscriber {
                 event.data.txSig = txSig;
                 event.data.slot = slot;
                 event.data.eventType = event.name;
+                event.data.txSigIndex = runningEventIndex;
                 records.push(event.data);
             }
+            runningEventIndex++;
         }
         return records;
     }

package/lib/events/fetchLogs.js

@@ -83,11 +83,14 @@ class LogParser {
         const records = [];
         // @ts-ignore
         const eventGenerator = this.program._events._eventParser.parseLogs(event.logs, false);
+        let runningEventIndex = 0;
         for (const eventLog of eventGenerator) {
             eventLog.data.txSig = event.txSig;
             eventLog.data.slot = event.slot;
             eventLog.data.eventType = eventLog.name;
+            eventLog.data.txSigIndex = runningEventIndex;
             records.push(eventLog.data);
+            runningEventIndex++;
         }
         return records;
     }

package/lib/events/types.d.ts

@@ -17,6 +17,7 @@ export type EventSubscriptionOrderDirection = 'asc' | 'desc';
 export type Event<T> = T & {
     txSig: TransactionSignature;
     slot: number;
+    txSigIndex: number;
 };
 export type WrappedEvent<Type extends EventType> = EventMap[Type] & {
     eventType: Type;

package/lib/idl/drift.json

@@ -1122,6 +1122,31 @@
                 }
             ]
         },
+        {
+            "name": "updateUserReduceOnly",
+            "accounts": [
+                {
+                    "name": "user",
+                    "isMut": true,
+                    "isSigner": false
+                },
+                {
+                    "name": "authority",
+                    "isMut": false,
+                    "isSigner": true
+                }
+            ],
+            "args": [
+                {
+                    "name": "subAccountId",
+                    "type": "u16"
+                },
+                {
+                    "name": "reduceOnly",
+                    "type": "bool"
+                }
+            ]
+        },
         {
             "name": "deleteUser",
             "accounts": [
@@ -3857,6 +3882,32 @@
                 }
             ]
         },
+        {
+            "name": "updatePerpMarketPerLpBase",
+            "accounts": [
+                {
+                    "name": "admin",
+                    "isMut": false,
+                    "isSigner": true
+                },
+                {
+                    "name": "state",
+                    "isMut": false,
+                    "isSigner": false
+                },
+                {
+                    "name": "perpMarket",
+                    "isMut": true,
+                    "isSigner": false
+                }
+            ],
+            "args": [
+                {
+                    "name": "perLpBase",
+                    "type": "i8"
+                }
+            ]
+        },
         {
             "name": "updateLpCooldownTime",
             "accounts": [
@@ -6953,9 +7004,20 @@
                         ],
                         "type": "i32"
                     },
+                    {
+                        "name": "perLpBase",
+                        "docs": [
+                            "expo for unit of per_lp, base 10 (if per_lp_base=X, then per_lp unit is 10^X)"
+                        ],
+                        "type": "i8"
+                    },
                     {
                         "name": "padding1",
-                        "type": "u32"
+                        "type": "u8"
+                    },
+                    {
+                        "name": "padding2",
+                        "type": "u16"
                     },
                     {
                         "name": "totalFeeEarnedPerLp",
@@ -7422,13 +7484,8 @@
                         "type": "u8"
                     },
                     {
-                        "name": "padding",
-                        "type": {
-                            "array": [
-                                "u8",
-                                1
-                            ]
-                        }
+                        "name": "perLpBase",
+                        "type": "i8"
                     }
                 ]
             }
@@ -8314,6 +8371,9 @@
                     },
                     {
                         "name": "Bankrupt"
+                    },
+                    {
+                        "name": "ReduceOnly"
                     }
                 ]
             }
@@ -10681,6 +10741,11 @@
             "code": 6253,
             "name": "CantUpdatePerpBidAskTwap",
             "msg": "CantUpdatePerpBidAskTwap"
+        },
+        {
+            "code": 6254,
+            "name": "UserReduceOnly",
+            "msg": "UserReduceOnly"
         }
     ]
 }

package/lib/index.d.ts

@@ -60,6 +60,7 @@ export * from './serum/serumSubscriber';
 export * from './serum/serumFulfillmentConfigMap';
 export * from './phoenix/phoenixSubscriber';
 export * from './phoenix/phoenixFulfillmentConfigMap';
+export * from './tx/fastSingleTxSender';
 export * from './tx/retryTxSender';
 export * from './tx/types';
 export * from './util/computeUnits';

package/lib/index.js

@@ -83,6 +83,7 @@ __exportStar(require("./serum/serumSubscriber"), exports);
 __exportStar(require("./serum/serumFulfillmentConfigMap"), exports);
 __exportStar(require("./phoenix/phoenixSubscriber"), exports);
 __exportStar(require("./phoenix/phoenixFulfillmentConfigMap"), exports);
+__exportStar(require("./tx/fastSingleTxSender"), exports);
 __exportStar(require("./tx/retryTxSender"), exports);
 __exportStar(require("./tx/types"), exports);
 __exportStar(require("./util/computeUnits"), exports);

package/lib/math/auction.js

@@ -64,7 +64,7 @@ function getAuctionPriceForOracleOffsetAuction(order, slot, oraclePrice) {
     const deltaDenominator = new _1.BN(order.auctionDuration);
     const deltaNumerator = _1.BN.min(slotsElapsed, deltaDenominator);
     if (deltaDenominator.eq(_1.ZERO)) {
-        return order.auctionEndPrice.add(order.auctionEndPrice);
+        return oraclePrice.add(order.auctionEndPrice);
     }
     let priceOffsetDelta;
     if ((0, types_1.isVariant)(order.direction, 'long')) {

package/lib/orderSubscriber/OrderSubscriber.d.ts

@@ -1,11 +1,14 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { DriftClient } from '../driftClient';
 import { UserAccount } from '../types';
 import { Buffer } from 'buffer';
 import { DLOB } from '../dlob/DLOB';
-import { OrderSubscriberConfig } from './types';
+import { OrderSubscriberConfig, OrderSubscriberEvents } from './types';
 import { PollingSubscription } from './PollingSubscription';
 import { WebsocketSubscription } from './WebsocketSubscription';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
 export declare class OrderSubscriber {
     driftClient: DriftClient;
     usersAccounts: Map<string, {
@@ -13,6 +16,7 @@ export declare class OrderSubscriber {
         userAccount: UserAccount;
     }>;
     subscription: PollingSubscription | WebsocketSubscription;
+    eventEmitter: StrictEventEmitter<EventEmitter, OrderSubscriberEvents>;
     fetchPromise?: Promise<void>;
     fetchPromiseResolver: () => void;
     constructor(config: OrderSubscriberConfig);

package/lib/orderSubscriber/OrderSubscriber.js

@@ -7,6 +7,7 @@ const buffer_1 = require("buffer");
 const DLOB_1 = require("../dlob/DLOB");
 const PollingSubscription_1 = require("./PollingSubscription");
 const WebsocketSubscription_1 = require("./WebsocketSubscription");
+const events_1 = require("events");
 class OrderSubscriber {
     constructor(config) {
         this.usersAccounts = new Map();
@@ -23,6 +24,7 @@ class OrderSubscriber {
                 skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
             });
         }
+        this.eventEmitter = new events_1.EventEmitter();
     }
     async subscribe() {
         await this.subscription.subscribe();
@@ -75,6 +77,14 @@ class OrderSubscriber {
         const slotAndUserAccount = this.usersAccounts.get(key);
         if (!slotAndUserAccount || slotAndUserAccount.slot < slot) {
             const userAccount = this.driftClient.program.account.user.coder.accounts.decode('User', buffer);
+            const newOrders = userAccount.orders.filter((order) => {
+                var _a;
+                return order.slot.toNumber() > ((_a = slotAndUserAccount === null || slotAndUserAccount === void 0 ? void 0 : slotAndUserAccount.slot) !== null && _a !== void 0 ? _a : 0) &&
+                    order.slot.toNumber() <= slot;
+            });
+            if (newOrders.length > 0) {
+                this.eventEmitter.emit('onUpdate', userAccount, newOrders, new web3_js_1.PublicKey(key), slot);
+            }
             if (userAccount.hasOpenOrder) {
                 this.usersAccounts.set(key, { slot, userAccount });
             }

package/lib/orderSubscriber/types.d.ts

@@ -1,3 +1,5 @@
+import { PublicKey } from '@solana/web3.js';
+import { Order, UserAccount } from '../types';
 import { DriftClient } from '../driftClient';
 export type OrderSubscriberConfig = {
     driftClient: DriftClient;
@@ -9,3 +11,6 @@ export type OrderSubscriberConfig = {
         skipInitialLoad?: boolean;
     };
 };
+export interface OrderSubscriberEvents {
+    onUpdate: (account: UserAccount, updatedOrders: Order[], pubkey: PublicKey, slot: number) => void;
+}

package/lib/tx/baseTxSender.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { TxSender, TxSigAndSlot } from './types';
+import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature, Connection, VersionedTransaction, TransactionInstruction, AddressLookupTableAccount } from '@solana/web3.js';
+import { IWallet } from '../types';
+export declare abstract class BaseTxSender implements TxSender {
+    connection: Connection;
+    wallet: IWallet;
+    opts: ConfirmOptions;
+    timeout: number;
+    additionalConnections: Connection[];
+    timeoutCount: number;
+    constructor({ connection, wallet, opts, timeout, additionalConnections, }: {
+        connection: Connection;
+        wallet: IWallet;
+        opts?: ConfirmOptions;
+        timeout?: number;
+        additionalConnections?: any;
+    });
+    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
+    prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions): Promise<Transaction>;
+    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<VersionedTransaction>;
+    sendVersionedTransaction(tx: VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
+    sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
+    confirmTransaction(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
+    getTimestamp(): number;
+    promiseTimeout<T>(promises: Promise<T>[], timeoutMs: number): Promise<T | null>;
+    sendToAdditionalConnections(rawTx: Buffer | Uint8Array, opts: ConfirmOptions): void;
+    addAdditionalConnection(newConnection: Connection): void;
+    getTimeoutCount(): number;
+}

package/lib/tx/baseTxSender.js

@@ -0,0 +1,176 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTxSender = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@coral-xyz/anchor");
+const assert_1 = __importDefault(require("assert"));
+const bs58_1 = __importDefault(require("bs58"));
+const DEFAULT_TIMEOUT = 35000;
+class BaseTxSender {
+    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, additionalConnections = new Array(), }) {
+        this.timeoutCount = 0;
+        this.connection = connection;
+        this.wallet = wallet;
+        this.opts = opts;
+        this.timeout = timeout;
+        this.additionalConnections = additionalConnections;
+    }
+    async send(tx, additionalSigners, opts, preSigned) {
+        if (additionalSigners === undefined) {
+            additionalSigners = [];
+        }
+        if (opts === undefined) {
+            opts = this.opts;
+        }
+        const signedTx = preSigned
+            ? tx
+            : await this.prepareTx(tx, additionalSigners, opts);
+        return this.sendRawTransaction(signedTx.serialize(), opts);
+    }
+    async prepareTx(tx, additionalSigners, opts) {
+        tx.feePayer = this.wallet.publicKey;
+        tx.recentBlockhash = (await this.connection.getLatestBlockhash(opts.preflightCommitment)).blockhash;
+        additionalSigners
+            .filter((s) => s !== undefined)
+            .forEach((kp) => {
+            tx.partialSign(kp);
+        });
+        const signedTx = await this.wallet.signTransaction(tx);
+        return signedTx;
+    }
+    async getVersionedTransaction(ixs, lookupTableAccounts, additionalSigners, opts) {
+        if (additionalSigners === undefined) {
+            additionalSigners = [];
+        }
+        if (opts === undefined) {
+            opts = this.opts;
+        }
+        const message = new web3_js_1.TransactionMessage({
+            payerKey: this.wallet.publicKey,
+            recentBlockhash: (await this.connection.getLatestBlockhash(opts.preflightCommitment)).blockhash,
+            instructions: ixs,
+        }).compileToV0Message(lookupTableAccounts);
+        const tx = new web3_js_1.VersionedTransaction(message);
+        return tx;
+    }
+    async sendVersionedTransaction(tx, additionalSigners, opts, preSigned) {
+        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 (opts === undefined) {
+            opts = this.opts;
+        }
+        return this.sendRawTransaction(signedTx.serialize(), opts);
+    }
+    async sendRawTransaction(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    rawTransaction, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    opts) {
+        throw new Error('Must be implemented by subclass');
+    }
+    async confirmTransaction(signature, commitment) {
+        let decodedSignature;
+        try {
+            decodedSignature = bs58_1.default.decode(signature);
+        }
+        catch (err) {
+            throw new Error('signature must be base58 encoded: ' + signature);
+        }
+        (0, assert_1.default)(decodedSignature.length === 64, 'signature has invalid length');
+        const start = Date.now();
+        const subscriptionCommitment = commitment || this.opts.commitment;
+        const subscriptionIds = new Array();
+        const connections = [this.connection, ...this.additionalConnections];
+        let response = null;
+        const promises = connections.map((connection, i) => {
+            let subscriptionId;
+            const confirmPromise = new Promise((resolve, reject) => {
+                try {
+                    subscriptionId = connection.onSignature(signature, (result, context) => {
+                        subscriptionIds[i] = undefined;
+                        response = {
+                            context,
+                            value: result,
+                        };
+                        resolve(null);
+                    }, subscriptionCommitment);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+            subscriptionIds.push(subscriptionId);
+            return confirmPromise;
+        });
+        try {
+            await this.promiseTimeout(promises, this.timeout);
+        }
+        finally {
+            for (const [i, subscriptionId] of subscriptionIds.entries()) {
+                if (subscriptionId) {
+                    connections[i].removeSignatureListener(subscriptionId);
+                }
+            }
+        }
+        if (response === null) {
+            this.timeoutCount += 1;
+            const duration = (Date.now() - start) / 1000;
+            throw new Error(`Transaction was not confirmed in ${duration.toFixed(2)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`);
+        }
+        return response;
+    }
+    getTimestamp() {
+        return new Date().getTime();
+    }
+    promiseTimeout(promises, timeoutMs) {
+        let timeoutId;
+        const timeoutPromise = new Promise((resolve) => {
+            timeoutId = setTimeout(() => resolve(null), timeoutMs);
+        });
+        return Promise.race([...promises, timeoutPromise]).then((result) => {
+            clearTimeout(timeoutId);
+            return result;
+        });
+    }
+    sendToAdditionalConnections(rawTx, opts) {
+        this.additionalConnections.map((connection) => {
+            connection.sendRawTransaction(rawTx, opts).catch((e) => {
+                console.error(
+                // @ts-ignore
+                `error sending tx to additional connection ${connection._rpcEndpoint}`);
+                console.error(e);
+            });
+        });
+    }
+    addAdditionalConnection(newConnection) {
+        const alreadyUsingConnection = this.additionalConnections.filter((connection) => {
+            // @ts-ignore
+            return connection._rpcEndpoint === newConnection.rpcEndpoint;
+        }).length > 0;
+        if (!alreadyUsingConnection) {
+            this.additionalConnections.push(newConnection);
+        }
+    }
+    getTimeoutCount() {
+        return this.timeoutCount;
+    }
+}
+exports.BaseTxSender = BaseTxSender;

package/lib/tx/fastSingleTxSender.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { TxSigAndSlot } from './types';
+import { ConfirmOptions, Signer, Transaction, Connection, VersionedTransaction, TransactionInstruction, AddressLookupTableAccount } from '@solana/web3.js';
+import { IWallet } from '../types';
+import { BaseTxSender } from './baseTxSender';
+export declare class FastSingleTxSender extends BaseTxSender {
+    connection: Connection;
+    wallet: IWallet;
+    opts: ConfirmOptions;
+    timeout: number;
+    blockhashRefreshInterval: number;
+    additionalConnections: Connection[];
+    timoutCount: number;
+    recentBlockhash: string;
+    constructor({ connection, wallet, opts, timeout, blockhashRefreshInterval, additionalConnections, }: {
+        connection: Connection;
+        wallet: IWallet;
+        opts?: ConfirmOptions;
+        timeout?: number;
+        blockhashRefreshInterval?: number;
+        additionalConnections?: any;
+    });
+    startBlockhashRefreshLoop(): void;
+    prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions): Promise<Transaction>;
+    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<VersionedTransaction>;
+    sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
+}

package/lib/tx/fastSingleTxSender.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastSingleTxSender = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@coral-xyz/anchor");
+const baseTxSender_1 = require("./baseTxSender");
+const DEFAULT_TIMEOUT = 35000;
+const DEFAULT_BLOCKHASH_REFRESH = 10000;
+class FastSingleTxSender extends baseTxSender_1.BaseTxSender {
+    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, blockhashRefreshInterval = DEFAULT_BLOCKHASH_REFRESH, additionalConnections = new Array(), }) {
+        super({ connection, wallet, opts, timeout, additionalConnections });
+        this.timoutCount = 0;
+        this.connection = connection;
+        this.wallet = wallet;
+        this.opts = opts;
+        this.timeout = timeout;
+        this.blockhashRefreshInterval = blockhashRefreshInterval;
+        this.additionalConnections = additionalConnections;
+        this.startBlockhashRefreshLoop();
+    }
+    startBlockhashRefreshLoop() {
+        setInterval(async () => {
+            this.recentBlockhash = (await this.connection.getLatestBlockhash(this.opts)).blockhash;
+        }, 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(opts.preflightCommitment))
+                .blockhash;
+        additionalSigners
+            .filter((s) => s !== undefined)
+            .forEach((kp) => {
+            tx.partialSign(kp);
+        });
+        const signedTx = await this.wallet.signTransaction(tx);
+        return signedTx;
+    }
+    async getVersionedTransaction(ixs, lookupTableAccounts, additionalSigners, opts) {
+        var _a;
+        if (additionalSigners === undefined) {
+            additionalSigners = [];
+        }
+        if (opts === undefined) {
+            opts = this.opts;
+        }
+        const message = new web3_js_1.TransactionMessage({
+            payerKey: this.wallet.publicKey,
+            recentBlockhash: (_a = this.recentBlockhash) !== null && _a !== void 0 ? _a : (await this.connection.getLatestBlockhash(opts.preflightCommitment))
+                .blockhash,
+            instructions: ixs,
+        }).compileToV0Message(lookupTableAccounts);
+        const tx = new web3_js_1.VersionedTransaction(message);
+        return tx;
+    }
+    async sendRawTransaction(rawTransaction, opts) {
+        let txid;
+        try {
+            txid = await this.connection.sendRawTransaction(rawTransaction, opts);
+            this.sendToAdditionalConnections(rawTransaction, opts);
+        }
+        catch (e) {
+            console.error(e);
+            throw e;
+        }
+        this.connection.sendRawTransaction(rawTransaction, opts).catch((e) => {
+            console.error(e);
+        });
+        this.sendToAdditionalConnections(rawTransaction, opts);
+        let slot;
+        try {
+            const result = await this.confirmTransaction(txid, opts.commitment);
+            slot = result.context.slot;
+        }
+        catch (e) {
+            console.error(e);
+            throw e;
+        }
+        return { txSig: txid, slot };
+    }
+}
+exports.FastSingleTxSender = FastSingleTxSender;