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

package/VERSION

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

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/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/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;

package/lib/tx/retryTxSender.d.ts

@@ -1,11 +1,12 @@
 /// <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 { TxSigAndSlot } from './types';
+import { ConfirmOptions, Connection } from '@solana/web3.js';
 import { IWallet } from '../types';
+import { BaseTxSender } from './baseTxSender';
 type ResolveReference = {
     resolve?: () => void;
 };
-export declare class RetryTxSender implements TxSender {
+export declare class RetryTxSender extends BaseTxSender {
     connection: Connection;
     wallet: IWallet;
     opts: ConfirmOptions;
@@ -21,17 +22,7 @@ export declare class RetryTxSender implements TxSender {
         retrySleep?: 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;
     sleep(reference: ResolveReference): Promise<void>;
-    promiseTimeout<T>(promises: Promise<T>[], timeoutMs: number): Promise<T | null>;
-    sendToAdditionalConnections(rawTx: Buffer | Uint8Array, opts: ConfirmOptions): void;
-    addAdditionalConnection(newConnection: Connection): void;
-    getTimeoutCount(): number;
+    sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
 }
 export {};

package/lib/tx/retryTxSender.js

@@ -1,17 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RetryTxSender = 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 baseTxSender_1 = require("./baseTxSender");
 const DEFAULT_TIMEOUT = 35000;
 const DEFAULT_RETRY = 8000;
-class RetryTxSender {
+class RetryTxSender extends baseTxSender_1.BaseTxSender {
     constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), }) {
+        super({ connection, wallet, opts, timeout, additionalConnections });
         this.timoutCount = 0;
         this.connection = connection;
         this.wallet = wallet;
@@ -20,66 +16,11 @@ class RetryTxSender {
         this.retrySleep = retrySleep;
         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.getRecentBlockhash(opts.preflightCommitment)).blockhash;
-        additionalSigners
-            .filter((s) => s !== undefined)
-            .forEach((kp) => {
-            tx.partialSign(kp);
+    async sleep(reference) {
+        return new Promise((resolve) => {
+            reference.resolve = resolve;
+            setTimeout(resolve, this.retrySleep);
         });
-        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.getRecentBlockhash(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(rawTransaction, opts) {
         const startTime = this.getTimestamp();
@@ -130,97 +71,5 @@ class RetryTxSender {
         }
         return { txSig: txid, slot };
     }
-    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.timoutCount += 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();
-    }
-    async sleep(reference) {
-        return new Promise((resolve) => {
-            reference.resolve = resolve;
-            setTimeout(resolve, this.retrySleep);
-        });
-    }
-    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.timoutCount;
-    }
 }
 exports.RetryTxSender = RetryTxSender;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.37.1-beta.0",
+	"version": "2.37.1-beta.2",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -55,7 +55,7 @@
 		"eslint-plugin-prettier": "^3.4.0",
 		"lodash": "^4.17.21",
 		"mocha": "^10.0.0",
-		"prettier": "^2.4.1",
+		"prettier": "^3.0.1",
 		"ts-node": "^10.8.0",
 		"typescript": "^4.9.5"
 	},

package/src/events/eventSubscriber.ts

@@ -168,6 +168,7 @@ export class EventSubscriber {
 		const records = [];
 		// @ts-ignore
 		const events = parseLogs(this.program, slot, logs);
+		let runningEventIndex = 0;
 		for (const event of events) {
 			// @ts-ignore
 			const expectRecordType = this.eventListMap.has(event.name);
@@ -175,8 +176,10 @@ export 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/src/events/fetchLogs.ts

@@ -155,11 +155,14 @@ export class LogParser {
 			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/src/events/types.ts

@@ -64,6 +64,7 @@ export type EventSubscriptionOrderDirection = 'asc' | 'desc';
 export type Event<T> = T & {
 	txSig: TransactionSignature;
 	slot: number;
+	txSigIndex: number; // Unique index for each event inside a tx
 };
 
 export type WrappedEvent<Type extends EventType> = EventMap[Type] & {