@drift-labs/sdk 2.31.0-beta.2 → 2.31.0-beta.5

package/lib/orderSubscriber/OrderSubscriber.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderSubscriber = void 0;
+const memcmp_1 = require("../memcmp");
+const web3_js_1 = require("@solana/web3.js");
+const buffer_1 = require("buffer");
+const DLOB_1 = require("../dlob/DLOB");
+const PollingSubscription_1 = require("./PollingSubscription");
+const WebsocketSubscription_1 = require("./WebsocketSubscription");
+class OrderSubscriber {
+    constructor(config) {
+        this.usersAccounts = new Map();
+        this.driftClient = config.driftClient;
+        if (config.subscriptionConfig.type === 'polling') {
+            this.subscription = new PollingSubscription_1.PollingSubscription({
+                orderSubscriber: this,
+                frequency: config.subscriptionConfig.frequency,
+            });
+        }
+        else {
+            this.subscription = new WebsocketSubscription_1.WebsocketSubscription({
+                orderSubscriber: this,
+                skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
+            });
+        }
+    }
+    async subscribe() {
+        await this.subscription.subscribe();
+    }
+    async fetch() {
+        if (this.fetchPromise) {
+            return this.fetchPromise;
+        }
+        this.fetchPromise = new Promise((resolver) => {
+            this.fetchPromiseResolver = resolver;
+        });
+        try {
+            const rpcRequestArgs = [
+                this.driftClient.program.programId.toBase58(),
+                {
+                    commitment: this.driftClient.opts.commitment,
+                    filters: [(0, memcmp_1.getUserFilter)(), (0, memcmp_1.getUserWithOrderFilter)()],
+                    encoding: 'base64',
+                    withContext: true,
+                },
+            ];
+            const rpcJSONResponse = 
+            // @ts-ignore
+            await this.driftClient.connection._rpcRequest('getProgramAccounts', rpcRequestArgs);
+            const rpcResponseAndContext = rpcJSONResponse.result;
+            const slot = rpcResponseAndContext.context.slot;
+            const programAccountSet = new Set();
+            for (const programAccount of rpcResponseAndContext.value) {
+                const key = programAccount.pubkey.toString();
+                // @ts-ignore
+                const buffer = buffer_1.Buffer.from(programAccount.account.data[0], programAccount.account.data[1]);
+                programAccountSet.add(key);
+                this.tryUpdateUserAccount(key, buffer, slot);
+            }
+            for (const key of this.usersAccounts.keys()) {
+                if (!programAccountSet.has(key)) {
+                    this.usersAccounts.delete(key);
+                }
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        finally {
+            this.fetchPromiseResolver();
+            this.fetchPromise = undefined;
+        }
+    }
+    tryUpdateUserAccount(key, buffer, slot) {
+        const slotAndUserAccount = this.usersAccounts.get(key);
+        if (!slotAndUserAccount || slotAndUserAccount.slot < slot) {
+            const userAccount = this.driftClient.program.account.user.coder.accounts.decode('User', buffer);
+            if (userAccount.hasOpenOrder) {
+                this.usersAccounts.set(key, { slot, userAccount });
+            }
+            else {
+                this.usersAccounts.delete(key);
+            }
+        }
+    }
+    async getDLOB(slot) {
+        const dlob = new DLOB_1.DLOB();
+        for (const [key, { userAccount }] of this.usersAccounts.entries()) {
+            const userAccountPubkey = new web3_js_1.PublicKey(key);
+            for (const order of userAccount.orders) {
+                dlob.insertOrder(order, userAccountPubkey, slot);
+            }
+        }
+        return dlob;
+    }
+    async unsubscribe() {
+        await this.subscription.unsubscribe();
+    }
+}
+exports.OrderSubscriber = OrderSubscriber;

package/lib/orderSubscriber/PollingSubscription.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { OrderSubscriber } from './OrderSubscriber';
+export declare class PollingSubscription {
+    private orderSubscriber;
+    private frequency;
+    intervalId?: NodeJS.Timer;
+    constructor({ orderSubscriber, frequency, }: {
+        orderSubscriber: OrderSubscriber;
+        frequency: number;
+    });
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/orderSubscriber/PollingSubscription.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingSubscription = void 0;
+class PollingSubscription {
+    constructor({ orderSubscriber, frequency, }) {
+        this.orderSubscriber = orderSubscriber;
+        this.frequency = frequency;
+    }
+    async subscribe() {
+        if (this.intervalId) {
+            return;
+        }
+        this.intervalId = setInterval(this.orderSubscriber.fetch.bind(this.orderSubscriber), this.frequency);
+        await this.orderSubscriber.fetch();
+    }
+    async unsubscribe() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+}
+exports.PollingSubscription = PollingSubscription;

package/lib/orderSubscriber/WebsocketSubscription.d.ts

@@ -0,0 +1,12 @@
+import { OrderSubscriber } from './OrderSubscriber';
+export declare class WebsocketSubscription {
+    private orderSubscriber;
+    private skipInitialLoad;
+    private websocketId;
+    constructor({ orderSubscriber, skipInitialLoad, }: {
+        orderSubscriber: OrderSubscriber;
+        skipInitialLoad?: boolean;
+    });
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/orderSubscriber/WebsocketSubscription.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebsocketSubscription = void 0;
+const memcmp_1 = require("../memcmp");
+class WebsocketSubscription {
+    constructor({ orderSubscriber, skipInitialLoad = false, }) {
+        this.orderSubscriber = orderSubscriber;
+        this.skipInitialLoad = skipInitialLoad;
+    }
+    async subscribe() {
+        if (this.websocketId) {
+            return;
+        }
+        this.websocketId =
+            this.orderSubscriber.driftClient.connection.onProgramAccountChange(this.orderSubscriber.driftClient.program.programId, (keyAccountInfo, context) => {
+                const userKey = keyAccountInfo.accountId.toBase58();
+                this.orderSubscriber.tryUpdateUserAccount(userKey, keyAccountInfo.accountInfo.data, context.slot);
+            }, this.orderSubscriber.driftClient.opts.commitment, [(0, memcmp_1.getUserFilter)(), (0, memcmp_1.getNonIdleUserFilter)()]);
+        if (!this.skipInitialLoad) {
+            await this.orderSubscriber.fetch();
+        }
+    }
+    async unsubscribe() {
+        if (this.websocketId) {
+            await this.orderSubscriber.driftClient.connection.removeProgramAccountChangeListener(this.websocketId);
+            this.websocketId = undefined;
+        }
+    }
+}
+exports.WebsocketSubscription = WebsocketSubscription;

package/lib/orderSubscriber/index.d.ts

@@ -0,0 +1,2 @@
+export * from './OrderSubscriber';
+export * from './types';

package/lib/orderSubscriber/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./OrderSubscriber"), exports);
+__exportStar(require("./types"), exports);

package/lib/orderSubscriber/types.d.ts

@@ -0,0 +1,11 @@
+import { DriftClient } from '../driftClient';
+export type OrderSubscriberConfig = {
+    driftClient: DriftClient;
+    subscriptionConfig: {
+        type: 'polling';
+        frequency: number;
+    } | {
+        type: 'websocket';
+        skipInitialLoad?: boolean;
+    };
+};

package/lib/orderSubscriber/types.js

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

package/lib/tx/retryTxSender.js

@@ -55,12 +55,15 @@ class RetryTxSender {
         return tx;
     }
     async sendVersionedTransaction(tx, additionalSigners, opts) {
+        additionalSigners === null || additionalSigners === void 0 ? void 0 : additionalSigners.filter((s) => s !== undefined).forEach((kp) => {
+            tx.sign([kp]);
+        });
         // @ts-ignore
-        tx.sign((additionalSigners !== null && additionalSigners !== void 0 ? additionalSigners : []).concat(this.provider.wallet.payer));
+        const signedTx = await this.provider.wallet.signTransaction(tx);
         if (opts === undefined) {
             opts = this.provider.opts;
         }
-        return this.sendRawTransaction(tx.serialize(), opts);
+        return this.sendRawTransaction(signedTx.serialize(), opts);
     }
     async sendRawTransaction(rawTransaction, opts) {
         const startTime = this.getTimestamp();

package/lib/types.d.ts

@@ -222,7 +222,7 @@ export declare class OrderActionExplanation {
         orderFilledWithAmmJitLpSplit: {};
     };
     static readonly ORDER_FILLED_WITH_LP_JIT: {
-        orderFilledWithAmmJitLpSplit: {};
+        orderFilledWithLpJit: {};
     };
     static readonly ORDER_FILLED_WITH_MATCH: {
         orderFilledWithMatch: {};
@@ -877,6 +877,10 @@ export type UserAccount = {
     lastActiveSlot: BN;
     isMarginTradingEnabled: boolean;
     idle: boolean;
+    openOrders: number;
+    hasOpenOrder: boolean;
+    openAuctions: number;
+    hasOpenAuction: boolean;
 };
 export type SpotPosition = {
     marketIndex: number;

package/lib/types.js

@@ -138,7 +138,7 @@ OrderActionExplanation.ORDER_FILLED_WITH_AMM_JIT_LP_SPLIT = {
     orderFilledWithAmmJitLpSplit: {},
 };
 OrderActionExplanation.ORDER_FILLED_WITH_LP_JIT = {
-    orderFilledWithAmmJitLpSplit: {},
+    orderFilledWithLpJit: {},
 };
 OrderActionExplanation.ORDER_FILLED_WITH_MATCH = {
     orderFilledWithMatch: {},

package/lib/userMap/userMap.js

@@ -1,13 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserMap = void 0;
 const __1 = require("..");
 const web3_js_1 = require("@solana/web3.js");
 const buffer_1 = require("buffer");
-const bs58_1 = __importDefault(require("bs58"));
+const memcmp_1 = require("../memcmp");
 class UserMap {
     /**
      *
@@ -143,27 +140,15 @@ class UserMap {
         return this.userMap.size;
     }
     async sync() {
-        let filters = undefined;
+        const filters = [(0, memcmp_1.getUserFilter)()];
         if (!this.includeIdle) {
-            filters = [
-                {
-                    memcmp: {
-                        offset: 4350,
-                        bytes: bs58_1.default.encode(Uint8Array.from([0])),
-                    },
-                },
-            ];
+            filters.push((0, memcmp_1.getNonIdleUserFilter)());
         }
         const rpcRequestArgs = [
             this.driftClient.program.programId.toBase58(),
             {
                 commitment: this.driftClient.connection.commitment,
-                filters: [
-                    {
-                        memcmp: this.driftClient.program.coder.accounts.memcmp('User'),
-                    },
-                    ...(Array.isArray(filters) ? filters : []),
-                ],
+                filters,
                 encoding: 'base64',
                 withContext: true,
             },

package/package.json

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

package/src/auctionSubscriber/auctionSubscriber.ts

@@ -0,0 +1,50 @@
+import { AuctionSubscriberConfig, AuctionSubscriberEvents } from './types';
+import { DriftClient } from '../driftClient';
+import { getUserFilter, getUserWithAuctionFilter } from '../memcmp';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { UserAccount } from '../types';
+import { ConfirmOptions } from '@solana/web3.js';
+
+export class AuctionSubscriber {
+	private driftClient: DriftClient;
+	private opts: ConfirmOptions;
+
+	eventEmitter: StrictEventEmitter<EventEmitter, AuctionSubscriberEvents>;
+
+	private websocketId: number;
+
+	constructor({ driftClient, opts }: AuctionSubscriberConfig) {
+		this.driftClient = driftClient;
+		this.opts = opts || this.driftClient.opts;
+	}
+
+	public async subscribe() {
+		this.websocketId = this.driftClient.connection.onProgramAccountChange(
+			this.driftClient.program.programId,
+			(keyAccountInfo, context) => {
+				const userAccount =
+					this.driftClient.program.account.user.coder.accounts.decode(
+						'User',
+						keyAccountInfo.accountInfo.data
+					) as UserAccount;
+				this.eventEmitter.emit(
+					'onAccountUpdate',
+					userAccount,
+					keyAccountInfo.accountId,
+					context.slot
+				);
+			},
+			this.driftClient.opts.commitment,
+			[getUserFilter(), getUserWithAuctionFilter()]
+		);
+	}
+
+	public async unsubscribe() {
+		if (this.websocketId) {
+			await this.driftClient.connection.removeProgramAccountChangeListener(
+				this.websocketId
+			);
+		}
+	}
+}

package/src/auctionSubscriber/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './auctionSubscriber';

package/src/auctionSubscriber/types.ts

@@ -0,0 +1,16 @@
+import { DriftClient } from '../driftClient';
+import { UserAccount } from '../types';
+import { ConfirmOptions, PublicKey } from '@solana/web3.js';
+
+export type AuctionSubscriberConfig = {
+	driftClient: DriftClient;
+	opts?: ConfirmOptions;
+};
+
+export interface AuctionSubscriberEvents {
+	onAccountUpdate: (
+		account: UserAccount,
+		pubkey: PublicKey,
+		slot: number
+	) => void;
+}

package/src/config.ts

@@ -1,3 +1,4 @@
+import { PerpMarketAccount, SpotMarketAccount } from '.';
 import {
 	DevnetPerpMarkets,
 	MainnetPerpMarkets,
@@ -11,7 +12,7 @@ import {
 	MainnetSpotMarkets,
 } from './constants/spotMarkets';
 import { OracleInfo } from './oracles/types';
-import { Program } from '@coral-xyz/anchor';
+import { Program, ProgramAccount } from '@coral-xyz/anchor';
 
 type DriftConfig = {
 	ENV: DriftEnv;
@@ -124,8 +125,10 @@ export async function findAllMarketAndOracles(program: Program): Promise<{
 	const spotMarketIndexes = [];
 	const oracleInfos = new Map<string, OracleInfo>();
 
-	const perpMarketProgramAccounts = await program.account.perpMarket.all();
-	const spotMarketProgramAccounts = await program.account.spotMarket.all();
+	const perpMarketProgramAccounts =
+		(await program.account.perpMarket.all()) as ProgramAccount<PerpMarketAccount>[];
+	const spotMarketProgramAccounts =
+		(await program.account.spotMarket.all()) as ProgramAccount<SpotMarketAccount>[];
 
 	for (const perpMarketProgramAccount of perpMarketProgramAccounts) {
 		const perpMarket = perpMarketProgramAccount.account;

package/src/dlob/orderBookLevels.ts

@@ -244,17 +244,22 @@ export function getVammL2Generator({
 	};
 }
 
-export function groupL2(l2: L2OrderBook, grouping: BN): L2OrderBook {
+export function groupL2(
+	l2: L2OrderBook,
+	grouping: BN,
+	depth: number
+): L2OrderBook {
 	return {
-		bids: groupL2Levels(l2.bids, grouping, PositionDirection.LONG),
-		asks: groupL2Levels(l2.asks, grouping, PositionDirection.SHORT),
+		bids: groupL2Levels(l2.bids, grouping, PositionDirection.LONG, depth),
+		asks: groupL2Levels(l2.asks, grouping, PositionDirection.SHORT, depth),
 	};
 }
 
 function groupL2Levels(
 	levels: L2Level[],
 	grouping: BN,
-	direction: PositionDirection
+	direction: PositionDirection,
+	depth: number
 ): L2Level[] {
 	const groupedLevels = [];
 	for (const level of levels) {
@@ -281,6 +286,10 @@ function groupL2Levels(
 			};
 			groupedLevels.push(groupedLevel);
 		}
+
+		if (groupedLevels.length === depth) {
+			break;
+		}
 	}
 	return groupedLevels;
 }

package/src/driftClient.ts

@@ -114,6 +114,7 @@ import { calculateMarketMaxAvailableInsurance } from './math/market';
 import { fetchUserStatsAccount } from './accounts/fetch';
 import { castNumberToSpotPrecision } from './math/spotMarket';
 import { JupiterClient, Route, SwapMode } from './jupiter/jupiterClient';
+import { getNonIdleUserFilter } from './memcmp';
 
 type RemainingAccountParams = {
 	userAccounts: UserAccount[];
@@ -897,14 +898,7 @@ export class DriftClient {
 	): Promise<ProgramAccount<UserAccount>[]> {
 		let filters = undefined;
 		if (!includeIdle) {
-			filters = [
-				{
-					memcmp: {
-						offset: 4350,
-						bytes: bs58.encode(Uint8Array.from([0])),
-					},
-				},
-			];
+			filters = [getNonIdleUserFilter()];
 		}
 		return (await this.program.account.user.all(
 			filters
@@ -3395,12 +3389,12 @@ export class DriftClient {
 			endSwapIx,
 		];
 
-		const tx = await this.buildTransaction(
+		const tx = (await this.buildTransaction(
 			instructions,
 			txParams,
 			0,
 			lookupTables
-		);
+		)) as VersionedTransaction;
 
 		const { txSig, slot } = await this.sendTransaction(tx);
 		this.spotMarketLastSlotCache.set(outMarketIndex, slot);
@@ -3625,6 +3619,43 @@ export class DriftClient {
 		});
 	}
 
+	public async updateUserOpenOrdersCount(
+		userAccountPublicKey: PublicKey,
+		user: UserAccount,
+		txParams?: TxParams
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.sendTransaction(
+			await this.buildTransaction(
+				await this.getUpdateUserOpenOrdersCountIx(userAccountPublicKey, user),
+				txParams
+			),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getUpdateUserOpenOrdersCountIx(
+		userAccountPublicKey: PublicKey,
+		userAccount: UserAccount
+	): Promise<TransactionInstruction> {
+		const fillerPublicKey = await this.getUserAccountPublicKey();
+
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [userAccount],
+		});
+
+		return await this.program.instruction.updateUserOpenOrdersCount({
+			accounts: {
+				state: await this.getStatePublicKey(),
+				filler: fillerPublicKey,
+				user: userAccountPublicKey,
+				authority: this.wallet.publicKey,
+			},
+			remainingAccounts,
+		});
+	}
+
 	public async placeAndTakePerpOrder(
 		orderParams: OptionalOrderParams,
 		makerInfo?: MakerInfo | MakerInfo[],

package/src/events/eventSubscriber.ts

@@ -1,4 +1,4 @@
-import { Connection, TransactionSignature } from '@solana/web3.js';
+import { Connection, PublicKey, TransactionSignature } from '@solana/web3.js';
 import { Program } from '@coral-xyz/anchor';
 import {
 	DefaultEventSubscriptionOptions,
@@ -19,6 +19,7 @@ import StrictEventEmitter from 'strict-event-emitter-types';
 import { getSortFn } from './sort';
 
 export class EventSubscriber {
+	private address: PublicKey;
 	private eventListMap: Map<EventType, EventList<EventType>>;
 	private txEventCache: TxEventCache;
 	private awaitTxPromises = new Map<string, Promise<void>>();
@@ -35,6 +36,7 @@ export class EventSubscriber {
 		private options: EventSubscriptionOptions = DefaultEventSubscriptionOptions
 	) {
 		this.options = Object.assign({}, DefaultEventSubscriptionOptions, options);
+		this.address = this.options.address ?? program.programId;
 		this.txEventCache = new TxEventCache(this.options.maxTx);
 		this.eventListMap = new Map<EventType, EventList<EventType>>();
 		for (const eventType of this.options.eventTypes) {
@@ -52,13 +54,13 @@ export class EventSubscriber {
 		if (this.options.logProviderConfig.type === 'websocket') {
 			this.logProvider = new WebSocketLogProvider(
 				this.connection,
-				this.program.programId,
+				this.address,
 				this.options.commitment
 			);
 		} else {
 			this.logProvider = new PollingLogProvider(
 				this.connection,
-				this.program.programId,
+				this.address,
 				options.commitment,
 				this.options.logProviderConfig.frequency
 			);
@@ -134,7 +136,7 @@ export class EventSubscriber {
 		while (txFetched < this.options.maxTx) {
 			const response = await fetchLogs(
 				this.connection,
-				this.program.programId,
+				this.address,
 				this.options.commitment === 'finalized' ? 'finalized' : 'confirmed',
 				beforeTx,
 				untilTx

package/src/events/fetchLogs.ts

@@ -31,14 +31,14 @@ function mapTransactionResponseToLog(
 
 export async function fetchLogs(
 	connection: Connection,
-	programId: PublicKey,
+	address: PublicKey,
 	finality: Finality,
 	beforeTx?: TransactionSignature,
 	untilTx?: TransactionSignature,
 	limit?: number
 ): Promise<FetchLogsResponse> {
 	const signatures = await connection.getSignaturesForAddress(
-		programId,
+		address,
 		{
 			before: beforeTx,
 			until: untilTx,

package/src/events/pollingLogProvider.ts

@@ -17,7 +17,7 @@ export class PollingLogProvider implements LogProvider {
 
 	public constructor(
 		private connection: Connection,
-		private programId: PublicKey,
+		private address: PublicKey,
 		commitment: Commitment,
 		private frequency = 15 * 1000
 	) {
@@ -41,7 +41,7 @@ export class PollingLogProvider implements LogProvider {
 			try {
 				const response = await fetchLogs(
 					this.connection,
-					this.programId,
+					this.address,
 					this.finality,
 					undefined,
 					this.mostRecentSeenTx,

package/src/events/types.ts

@@ -1,4 +1,4 @@
-import { Commitment, TransactionSignature } from '@solana/web3.js';
+import { Commitment, PublicKey, TransactionSignature } from '@solana/web3.js';
 import {
 	DepositRecord,
 	FundingPaymentRecord,
@@ -17,6 +17,7 @@ import {
 } from '../index';
 
 export type EventSubscriptionOptions = {
+	address?: PublicKey;
 	eventTypes?: EventType[];
 	maxEventsPerType?: number;
 	orderBy?: EventSubscriptionOrderBy;

package/src/events/webSocketLogProvider.ts

@@ -5,7 +5,7 @@ export class WebSocketLogProvider implements LogProvider {
 	private subscriptionId: number;
 	public constructor(
 		private connection: Connection,
-		private programId: PublicKey,
+		private address: PublicKey,
 		private commitment: Commitment
 	) {}
 
@@ -15,7 +15,7 @@ export class WebSocketLogProvider implements LogProvider {
 		}
 
 		this.subscriptionId = this.connection.onLogs(
-			this.programId,
+			this.address,
 			(logs, ctx) => {
 				callback(logs.signature, ctx.slot, logs.logs, undefined);
 			},