@drift-labs/sdk 0.2.0-master.20 → 0.2.0-master.23

package/src/index.ts

@@ -41,6 +41,7 @@ export * from './math/trade';
 export * from './math/orders';
 export * from './math/repeg';
 export * from './math/margin';
+export * from './math/insurance';
 export * from './orderParams';
 export * from './slot/SlotSubscriber';
 export * from './wallet';

package/src/math/amm.ts

@@ -635,12 +635,12 @@ export function calculateMaxBaseAssetAmountFillable(
 	if (isVariant(orderDirection, 'long')) {
 		maxBaseAssetAmountOnSide = BN.max(
 			ZERO,
-			amm.maxBaseAssetReserve.sub(amm.baseAssetReserve)
+			amm.baseAssetReserve.sub(amm.minBaseAssetReserve)
 		);
 	} else {
 		maxBaseAssetAmountOnSide = BN.max(
 			ZERO,
-			amm.baseAssetReserve.sub(amm.minBaseAssetReserve)
+			amm.maxBaseAssetReserve.sub(amm.baseAssetReserve)
 		);
 	}
 

package/src/math/insurance.ts

@@ -0,0 +1,35 @@
+import { ONE, ZERO } from '../constants/numericConstants';
+import { BN } from '../index';
+
+export function stakeAmountToShares(
+	amount: BN,
+	totalIfShares: BN,
+	insuranceFundVaultBalance: BN
+): BN {
+	let nShares: BN;
+	if (insuranceFundVaultBalance.gt(ZERO)) {
+		nShares = amount.mul(totalIfShares).div(insuranceFundVaultBalance);
+	} else {
+		nShares = amount;
+	}
+
+	return nShares;
+}
+
+export function unstakeSharesToAmount(
+	nShares: BN,
+	totalIfShares: BN,
+	insuranceFundVaultBalance: BN
+): BN {
+	let amount: BN;
+	if (totalIfShares.gt(ZERO)) {
+		amount = BN.max(
+			ZERO,
+			nShares.mul(insuranceFundVaultBalance).div(totalIfShares).sub(ONE)
+		);
+	} else {
+		amount = ZERO;
+	}
+
+	return amount;
+}

package/src/math/margin.ts

@@ -92,22 +92,15 @@ export function calculateOraclePriceForPerpMargin(
 	return marginPrice;
 }
 
-export function calculateMarginBaseAssetValue(
+export function calculateBaseAssetValueWithOracle(
 	market: MarketAccount,
 	marketPosition: UserPosition,
 	oraclePriceData: OraclePriceData
 ): BN {
-	const marginPrice = calculateOraclePriceForPerpMargin(
-		marketPosition,
-		market,
-		oraclePriceData
-	);
-	const baseAssetValue = marketPosition.baseAssetAmount
+	return marketPosition.baseAssetAmount
 		.abs()
-		.mul(marginPrice)
+		.mul(oraclePriceData.price)
 		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
-
-	return baseAssetValue;
 }
 
 export function calculateWorstCaseBaseAssetAmount(

package/src/math/orders.ts

@@ -139,7 +139,7 @@ export function getLimitPrice(
 	if (!order.oraclePriceOffset.eq(ZERO)) {
 		limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
 	} else if (isOneOfVariant(order.orderType, ['market', 'triggerMarket'])) {
-		if (isAuctionComplete(order, slot)) {
+		if (!isAuctionComplete(order, slot)) {
 			limitPrice = getAuctionPrice(order, slot);
 		} else if (!order.price.eq(ZERO)) {
 			limitPrice = order.price;
@@ -163,16 +163,18 @@ export function isFillableByVAMM(
 	order: Order,
 	market: MarketAccount,
 	oraclePriceData: OraclePriceData,
-	slot: number
+	slot: number,
+	maxAuctionDuration: number
 ): boolean {
 	return (
-		isAuctionComplete(order, slot) &&
-		!calculateBaseAssetAmountForAmmToFulfill(
-			order,
-			market,
-			oraclePriceData,
-			slot
-		).eq(ZERO)
+		(isAuctionComplete(order, slot) &&
+			!calculateBaseAssetAmountForAmmToFulfill(
+				order,
+				market,
+				oraclePriceData,
+				slot
+			).eq(ZERO)) ||
+		isOrderExpired(order, slot, maxAuctionDuration)
 	);
 }
 
@@ -243,3 +245,18 @@ function isSameDirection(
 		(isVariant(firstDirection, 'short') && isVariant(secondDirection, 'short'))
 	);
 }
+
+export function isOrderExpired(
+	order: Order,
+	slot: number,
+	maxAuctionDuration: number
+): boolean {
+	if (
+		!isVariant(order.orderType, 'market') ||
+		!isVariant(order.status, 'open')
+	) {
+		return false;
+	}
+
+	return new BN(slot).sub(order.slot).gt(new BN(maxAuctionDuration));
+}

package/src/math/position.ts

@@ -18,7 +18,7 @@ import {
 	getSwapDirection,
 } from './amm';
 
-import { calculateMarginBaseAssetValue } from './margin';
+import { calculateBaseAssetValueWithOracle } from './margin';
 
 /**
  * calculateBaseAssetValue
@@ -99,7 +99,7 @@ export function calculatePositionPNL(
 		return marketPosition.quoteAssetAmount;
 	}
 
-	const baseAssetValue = calculateMarginBaseAssetValue(
+	const baseAssetValue = calculateBaseAssetValueWithOracle(
 		market,
 		marketPosition,
 		oraclePriceData

package/src/types.ts

@@ -58,9 +58,6 @@ export class OrderAction {
 
 export class OrderActionExplanation {
 	static readonly NONE = { none: {} };
-	static readonly BREACHED_MARGIN_REQUIREMENT = {
-		breachedMarginRequirement: {},
-	};
 	static readonly ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
 		oraclePriceBreachedLimitPrice: {},
 	};
@@ -156,10 +153,15 @@ export type FundingRateRecord = {
 	recordId: BN;
 	marketIndex: BN;
 	fundingRate: BN;
+	fundingRateLong: BN;
+	fundingRateShort: BN;
 	cumulativeFundingRateLong: BN;
 	cumulativeFundingRateShort: BN;
 	oraclePriceTwap: BN;
 	markPriceTwap: BN;
+	periodRevenue: BN;
+	netBaseAssetAmount: BN;
+	netUnsettledLpBaseAssetAmount: BN;
 };
 
 export type FundingPaymentRecord = {
@@ -274,27 +276,41 @@ export type SettlePnlRecord = {
 
 export type OrderRecord = {
 	ts: BN;
-	taker: PublicKey;
-	maker: PublicKey;
-	takerOrder: Order;
-	makerOrder: Order;
-	takerPnl: BN;
-	makerPnl: BN;
+	user: PublicKey;
+	order: Order;
+};
+
+export type OrderActionRecord = {
+	ts: BN;
 	action: OrderAction;
 	actionExplanation: OrderActionExplanation;
-	filler: PublicKey;
-	fillRecordId: BN;
 	marketIndex: BN;
-	baseAssetAmountFilled: BN;
-	quoteAssetAmountFilled: BN;
-	makerRebate: BN;
-	takerFee: BN;
-	fillerReward: BN;
-	quoteAssetAmountSurplus: BN;
+	filler: PublicKey | null;
+	fillerReward: BN | null;
+	fillRecordId: BN | null;
+	referrer: PublicKey | null;
+	baseAssetAmountFilled: BN | null;
+	quoteAssetAmountFilled: BN | null;
+	takerPnl: BN | null;
+	makerPnl: BN | null;
+	takerFee: BN | null;
+	makerRebate: BN | null;
+	referrerReward: BN | null;
+	refereeDiscount: BN | null;
+	quoteAssetAmountSurplus: BN | null;
+	taker: PublicKey | null;
+	takerOrderId: BN | null;
+	takerOrderBaseAssetAmount: BN | null;
+	takerOrderBaseAssetAmountFilled: BN | null;
+	takerOrderQuoteAssetAmountFilled: BN | null;
+	takerOrderFee: BN | null;
+	maker: PublicKey | null;
+	makerOrderId: BN | null;
+	makerOrderBaseAssetAmount: BN | null;
+	makerOrderBaseAssetAmountFilled: BN | null;
+	makerOrderQuoteAssetAmountFilled: BN | null;
+	makerOrderFee: BN | null;
 	oraclePrice: BN;
-	referrer: PublicKey;
-	referrerReward: BN;
-	refereeDiscount: BN;
 };
 
 export type StateAccount = {
@@ -326,6 +342,8 @@ export type StateAccount = {
 	numberOfMarkets: BN;
 	numberOfBanks: BN;
 	minOrderQuoteAssetAmount: BN;
+	maxAuctionDuration: number;
+	minAuctionDuration: number;
 };
 
 export type MarketAccount = {
@@ -355,6 +373,20 @@ export type BankAccount = {
 	vault: PublicKey;
 	vaultAuthority: PublicKey;
 	vaultAuthorityNonce: number;
+
+	insuranceFundVault: PublicKey;
+	insuranceFundVaultAuthority: PublicKey;
+	insuranceFundVaultAuthorityNonce: number;
+	insuranceWithdrawEscrowPeriod: BN;
+	revenuePool: PoolBalance;
+
+	totalIfShares: BN;
+	userIfShares: BN;
+
+	userIfFactor: BN;
+	totalIfFactor: BN;
+	liquidationIfFactor: BN;
+
 	decimals: number;
 	optimalUtilization: BN;
 	optimalBorrowRate: BN;
@@ -437,6 +469,7 @@ export type AMM = {
 	maxSpread: number;
 	marketPosition: UserPosition;
 	marketPositionPerLp: UserPosition;
+	ammJitIntensity: number;
 	maxBaseAssetReserve: BN;
 	minBaseAssetReserve: BN;
 };
@@ -476,6 +509,7 @@ export type UserStatsAccount = {
 	isReferrer: boolean;
 	totalReferrerReward: BN;
 	authority: PublicKey;
+	quoteAssetInsuranceFundStake: BN;
 };
 
 export type UserAccount = {
@@ -589,6 +623,7 @@ export type MakerInfo = {
 export type TakerInfo = {
 	taker: PublicKey;
 	takerStats: PublicKey;
+	takerUserAccount: UserAccount;
 	order: Order;
 };
 
@@ -661,3 +696,15 @@ export type OrderFillerRewardStructure = {
 };
 
 export type MarginCategory = 'Initial' | 'Maintenance';
+
+export type InsuranceFundStake = {
+	bankIndex: BN;
+	authority: PublicKey;
+
+	ifShares: BN;
+	ifBase: BN;
+
+	lastWithdrawRequestShares: BN;
+	lastWithdrawRequestValue: BN;
+	lastWithdrawRequestTs: BN;
+};

package/src/events/eventSubscriber.js

@@ -1,139 +0,0 @@
-"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

@@ -1,50 +0,0 @@
-"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

@@ -1,64 +0,0 @@
-"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

@@ -1,44 +0,0 @@
-"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/webSocketLogProvider.js

@@ -1,41 +0,0 @@
-"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;