@drift-labs/sdk 0.2.0-master.0 → 0.2.0-master.11

package/src/clearingHouseUser.ts

@@ -205,7 +205,7 @@ export class ClearingHouseUser {
 	/**
 	 * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
 	 */
-	public getPartialMarginRequirement(): BN {
+	public getMaintenanceMarginRequirement(): BN {
 		return this.getUserAccount()
 			.positions.reduce((marginRequirement, marketPosition) => {
 				const market = this.clearingHouse.getMarketAccount(
@@ -217,7 +217,7 @@ export class ClearingHouseUser {
 						marketPosition,
 						this.getOracleDataForMarket(market.marketIndex)
 					)
-						.mul(new BN(market.marginRatioPartial))
+						.mul(new BN(market.marginRatioMaintenance))
 						.div(MARGIN_PRECISION)
 				);
 			}, ZERO)
@@ -514,9 +514,6 @@ export class ClearingHouseUser {
 			case 'Maintenance':
 				marginRatioCategory = market.marginRatioMaintenance;
 				break;
-			case 'Partial':
-				marginRatioCategory = market.marginRatioPartial;
-				break;
 			default:
 				marginRatioCategory = market.marginRatioInitial;
 				break;
@@ -543,7 +540,8 @@ export class ClearingHouseUser {
 
 	public canBeLiquidated(): [boolean, BN] {
 		const totalCollateral = this.getTotalCollateral();
-		const partialMaintenanceRequirement = this.getPartialMarginRequirement();
+		const partialMaintenanceRequirement =
+			this.getMaintenanceMarginRequirement();
 		const marginRatio = this.getMarginRatio();
 		const canLiquidate = totalCollateral.lt(partialMaintenanceRequirement);
 		return [canLiquidate, marginRatio];
@@ -587,8 +585,7 @@ export class ClearingHouseUser {
 	 */
 	public liquidationPrice(
 		marketPosition: Pick<UserPosition, 'marketIndex'>,
-		positionBaseSizeChange: BN = ZERO,
-		partial = false
+		positionBaseSizeChange: BN = ZERO
 	): BN {
 		// solves formula for example canBeLiquidated below
 
@@ -661,11 +658,7 @@ export class ClearingHouseUser {
 							this.getOracleDataForMarket(market.marketIndex)
 						);
 						const marketMarginRequirement = positionValue
-							.mul(
-								partial
-									? new BN(market.marginRatioPartial)
-									: new BN(market.marginRatioMaintenance)
-							)
+							.mul(new BN(market.marginRatioMaintenance))
 							.div(MARGIN_PRECISION);
 						totalMarginRequirement = totalMarginRequirement.add(
 							marketMarginRequirement
@@ -691,20 +684,17 @@ export class ClearingHouseUser {
 		const marginRequirementAfterTrade =
 			marginRequirementExcludingTargetMarket.add(
 				proposedMarketPositionValue
-					.mul(
-						partial
-							? new BN(market.marginRatioPartial)
-							: new BN(market.marginRatioMaintenance)
-					)
+					.mul(new BN(market.marginRatioMaintenance))
 					.div(MARGIN_PRECISION)
 			);
 		const freeCollateralAfterTrade = totalCollateral.sub(
 			marginRequirementAfterTrade
 		);
 
-		const marketMaxLeverage = partial
-			? this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Partial')
-			: this.getMaxLeverage(proposedMarketPosition.marketIndex, 'Maintenance');
+		const marketMaxLeverage = this.getMaxLeverage(
+			proposedMarketPosition.marketIndex,
+			'Maintenance'
+		);
 
 		let priceDelta;
 		if (proposedBaseAssetAmount.lt(ZERO)) {
@@ -777,8 +767,7 @@ export class ClearingHouseUser {
 			{
 				marketIndex: positionMarketIndex,
 			},
-			closeBaseAmount,
-			true
+			closeBaseAmount
 		);
 	}
 

package/src/config.ts

@@ -28,7 +28,7 @@ export const configs: { [key in DriftEnv]: DriftConfig } = {
 	devnet: {
 		ENV: 'devnet',
 		PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
-		CLEARING_HOUSE_PROGRAM_ID: 'GCuH76fb1rXc7bjFXNcnNvWSekLgzpsnMbc1Ng4FsGSs',
+		CLEARING_HOUSE_PROGRAM_ID: '4oyTJnAQ9FqJj1y9mPytbWsLeeHmBzGYfuFqypwyQvuh',
 		USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
 		MARKETS: DevnetMarkets,
 		BANKS: DevnetBanks,

package/src/constants/banks.ts

@@ -19,11 +19,18 @@ export const DevnetBanks: BankConfig[] = [
 		mint: new PublicKey('8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2'),
 	},
 	{
-		symbol: 'BTC',
+		symbol: 'SOL',
 		bankIndex: new BN(1),
+		oracle: new PublicKey('J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix'),
+		oracleSource: OracleSource.PYTH,
+		mint: new PublicKey('So11111111111111111111111111111111111111112'),
+	},
+	{
+		symbol: 'BTC',
+		bankIndex: new BN(2),
 		oracle: new PublicKey('HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J'),
 		oracleSource: OracleSource.PYTH,
-		mint: new PublicKey('Gh9ZwEmdLJ8DscKNTkTqPbNwLNNBjuSzaG9Vp2KGtKJr'),
+		mint: new PublicKey('3BZPwbcqB5kKScF3TEXxwNfx5ipV13kbRVDvfVp5c6fv'),
 	},
 ];
 

package/src/constants/numericConstants.ts

@@ -28,6 +28,7 @@ export const BANK_BALANCE_PRECISION_EXP = new BN(6);
 export const BANK_BALANCE_PRECISION = new BN(10).pow(
 	BANK_BALANCE_PRECISION_EXP
 );
+export const LIQUIDATION_FEE_PRECISION = new BN(1000000);
 
 export const QUOTE_PRECISION = new BN(10).pow(QUOTE_PRECISION_EXP);
 export const MARK_PRICE_PRECISION = new BN(10).pow(MARK_PRICE_PRECISION_EXP);
@@ -43,6 +44,7 @@ export const BASE_PRECISION_EXP = AMM_RESERVE_PRECISION_EXP;
 
 export const AMM_TO_QUOTE_PRECISION_RATIO =
 	AMM_RESERVE_PRECISION.div(QUOTE_PRECISION); // 10^7
+export const PRICE_DIV_PEG = MARK_PRICE_PRECISION.div(PEG_PRECISION); //10^7
 export const PRICE_TO_QUOTE_PRECISION =
 	MARK_PRICE_PRECISION.div(QUOTE_PRECISION);
 export const AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO =

package/src/events/eventList.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventList = void 0;
+class Node {
+    constructor(event, next, prev) {
+        this.event = event;
+        this.next = next;
+        this.prev = prev;
+    }
+}
+class EventList {
+    constructor(eventType, maxSize, sortFn, orderDirection) {
+        this.eventType = eventType;
+        this.maxSize = maxSize;
+        this.sortFn = sortFn;
+        this.orderDirection = orderDirection;
+        this.size = 0;
+    }
+    insert(event) {
+        this.size++;
+        const newNode = new Node(event);
+        if (this.head === undefined) {
+            this.head = this.tail = newNode;
+            return;
+        }
+        if (this.sortFn(this.head.event, newNode.event) ===
+            (this.orderDirection === 'asc' ? 'less than' : 'greater than')) {
+            this.head.prev = newNode;
+            newNode.next = this.head;
+            this.head = newNode;
+        }
+        else {
+            let currentNode = this.head;
+            while (currentNode.next !== undefined &&
+                this.sortFn(currentNode.next.event, newNode.event) !==
+                    (this.orderDirection === 'asc' ? 'less than' : 'greater than')) {
+                currentNode = currentNode.next;
+            }
+            newNode.next = currentNode.next;
+            if (currentNode.next !== undefined) {
+                newNode.next.prev = newNode;
+            }
+            currentNode.next = newNode;
+            newNode.prev = currentNode;
+        }
+        if (this.size > this.maxSize) {
+            this.detach();
+        }
+    }
+    detach() {
+        const node = this.tail;
+        if (node.prev !== undefined) {
+            node.prev.next = node.next;
+        }
+        else {
+            this.head = node.next;
+        }
+        if (node.next !== undefined) {
+            node.next.prev = node.prev;
+        }
+        else {
+            this.tail = node.prev;
+        }
+        this.size--;
+    }
+    toArray() {
+        return Array.from(this);
+    }
+    *[Symbol.iterator]() {
+        let node = this.head;
+        while (node) {
+            yield node.event;
+            node = node.next;
+        }
+    }
+}
+exports.EventList = EventList;

package/src/events/eventSubscriber.js

@@ -0,0 +1,139 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSubscriber = void 0;
+const types_1 = require("./types");
+const txEventCache_1 = require("./txEventCache");
+const eventList_1 = require("./eventList");
+const pollingLogProvider_1 = require("./pollingLogProvider");
+const fetchLogs_1 = require("./fetchLogs");
+const webSocketLogProvider_1 = require("./webSocketLogProvider");
+const events_1 = require("events");
+const sort_1 = require("./sort");
+class EventSubscriber {
+    constructor(connection, program, options = types_1.DefaultEventSubscriptionOptions) {
+        this.connection = connection;
+        this.program = program;
+        this.options = options;
+        this.awaitTxPromises = new Map();
+        this.awaitTxResolver = new Map();
+        this.options = Object.assign({}, types_1.DefaultEventSubscriptionOptions, options);
+        this.txEventCache = new txEventCache_1.TxEventCache(this.options.maxTx);
+        this.eventListMap = new Map();
+        for (const eventType of this.options.eventTypes) {
+            this.eventListMap.set(eventType, new eventList_1.EventList(eventType, this.options.maxEventsPerType, sort_1.getSortFn(this.options.orderBy, this.options.orderDir, eventType), this.options.orderDir));
+        }
+        this.eventEmitter = new events_1.EventEmitter();
+        if (this.options.logProviderConfig.type === 'websocket') {
+            this.logProvider = new webSocketLogProvider_1.WebSocketLogProvider(this.connection, this.program.programId, this.options.commitment);
+        }
+        else {
+            this.logProvider = new pollingLogProvider_1.PollingLogProvider(this.connection, this.program.programId, options.commitment, this.options.logProviderConfig.frequency);
+        }
+    }
+    subscribe() {
+        if (this.logProvider.isSubscribed()) {
+            return true;
+        }
+        this.fetchPreviousTx().catch((e) => {
+            console.error('Error fetching previous txs in event subscriber');
+            console.error(e);
+        });
+        return this.logProvider.subscribe((txSig, slot, logs) => {
+            this.handleTxLogs(txSig, slot, logs);
+        });
+    }
+    handleTxLogs(txSig, slot, logs) {
+        if (this.txEventCache.has(txSig)) {
+            return;
+        }
+        const wrappedEvents = this.parseEventsFromLogs(txSig, slot, logs);
+        for (const wrappedEvent of wrappedEvents) {
+            this.eventListMap.get(wrappedEvent.eventType).insert(wrappedEvent);
+            this.eventEmitter.emit('newEvent', wrappedEvent);
+        }
+        if (this.awaitTxPromises.has(txSig)) {
+            this.awaitTxPromises.delete(txSig);
+            this.awaitTxResolver.get(txSig)();
+            this.awaitTxResolver.delete(txSig);
+        }
+        this.txEventCache.add(txSig, wrappedEvents);
+    }
+    fetchPreviousTx() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.options.untilTx) {
+                return;
+            }
+            let txFetched = 0;
+            let beforeTx = undefined;
+            const untilTx = this.options.untilTx;
+            while (txFetched < this.options.maxTx) {
+                const response = yield fetchLogs_1.fetchLogs(this.connection, this.program.programId, this.options.commitment === 'finalized' ? 'finalized' : 'confirmed', beforeTx, untilTx);
+                if (response === undefined) {
+                    break;
+                }
+                txFetched += response.transactionLogs.length;
+                beforeTx = response.earliestTx;
+                for (const { txSig, slot, logs } of response.transactionLogs) {
+                    this.handleTxLogs(txSig, slot, logs);
+                }
+            }
+        });
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.logProvider.unsubscribe();
+        });
+    }
+    parseEventsFromLogs(txSig, slot, logs) {
+        const records = [];
+        // @ts-ignore
+        this.program._events._eventParser.parseLogs(logs, (event) => {
+            const expectRecordType = this.eventListMap.has(event.name);
+            if (expectRecordType) {
+                event.data.txSig = txSig;
+                event.data.slot = slot;
+                event.data.eventType = event.name;
+                records.push(event.data);
+            }
+        });
+        return records;
+    }
+    awaitTx(txSig) {
+        if (this.awaitTxPromises.has(txSig)) {
+            return this.awaitTxPromises.get(txSig);
+        }
+        if (this.txEventCache.has(txSig)) {
+            return Promise.resolve();
+        }
+        const promise = new Promise((resolve) => {
+            this.awaitTxResolver.set(txSig, resolve);
+        });
+        this.awaitTxPromises.set(txSig, promise);
+        return promise;
+    }
+    getEventList(eventType) {
+        return this.eventListMap.get(eventType);
+    }
+    /**
+     * This requires the EventList be cast to an array, which requires reallocation of memory.
+     * Would bias to using getEventList over getEvents
+     *
+     * @param eventType
+     */
+    getEventsArray(eventType) {
+        return this.eventListMap.get(eventType).toArray();
+    }
+    getEventsByTx(txSig) {
+        return this.txEventCache.get(txSig);
+    }
+}
+exports.EventSubscriber = EventSubscriber;

package/src/events/fetchLogs.js

@@ -0,0 +1,50 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchLogs = void 0;
+function fetchLogs(connection, programId, finality, beforeTx, untilTx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const signatures = yield connection.getSignaturesForAddress(programId, {
+            before: beforeTx,
+            until: untilTx,
+        }, finality);
+        const sortedSignatures = signatures.sort((a, b) => a.slot < b.slot ? -1 : 1);
+        const filteredSignatures = sortedSignatures.filter((signature) => !signature.err);
+        if (filteredSignatures.length === 0) {
+            return undefined;
+        }
+        const chunkedSignatures = chunk(filteredSignatures, 100);
+        const transactionLogs = (yield Promise.all(chunkedSignatures.map((chunk) => __awaiter(this, void 0, void 0, function* () {
+            const transactions = yield connection.getTransactions(chunk.map((confirmedSignature) => confirmedSignature.signature), finality);
+            return transactions.map((transaction) => {
+                return {
+                    txSig: transaction.transaction.signatures[0],
+                    slot: transaction.slot,
+                    logs: transaction.meta.logMessages,
+                };
+            });
+        })))).flat();
+        const earliestTx = filteredSignatures[0].signature;
+        const mostRecentTx = filteredSignatures[filteredSignatures.length - 1].signature;
+        return {
+            transactionLogs: transactionLogs,
+            earliestTx: earliestTx,
+            mostRecentTx: mostRecentTx,
+        };
+    });
+}
+exports.fetchLogs = fetchLogs;
+function chunk(array, size) {
+    return new Array(Math.ceil(array.length / size))
+        .fill(null)
+        .map((_, index) => index * size)
+        .map((begin) => array.slice(begin, begin + size));
+}

package/src/events/pollingLogProvider.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingLogProvider = void 0;
+const fetchLogs_1 = require("./fetchLogs");
+class PollingLogProvider {
+    constructor(connection, programId, commitment, frequency = 15 * 1000) {
+        this.connection = connection;
+        this.programId = programId;
+        this.frequency = frequency;
+        this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
+    }
+    subscribe(callback) {
+        if (this.intervalId) {
+            return true;
+        }
+        this.intervalId = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            if (this.mutex === 1) {
+                return;
+            }
+            this.mutex = 1;
+            try {
+                const response = yield fetchLogs_1.fetchLogs(this.connection, this.programId, this.finality, undefined, this.mostRecentSeenTx);
+                if (response === undefined) {
+                    return;
+                }
+                const { mostRecentTx, transactionLogs } = response;
+                for (const { txSig, slot, logs } of transactionLogs) {
+                    callback(txSig, slot, logs);
+                }
+                this.mostRecentSeenTx = mostRecentTx;
+            }
+            catch (e) {
+                console.error('PollingLogProvider threw an Error');
+                console.error(e);
+            }
+            finally {
+                this.mutex = 0;
+            }
+        }), this.frequency);
+        return true;
+    }
+    isSubscribed() {
+        return this.intervalId !== undefined;
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.intervalId !== undefined) {
+                clearInterval(this.intervalId);
+                this.intervalId = undefined;
+            }
+            return true;
+        });
+    }
+}
+exports.PollingLogProvider = PollingLogProvider;

package/src/events/sort.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSortFn = void 0;
+const index_1 = require("../index");
+function clientSortAscFn() {
+    return 'less than';
+}
+function clientSortDescFn() {
+    return 'greater than';
+}
+function defaultBlockchainSortFn(currentEvent, newEvent) {
+    return currentEvent.slot <= newEvent.slot ? 'less than' : 'greater than';
+}
+function orderRecordSortFn(currentEvent, newEvent) {
+    const currentEventMarketIndex = !currentEvent.maker.equals(index_1.PublicKey.default)
+        ? currentEvent.makerOrder.marketIndex
+        : currentEvent.takerOrder.marketIndex;
+    const newEventMarketIndex = !newEvent.maker.equals(index_1.PublicKey.default)
+        ? newEvent.makerOrder.marketIndex
+        : newEvent.takerOrder.marketIndex;
+    if (!currentEventMarketIndex.eq(newEventMarketIndex)) {
+        return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
+    }
+    if (currentEvent.fillRecordId.gt(index_1.ZERO) && newEvent.fillRecordId.gt(index_1.ZERO)) {
+        return currentEvent.fillRecordId.lte(newEvent.fillRecordId)
+            ? 'less than'
+            : 'greater than';
+    }
+    else {
+        return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
+    }
+}
+function getSortFn(orderBy, orderDir, eventType) {
+    if (orderBy === 'client') {
+        return orderDir === 'asc' ? clientSortAscFn : clientSortDescFn;
+    }
+    switch (eventType) {
+        case 'OrderRecord':
+            return orderRecordSortFn;
+        default:
+            return defaultBlockchainSortFn;
+    }
+}
+exports.getSortFn = getSortFn;

package/src/events/txEventCache.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxEventCache = void 0;
+class Node {
+    constructor(key, value, next, prev) {
+        this.key = key;
+        this.value = value;
+        this.next = next;
+        this.prev = prev;
+    }
+}
+// lru cache
+class TxEventCache {
+    constructor(maxTx = 1024) {
+        this.maxTx = maxTx;
+        this.size = 0;
+        this.cacheMap = {};
+    }
+    add(key, events) {
+        const existingNode = this.cacheMap[key];
+        if (existingNode) {
+            this.detach(existingNode);
+            this.size--;
+        }
+        else if (this.size === this.maxTx) {
+            delete this.cacheMap[this.tail.key];
+            this.detach(this.tail);
+            this.size--;
+        }
+        // Write to head of LinkedList
+        if (!this.head) {
+            this.head = this.tail = new Node(key, events);
+        }
+        else {
+            const node = new Node(key, events, this.head);
+            this.head.prev = node;
+            this.head = node;
+        }
+        // update cacheMap with LinkedList key and Node reference
+        this.cacheMap[key] = this.head;
+        this.size++;
+    }
+    has(key) {
+        return this.cacheMap.hasOwnProperty(key);
+    }
+    get(key) {
+        var _a;
+        return (_a = this.cacheMap[key]) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    detach(node) {
+        if (node.prev !== undefined) {
+            node.prev.next = node.next;
+        }
+        else {
+            this.head = node.next;
+        }
+        if (node.next !== undefined) {
+            node.next.prev = node.prev;
+        }
+        else {
+            this.tail = node.prev;
+        }
+    }
+    clear() {
+        this.head = undefined;
+        this.tail = undefined;
+        this.size = 0;
+        this.cacheMap = {};
+    }
+}
+exports.TxEventCache = TxEventCache;

package/src/events/types.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultEventSubscriptionOptions = void 0;
+exports.DefaultEventSubscriptionOptions = {
+    eventTypes: [
+        'DepositRecord',
+        'FundingPaymentRecord',
+        'LiquidationRecord',
+        'OrderRecord',
+        'FundingRateRecord',
+    ],
+    maxEventsPerType: 4096,
+    orderBy: 'blockchain',
+    orderDir: 'asc',
+    commitment: 'confirmed',
+    maxTx: 4096,
+    logProviderConfig: {
+        type: 'websocket',
+    },
+};

package/src/events/webSocketLogProvider.js

@@ -0,0 +1,41 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketLogProvider = void 0;
+class WebSocketLogProvider {
+    constructor(connection, programId, commitment) {
+        this.connection = connection;
+        this.programId = programId;
+        this.commitment = commitment;
+    }
+    subscribe(callback) {
+        if (this.subscriptionId) {
+            return true;
+        }
+        this.subscriptionId = this.connection.onLogs(this.programId, (logs, ctx) => {
+            callback(logs.signature, ctx.slot, logs.logs);
+        }, this.commitment);
+        return true;
+    }
+    isSubscribed() {
+        return this.subscriptionId !== undefined;
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.subscriptionId !== undefined) {
+                yield this.connection.removeOnLogsListener(this.subscriptionId);
+                this.subscriptionId = undefined;
+            }
+            return true;
+        });
+    }
+}
+exports.WebSocketLogProvider = WebSocketLogProvider;