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

package/VERSION

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

package/lib/constants/perpMarkets.js

@@ -778,6 +778,16 @@ exports.MainnetPerpMarkets = [
         oracleSource: __1.OracleSource.PYTH_PULL,
         pythFeedId: '0x8963217838ab4cf5cadc172203c1f0b763fbaa45f346d8ee50ba994bbcac3026',
     },
+    {
+        fullName: 'LANDO-F1-SGP-WIN-BET',
+        category: ['Prediction', 'Sports'],
+        symbol: 'LANDO-F1-SGP-WIN-BET',
+        baseAssetSymbol: 'LANDO-F1-SGP-WIN',
+        marketIndex: 43,
+        oracle: new web3_js_1.PublicKey('DpJz7rjTJLxxnuqrqZTUjMWtnaMFAEfZUv5ATdb9HTh1'),
+        launchTs: 1726646453000,
+        oracleSource: __1.OracleSource.Prelaunch,
+    },
 ];
 exports.PerpMarkets = {
     devnet: exports.DevnetPerpMarkets,

package/lib/constants/spotMarkets.js

@@ -94,7 +94,7 @@ exports.MainnetSpotMarkets = [
         precision: new __1.BN(10).pow(numericConstants_1.EIGHT),
         precisionExp: numericConstants_1.EIGHT,
         serumMarket: new web3_js_1.PublicKey('3BAKsQd3RuhZKES2DGysMhjBdwjZYKYmxRqnSMtZ4KSN'),
-        pythFeedId: '0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43',
+        pythFeedId: '0xc9d8b075a5c69303365ae23633d4e085199bf5c520a3b90fed1322a0342ffc33',
     },
     {
         symbol: 'wETH',
@@ -280,6 +280,7 @@ exports.MainnetSpotMarkets = [
         precision: new __1.BN(10).pow(numericConstants_1.SIX),
         precisionExp: numericConstants_1.SIX,
         launchTs: 1719415157000,
+        pythFeedId: '0xc811abc82b4bad1f9bd711a2773ccaa935b03ecef974236942cec5e0eb845a3a',
     },
     {
         symbol: 'POPCAT',

package/lib/driftClient.d.ts

@@ -3,7 +3,7 @@
 /// <reference types="node" />
 import { AnchorProvider, BN, Program, ProgramAccount } from '@coral-xyz/anchor';
 import { Idl as Idl30, Program as Program30 } from '@coral-xyz/anchor-30';
-import { StateAccount, IWallet, PositionDirection, UserAccount, PerpMarketAccount, OrderParams, Order, SpotMarketAccount, SpotPosition, MakerInfo, TakerInfo, OptionalOrderParams, ReferrerInfo, MarketType, TxParams, SerumV3FulfillmentConfigAccount, ReferrerNameAccount, OrderTriggerCondition, PerpMarketExtendedInfo, UserStatsAccount, PhoenixV1FulfillmentConfigAccount, ModifyOrderPolicy, SwapReduceOnly, SettlePnlMode, SignedTxData, MappedRecord, OpenbookV2FulfillmentConfigAccount } from './types';
+import { StateAccount, IWallet, PositionDirection, UserAccount, PerpMarketAccount, OrderParams, Order, SpotMarketAccount, SpotPosition, MakerInfo, TakerInfo, OptionalOrderParams, ReferrerInfo, MarketType, TxParams, SerumV3FulfillmentConfigAccount, ReferrerNameAccount, OrderTriggerCondition, PerpMarketExtendedInfo, UserStatsAccount, PhoenixV1FulfillmentConfigAccount, ModifyOrderPolicy, SwapReduceOnly, SettlePnlMode, SignedTxData, MappedRecord, OpenbookV2FulfillmentConfigAccount, SwiftOrderParamsMessage } from './types';
 import * as anchor from '@coral-xyz/anchor';
 import { Connection, PublicKey, TransactionSignature, ConfirmOptions, Transaction, TransactionInstruction, AccountMeta, Signer, AddressLookupTableAccount, TransactionVersion, VersionedTransaction, BlockhashWithExpiryBlockHeight } from '@solana/web3.js';
 import { TokenFaucet } from './tokenFaucet';
@@ -239,6 +239,7 @@ export declare class DriftClient {
      */
     getAssociatedTokenAccount(marketIndex: number, useNative?: boolean, tokenProgram?: anchor.web3.PublicKey): Promise<PublicKey>;
     createAssociatedTokenAccountIdempotentInstruction(account: PublicKey, payer: PublicKey, owner: PublicKey, mint: PublicKey, tokenProgram?: anchor.web3.PublicKey): TransactionInstruction;
+    getDepositTxnIx(amount: BN, marketIndex: number, associatedTokenAccount: PublicKey, subAccountId?: number, reduceOnly?: boolean): Promise<TransactionInstruction[]>;
     createDepositTxn(amount: BN, marketIndex: number, associatedTokenAccount: PublicKey, subAccountId?: number, reduceOnly?: boolean, txParams?: TxParams): Promise<VersionedTransaction | Transaction>;
     /**
      * Deposit funds into the given spot market
@@ -261,6 +262,10 @@ export declare class DriftClient {
     getTokenProgramForSpotMarket(spotMarketAccount: SpotMarketAccount): PublicKey;
     addTokenMintToRemainingAccounts(spotMarketAccount: SpotMarketAccount, remainingAccounts: AccountMeta[]): void;
     getAssociatedTokenAccountCreationIx(tokenMintAddress: PublicKey, associatedTokenAddress: PublicKey, tokenProgram: PublicKey): anchor.web3.TransactionInstruction;
+    createInitializeUserAccountAndDepositCollateralIxs(amount: BN, userTokenAccount: PublicKey, marketIndex?: number, subAccountId?: number, name?: string, fromSubAccountId?: number, referrerInfo?: ReferrerInfo, donateAmount?: BN, customMaxMarginRatio?: number): Promise<{
+        ixs: TransactionInstruction[];
+        userAccountPublicKey: PublicKey;
+    }>;
     createInitializeUserAccountAndDepositCollateral(amount: BN, userTokenAccount: PublicKey, marketIndex?: number, subAccountId?: number, name?: string, fromSubAccountId?: number, referrerInfo?: ReferrerInfo, donateAmount?: BN, txParams?: TxParams, customMaxMarginRatio?: number): Promise<[Transaction | VersionedTransaction, PublicKey]>;
     /**
      * Creates the User account for a user, and deposits some initial collateral
@@ -340,7 +345,10 @@ export declare class DriftClient {
         signedSettlePnlTx?: Transaction;
     }>;
     placePerpOrder(orderParams: OptionalOrderParams, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
-    getPlacePerpOrderIx(orderParams: OptionalOrderParams, subAccountId?: number): Promise<TransactionInstruction>;
+    getPlacePerpOrderIx(orderParams: OptionalOrderParams, subAccountId?: number, depositToTradeArgs?: {
+        isMakingNewAccount: boolean;
+        depositMarketIndex: number;
+    }): Promise<TransactionInstruction>;
     updateAMMs(marketIndexes: number[], txParams?: TxParams): Promise<TransactionSignature>;
     getUpdateAMMsIx(marketIndexes: number[]): Promise<TransactionInstruction>;
     settleExpiredMarket(marketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
@@ -497,6 +505,38 @@ export declare class DriftClient {
     getPlaceAndTakePerpOrderIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, 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>;
+    signTakerOrderParams(orderParamsMessage: SwiftOrderParamsMessage): Promise<Buffer>;
+    getEncodedSwiftOrderParamsMessage(orderParamsMessage: SwiftOrderParamsMessage): Buffer;
+    decodeSwiftTakerOrderParamsMessage(encodedMessage: Buffer): SwiftOrderParamsMessage;
+    signMessage(message: Uint8Array): Promise<Buffer>;
+    assembleSwiftServerMessage(message: Buffer, signature: Buffer, takerPubkey: PublicKey, marketIndex: number, marketType: MarketType, slot: number | BN): {
+        message: string;
+        signature: string;
+        taker_pubkey: string;
+        market_index: number;
+        market_type: 'perp' | 'spot';
+        slot: BN;
+    };
+    placeSwiftTakerOrder(takerOrderParamsMessage: Buffer, takerSignature: Buffer, marketIndex: number, takerInfo: {
+        taker: PublicKey;
+        takerStats: PublicKey;
+        takerUserAccount: UserAccount;
+    }, txParams?: TxParams): Promise<TransactionSignature>;
+    getPlaceSwiftTakerPerpOrderIx(takerOrderParamsMessage: Buffer, takerSignature: Buffer, marketIndex: number, takerInfo: {
+        taker: PublicKey;
+        takerStats: PublicKey;
+        takerUserAccount: UserAccount;
+    }): Promise<TransactionInstruction[]>;
+    placeAndMakeSwiftPerpOrder(encodedTakerOrderParamsMessage: Buffer, takerSignature: Buffer, takerExpectedOrderId: number, takerInfo: {
+        taker: PublicKey;
+        takerStats: PublicKey;
+        takerUserAccount: UserAccount;
+    }, orderParams: OptionalOrderParams, referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
+    getPlaceAndMakeSwiftPerpOrderIxs(encodedTakerOrderParamsMessage: Buffer, takerSignature: Buffer, takerExpectedOrderId: number, takerInfo: {
+        taker: PublicKey;
+        takerStats: PublicKey;
+        takerUserAccount: UserAccount;
+    }, orderParams: OptionalOrderParams, referrerInfo?: ReferrerInfo, subAccountId?: number): Promise<TransactionInstruction[]>;
     preparePlaceAndTakeSpotOrder(orderParams: OptionalOrderParams, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number): Promise<{
         placeAndTakeSpotOrderTx: anchor.web3.Transaction | anchor.web3.VersionedTransaction;
     }>;

package/lib/driftClient.js

@@ -68,6 +68,7 @@ const utils_2 = require("./tx/utils");
 const pyth_solana_receiver_json_1 = __importDefault(require("./idl/pyth_solana_receiver.json"));
 const on_demand_1 = require("@switchboard-xyz/on-demand");
 const switchboard_on_demand_30_json_1 = __importDefault(require("./idl/switchboard_on_demand_30.json"));
+const ed = __importStar(require("@noble/ed25519"));
 /**
  * # DriftClient
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
@@ -109,6 +110,7 @@ class DriftClient {
         this.txHandler =
             (_m = config === null || config === void 0 ? void 0 : config.txHandler) !== null && _m !== void 0 ? _m : new txHandler_1.TxHandler({
                 connection: this.connection,
+                // @ts-ignore
                 wallet: this.provider.wallet,
                 confirmationOptions: this.opts,
                 opts: {
@@ -1118,7 +1120,7 @@ class DriftClient {
             data: Buffer.from([0x1]),
         });
     }
-    async createDepositTxn(amount, marketIndex, associatedTokenAccount, subAccountId, reduceOnly = false, txParams) {
+    async getDepositTxnIx(amount, marketIndex, associatedTokenAccount, subAccountId, reduceOnly = false) {
         const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
         const isSolMarket = spotMarketAccount.mint.equals(spotMarkets_1.WRAPPED_SOL_MINT);
         const signerAuthority = this.wallet.publicKey;
@@ -1135,6 +1137,10 @@ class DriftClient {
         if (createWSOLTokenAccount) {
             instructions.push((0, spl_token_1.createCloseAccountInstruction)(associatedTokenAccount, signerAuthority, signerAuthority, []));
         }
+        return instructions;
+    }
+    async createDepositTxn(amount, marketIndex, associatedTokenAccount, subAccountId, reduceOnly = false, txParams) {
+        const instructions = await this.getDepositTxnIx(amount, marketIndex, associatedTokenAccount, subAccountId, reduceOnly);
         txParams = { ...(txParams !== null && txParams !== void 0 ? txParams : this.txParams), computeUnits: 600000 };
         const tx = await this.buildTransaction(instructions, txParams);
         return tx;
@@ -1242,7 +1248,7 @@ class DriftClient {
     getAssociatedTokenAccountCreationIx(tokenMintAddress, associatedTokenAddress, tokenProgram) {
         return (0, spl_token_1.createAssociatedTokenAccountInstruction)(this.wallet.publicKey, associatedTokenAddress, this.wallet.publicKey, tokenMintAddress, tokenProgram);
     }
-    async createInitializeUserAccountAndDepositCollateral(amount, userTokenAccount, marketIndex = 0, subAccountId = 0, name, fromSubAccountId, referrerInfo, donateAmount, txParams, customMaxMarginRatio) {
+    async createInitializeUserAccountAndDepositCollateralIxs(amount, userTokenAccount, marketIndex = 0, subAccountId = 0, name, fromSubAccountId, referrerInfo, donateAmount, customMaxMarginRatio) {
         const ixs = [];
         const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(subAccountId, name, referrerInfo);
         const spotMarket = this.getSpotMarketAccount(marketIndex);
@@ -1288,6 +1294,13 @@ class DriftClient {
         if (createWSOLTokenAccount) {
             ixs.push((0, spl_token_1.createCloseAccountInstruction)(wsolTokenAccount, authority, authority, []));
         }
+        return {
+            ixs,
+            userAccountPublicKey,
+        };
+    }
+    async createInitializeUserAccountAndDepositCollateral(amount, userTokenAccount, marketIndex = 0, subAccountId = 0, name, fromSubAccountId, referrerInfo, donateAmount, txParams, customMaxMarginRatio) {
+        const { ixs, userAccountPublicKey } = await this.createInitializeUserAccountAndDepositCollateralIxs(amount, userTokenAccount, marketIndex, subAccountId, name, fromSubAccountId, referrerInfo, donateAmount, customMaxMarginRatio);
         const tx = await this.buildTransaction(ixs, txParams);
         return [tx, userAccountPublicKey];
     }
@@ -1663,13 +1676,21 @@ class DriftClient {
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
-    async getPlacePerpOrderIx(orderParams, subAccountId) {
+    async getPlacePerpOrderIx(orderParams, subAccountId, depositToTradeArgs) {
         orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.PERP });
-        const user = await this.getUserAccountPublicKey(subAccountId);
+        const isDepositToTradeTx = depositToTradeArgs !== undefined;
+        const user = isDepositToTradeTx
+            ? (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, this.authority, subAccountId)
+            : await this.getUserAccountPublicKey(subAccountId);
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount(subAccountId)],
-            useMarketLastSlotCache: true,
+            userAccounts: (depositToTradeArgs === null || depositToTradeArgs === void 0 ? void 0 : depositToTradeArgs.isMakingNewAccount)
+                ? []
+                : [this.getUserAccount(subAccountId)],
+            useMarketLastSlotCache: false,
             readablePerpMarketIndex: orderParams.marketIndex,
+            readableSpotMarketIndexes: isDepositToTradeTx
+                ? [depositToTradeArgs === null || depositToTradeArgs === void 0 ? void 0 : depositToTradeArgs.depositMarketIndex]
+                : undefined,
         });
         return await this.program.instruction.placePerpOrder(orderParams, {
             accounts: {
@@ -2781,7 +2802,9 @@ class DriftClient {
         if (!txsToSign) {
             return null;
         }
-        const signedTxs = (await this.txHandler.getSignedTransactionMap(txsToSign, this.provider.wallet)).signedTxMap;
+        const signedTxs = (await this.txHandler.getSignedTransactionMap(txsToSign, 
+        // @ts-ignore
+        this.provider.wallet)).signedTxMap;
         const { txSig, slot } = await this.sendTransaction(signedTxs.placeAndTakeTx, [], this.opts, true);
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return {
@@ -2888,6 +2911,101 @@ class DriftClient {
             remainingAccounts,
         });
     }
+    async signTakerOrderParams(orderParamsMessage) {
+        const takerOrderParamsMessage = Uint8Array.from(this.getEncodedSwiftOrderParamsMessage(orderParamsMessage));
+        return await this.signMessage(takerOrderParamsMessage);
+    }
+    getEncodedSwiftOrderParamsMessage(orderParamsMessage) {
+        return this.program.coder.types.encode('SwiftOrderParamsMessage', orderParamsMessage);
+    }
+    decodeSwiftTakerOrderParamsMessage(encodedMessage) {
+        return this.program.coder.types.decode('SwiftOrderParamsMessage', encodedMessage);
+    }
+    async signMessage(message) {
+        return Buffer.from(await ed.sign(message, this.wallet.payer.secretKey.slice(0, 32)));
+    }
+    assembleSwiftServerMessage(message, signature, takerPubkey, marketIndex, marketType, slot) {
+        return {
+            message: message.toString('base64'),
+            signature: signature.toString('base64'),
+            taker_pubkey: takerPubkey.toBase58(),
+            market_index: marketIndex,
+            market_type: (0, types_1.isVariant)(marketType, 'perp') ? 'perp' : 'spot',
+            slot: typeof slot === 'number' ? new anchor_1.BN(slot) : slot,
+        };
+    }
+    async placeSwiftTakerOrder(takerOrderParamsMessage, takerSignature, marketIndex, takerInfo, txParams) {
+        const ixs = await this.getPlaceSwiftTakerPerpOrderIx(takerOrderParamsMessage, takerSignature, marketIndex, takerInfo);
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(ixs, txParams), [], this.opts);
+        return txSig;
+    }
+    async getPlaceSwiftTakerPerpOrderIx(takerOrderParamsMessage, takerSignature, marketIndex, takerInfo) {
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [takerInfo.takerUserAccount],
+            useMarketLastSlotCache: true,
+            readablePerpMarketIndex: marketIndex,
+        });
+        const signatureIx = web3_js_1.Ed25519Program.createInstructionWithPublicKey({
+            publicKey: takerInfo.takerUserAccount.authority.toBytes(),
+            signature: Uint8Array.from(takerSignature),
+            message: Uint8Array.from(takerOrderParamsMessage),
+        });
+        const placeTakerSwiftPerpOrderIx = await this.program.instruction.placeSwiftTakerOrder(takerOrderParamsMessage, takerSignature, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user: takerInfo.taker,
+                userStats: takerInfo.takerStats,
+                authority: this.wallet.publicKey,
+                ixSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            },
+            remainingAccounts,
+        });
+        return [signatureIx, placeTakerSwiftPerpOrderIx];
+    }
+    async placeAndMakeSwiftPerpOrder(encodedTakerOrderParamsMessage, takerSignature, takerExpectedOrderId, takerInfo, orderParams, referrerInfo, txParams, subAccountId) {
+        const ixs = await this.getPlaceAndMakeSwiftPerpOrderIxs(encodedTakerOrderParamsMessage, takerSignature, takerExpectedOrderId, takerInfo, orderParams, referrerInfo, subAccountId);
+        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(ixs, txParams), [], this.opts);
+        this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
+        return txSig;
+    }
+    async getPlaceAndMakeSwiftPerpOrderIxs(encodedTakerOrderParamsMessage, takerSignature, takerExpectedOrderId, takerInfo, orderParams, referrerInfo, subAccountId) {
+        const [signatureIx, placeTakerSwiftPerpOrderIx] = await this.getPlaceSwiftTakerPerpOrderIx(encodedTakerOrderParamsMessage, takerSignature, orderParams.marketIndex, takerInfo);
+        orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.PERP });
+        const userStatsPublicKey = this.getUserStatsAccountPublicKey();
+        const user = await this.getUserAccountPublicKey(subAccountId);
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [
+                this.getUserAccount(subAccountId),
+                takerInfo.takerUserAccount,
+            ],
+            useMarketLastSlotCache: true,
+            writablePerpMarketIndexes: [orderParams.marketIndex],
+        });
+        if (referrerInfo) {
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrer,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrerStats,
+                isWritable: true,
+                isSigner: false,
+            });
+        }
+        const placeAndMakeIx = await this.program.instruction.placeAndMakePerpOrder(orderParams, takerExpectedOrderId, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                user,
+                userStats: userStatsPublicKey,
+                taker: takerInfo.taker,
+                takerStats: takerInfo.takerStats,
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts,
+        });
+        return [signatureIx, placeTakerSwiftPerpOrderIx, placeAndMakeIx];
+    }
     async preparePlaceAndTakeSpotOrder(orderParams, fulfillmentConfig, makerInfo, referrerInfo, txParams, subAccountId) {
         const tx = await this.buildTransaction(await this.getPlaceAndTakeSpotOrderIx(orderParams, fulfillmentConfig, makerInfo, referrerInfo, subAccountId), txParams);
         return {

package/lib/events/eventSubscriber.d.ts

@@ -15,12 +15,19 @@ export declare class EventSubscriber {
     private awaitTxPromises;
     private awaitTxResolver;
     private logProvider;
+    private currentProviderType;
     eventEmitter: StrictEventEmitter<EventEmitter, EventSubscriberEvents>;
     private lastSeenSlot;
     private lastSeenBlockTime;
     lastSeenTxSig: string;
     constructor(connection: Connection, program: Program, options?: EventSubscriptionOptions);
+    private initializeLogProvider;
     private populateInitialEventListMap;
+    /**
+     * Implements fallback logic for reconnecting to LogProvider. Currently terminates at polling,
+     * could be improved to try the original type again after some cooldown.
+     */
+    private updateFallbackProviderType;
     subscribe(): Promise<boolean>;
     private handleTxLogs;
     fetchPreviousTx(fetchMax?: boolean): Promise<void>;

package/lib/events/eventSubscriber.js

@@ -10,6 +10,7 @@ const webSocketLogProvider_1 = require("./webSocketLogProvider");
 const events_1 = require("events");
 const sort_1 = require("./sort");
 const parse_1 = require("./parse");
+const eventsServerLogProvider_1 = require("./eventsServerLogProvider");
 class EventSubscriber {
     constructor(connection, program, options = types_1.DefaultEventSubscriptionOptions) {
         var _a;
@@ -23,15 +24,37 @@ class EventSubscriber {
         this.txEventCache = new txEventCache_1.TxEventCache(this.options.maxTx);
         this.eventListMap = new Map();
         this.eventEmitter = new events_1.EventEmitter();
-        if (this.options.logProviderConfig.type === 'websocket') {
+        this.currentProviderType = this.options.logProviderConfig.type;
+        this.initializeLogProvider();
+    }
+    initializeLogProvider(subscribe = false) {
+        const logProviderConfig = this.options.logProviderConfig;
+        if (this.currentProviderType === 'websocket') {
             this.logProvider = new webSocketLogProvider_1.WebSocketLogProvider(
             // @ts-ignore
             this.connection, this.address, this.options.commitment, this.options.logProviderConfig.resubTimeoutMs);
         }
-        else {
+        else if (this.currentProviderType === 'polling') {
+            const frequency = 'frequency' in logProviderConfig
+                ? logProviderConfig.frequency
+                : logProviderConfig.fallbackFrequency;
+            const batchSize = 'batchSize' in logProviderConfig
+                ? logProviderConfig.batchSize
+                : logProviderConfig.fallbackBatchSize;
             this.logProvider = new pollingLogProvider_1.PollingLogProvider(
             // @ts-ignore
-            this.connection, this.address, options.commitment, this.options.logProviderConfig.frequency, this.options.logProviderConfig.batchSize);
+            this.connection, this.address, this.options.commitment, frequency, batchSize);
+        }
+        else if (this.currentProviderType === 'events-server') {
+            this.logProvider = new eventsServerLogProvider_1.EventsServerLogProvider(logProviderConfig.url, this.options.eventTypes, this.options.address ? this.options.address.toString() : undefined);
+        }
+        else {
+            throw new Error(`Invalid log provider type: ${this.currentProviderType}`);
+        }
+        if (subscribe) {
+            this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime, txSigIndex) => {
+                this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime, this.currentProviderType === 'events-server', txSigIndex);
+            }, true);
         }
     }
     populateInitialEventListMap() {
@@ -39,37 +62,51 @@ class EventSubscriber {
             this.eventListMap.set(eventType, new eventList_1.EventList(eventType, this.options.maxEventsPerType, (0, sort_1.getSortFn)(this.options.orderBy, this.options.orderDir), this.options.orderDir));
         }
     }
+    /**
+     * Implements fallback logic for reconnecting to LogProvider. Currently terminates at polling,
+     * could be improved to try the original type again after some cooldown.
+     */
+    updateFallbackProviderType(reconnectAttempts, maxReconnectAttempts) {
+        if (reconnectAttempts < maxReconnectAttempts) {
+            return;
+        }
+        let nextProviderType = this.currentProviderType;
+        if (this.currentProviderType === 'events-server') {
+            nextProviderType = 'websocket';
+        }
+        else if (this.currentProviderType === 'websocket') {
+            nextProviderType = 'polling';
+        }
+        else if (this.currentProviderType === 'polling') {
+            nextProviderType = 'polling';
+        }
+        console.log(`EventSubscriber: Failing over providerType ${this.currentProviderType} to ${nextProviderType}`);
+        this.currentProviderType = nextProviderType;
+    }
     async subscribe() {
         try {
             if (this.logProvider.isSubscribed()) {
                 return true;
             }
             this.populateInitialEventListMap();
-            if (this.options.logProviderConfig.type === 'websocket') {
-                if (this.options.logProviderConfig.resubTimeoutMs) {
-                    if (this.options.logProviderConfig.maxReconnectAttempts &&
-                        this.options.logProviderConfig.maxReconnectAttempts > 0) {
-                        const logProviderConfig = this.options
-                            .logProviderConfig;
-                        this.logProvider.eventEmitter.on('reconnect', (reconnectAttempts) => {
-                            if (reconnectAttempts > logProviderConfig.maxReconnectAttempts) {
-                                console.log('Failing over to polling');
-                                this.logProvider.eventEmitter.removeAllListeners('reconnect');
-                                this.unsubscribe().then(() => {
-                                    this.logProvider = new pollingLogProvider_1.PollingLogProvider(
-                                    // @ts-ignore
-                                    this.connection, this.address, this.options.commitment, logProviderConfig.fallbackFrequency, logProviderConfig.fallbackBatchSize);
-                                    this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime) => {
-                                        this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime);
-                                    }, true);
-                                });
-                            }
-                        });
-                    }
+            if (this.options.logProviderConfig.type === 'websocket' ||
+                this.options.logProviderConfig.type === 'events-server') {
+                const logProviderConfig = this.options
+                    .logProviderConfig;
+                if (this.logProvider.eventEmitter) {
+                    this.logProvider.eventEmitter.on('reconnect', async (reconnectAttempts) => {
+                        if (reconnectAttempts > logProviderConfig.maxReconnectAttempts) {
+                            console.log(`EventSubscriber: Reconnect attempts ${reconnectAttempts}/${logProviderConfig.maxReconnectAttempts}, reconnecting...`);
+                            this.logProvider.eventEmitter.removeAllListeners('reconnect');
+                            await this.unsubscribe();
+                            this.updateFallbackProviderType(reconnectAttempts, logProviderConfig.maxReconnectAttempts);
+                            this.initializeLogProvider(true);
+                        }
+                    });
                 }
             }
-            this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime) => {
-                this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime);
+            this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime, txSigIndex) => {
+                this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime, this.currentProviderType === 'events-server', txSigIndex);
             }, true);
             return true;
         }
@@ -79,11 +116,11 @@ class EventSubscriber {
             return false;
         }
     }
-    handleTxLogs(txSig, slot, logs, mostRecentBlockTime) {
-        if (this.txEventCache.has(txSig)) {
+    handleTxLogs(txSig, slot, logs, mostRecentBlockTime, fromEventsServer = false, txSigIndex = undefined) {
+        if (!fromEventsServer && this.txEventCache.has(txSig)) {
             return;
         }
-        const wrappedEvents = this.parseEventsFromLogs(txSig, slot, logs);
+        const wrappedEvents = this.parseEventsFromLogs(txSig, slot, logs, txSigIndex);
         for (const wrappedEvent of wrappedEvents) {
             this.eventListMap.get(wrappedEvent.eventType).insert(wrappedEvent);
         }
@@ -134,7 +171,7 @@ class EventSubscriber {
         this.awaitTxResolver.clear();
         return await this.logProvider.unsubscribe(true);
     }
-    parseEventsFromLogs(txSig, slot, logs) {
+    parseEventsFromLogs(txSig, slot, logs, txSigIndex) {
         const records = [];
         // @ts-ignore
         const events = (0, parse_1.parseLogs)(this.program, logs);
@@ -146,7 +183,8 @@ class EventSubscriber {
                 event.data.txSig = txSig;
                 event.data.slot = slot;
                 event.data.eventType = event.name;
-                event.data.txSigIndex = runningEventIndex;
+                event.data.txSigIndex =
+                    txSigIndex !== undefined ? txSigIndex : runningEventIndex;
                 records.push(event.data);
             }
             runningEventIndex++;

package/lib/events/eventsServerLogProvider.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { logProviderCallback, EventType, LogProvider } from './types';
+import { EventEmitter } from 'events';
+export declare class EventsServerLogProvider implements LogProvider {
+    private readonly url;
+    private readonly eventTypes;
+    private readonly userAccount?;
+    private ws?;
+    private callback?;
+    private isUnsubscribing;
+    private externalUnsubscribe;
+    private lastHeartbeat;
+    private timeoutId?;
+    private reconnectAttempts;
+    eventEmitter?: EventEmitter;
+    constructor(url: string, eventTypes: EventType[], userAccount?: string);
+    isSubscribed(): boolean;
+    subscribe(callback: logProviderCallback): Promise<boolean>;
+    unsubscribe(external?: boolean): Promise<boolean>;
+    private setTimeout;
+}

package/lib/events/eventsServerLogProvider.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsServerLogProvider = void 0;
+const events_1 = require("events");
+// browser support
+let WebSocketImpl;
+if (typeof window !== 'undefined' && window.WebSocket) {
+    WebSocketImpl = window.WebSocket;
+}
+else {
+    WebSocketImpl = require('ws');
+}
+const EVENT_SERVER_HEARTBEAT_INTERVAL_MS = 5000;
+const ALLOWED_MISSED_HEARTBEATS = 3;
+class EventsServerLogProvider {
+    constructor(url, eventTypes, userAccount) {
+        this.url = url;
+        this.eventTypes = eventTypes;
+        this.userAccount = userAccount;
+        this.isUnsubscribing = false;
+        this.externalUnsubscribe = false;
+        this.lastHeartbeat = 0;
+        this.reconnectAttempts = 0;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    isSubscribed() {
+        return this.ws !== undefined;
+    }
+    async subscribe(callback) {
+        if (this.ws !== undefined) {
+            return true;
+        }
+        this.ws = new WebSocketImpl(this.url);
+        this.callback = callback;
+        this.ws.addEventListener('open', () => {
+            for (const channel of this.eventTypes) {
+                const subscribeMessage = {
+                    type: 'subscribe',
+                    channel: channel,
+                };
+                if (this.userAccount) {
+                    subscribeMessage['user'] = this.userAccount;
+                }
+                this.ws.send(JSON.stringify(subscribeMessage));
+            }
+            this.reconnectAttempts = 0;
+        });
+        this.ws.addEventListener('message', (data) => {
+            try {
+                if (!this.isUnsubscribing) {
+                    clearTimeout(this.timeoutId);
+                    this.setTimeout();
+                    if (this.reconnectAttempts > 0) {
+                        console.log('eventsServerLogProvider: Resetting reconnect attempts to 0');
+                    }
+                    this.reconnectAttempts = 0;
+                }
+                const parsedData = JSON.parse(data.data.toString());
+                if (parsedData.channel === 'heartbeat') {
+                    this.lastHeartbeat = Date.now();
+                    return;
+                }
+                if (parsedData.message !== undefined) {
+                    return;
+                }
+                const event = JSON.parse(parsedData.data);
+                this.callback(event.txSig, event.slot, [
+                    'Program dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH invoke [1]',
+                    event.rawLog,
+                    'Program dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH success',
+                ], undefined, event.txSigIndex);
+            }
+            catch (error) {
+                console.error('Error parsing message:', error);
+            }
+        });
+        this.ws.addEventListener('close', () => {
+            console.log('eventsServerLogProvider: WebSocket closed');
+        });
+        this.ws.addEventListener('error', (error) => {
+            console.error('eventsServerLogProvider: WebSocket error:', error);
+        });
+        this.setTimeout();
+        return true;
+    }
+    async unsubscribe(external = false) {
+        this.isUnsubscribing = true;
+        this.externalUnsubscribe = external;
+        if (this.timeoutId) {
+            clearInterval(this.timeoutId);
+            this.timeoutId = undefined;
+        }
+        if (this.ws !== undefined) {
+            this.ws.close();
+            this.ws = undefined;
+            return true;
+        }
+        else {
+            this.isUnsubscribing = false;
+            return true;
+        }
+    }
+    setTimeout() {
+        this.timeoutId = setTimeout(async () => {
+            if (this.isUnsubscribing || this.externalUnsubscribe) {
+                // If we are in the process of unsubscribing, do not attempt to resubscribe
+                return;
+            }
+            const timeSinceLastHeartbeat = Date.now() - this.lastHeartbeat;
+            if (timeSinceLastHeartbeat >
+                EVENT_SERVER_HEARTBEAT_INTERVAL_MS * ALLOWED_MISSED_HEARTBEATS) {
+                console.log(`eventServerLogProvider: No heartbeat in ${timeSinceLastHeartbeat}ms, resubscribing on attempt ${this.reconnectAttempts + 1}`);
+                await this.unsubscribe();
+                this.reconnectAttempts++;
+                this.eventEmitter.emit('reconnect', this.reconnectAttempts);
+                this.subscribe(this.callback);
+            }
+        }, EVENT_SERVER_HEARTBEAT_INTERVAL_MS * 2);
+    }
+}
+exports.EventsServerLogProvider = EventsServerLogProvider;

package/lib/events/pollingLogProvider.js

@@ -30,7 +30,7 @@ class PollingLogProvider {
                 this.firstFetch = false;
                 const { mostRecentTx, transactionLogs } = response;
                 for (const { txSig, slot, logs } of transactionLogs) {
-                    callback(txSig, slot, logs, response.mostRecentBlockTime);
+                    callback(txSig, slot, logs, response.mostRecentBlockTime, undefined);
                 }
                 this.mostRecentSeenTx = mostRecentTx;
             }