@velocity-exchange/sdk 0.4.0 → 0.6.1

package/src/accounts/customizedCadenceBulkAccountLoader.ts

@@ -1,250 +0,0 @@
-import { GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE } from '../constants/numericConstants';
-import { BulkAccountLoader } from './bulkAccountLoader';
-import { Commitment, Connection, PublicKey } from '@solana/web3.js';
-import { v4 as uuidv4 } from 'uuid';
-
-/**
- * `BulkAccountLoader` variant where each account can be polled at its own cadence instead of a
- * single shared `pollingFrequency`. Overrides the base class's single `setInterval` with a
- * per-account `accountFrequencies` map: `handleAccountLoading()` only includes an account in a
- * given tick if `Date.now() - lastPollingTime >= frequency` for that account, then delegates to
- * the inherited chunked `loadChunk` for the actual `getMultipleAccounts` batch. The interval
- * itself always runs at the fastest frequency across all registered accounts (see `startPolling`),
- * so slower accounts simply get skipped on ticks that fire before they're due.
- */
-export class CustomizedCadenceBulkAccountLoader extends BulkAccountLoader {
-	private customIntervalId: NodeJS.Timeout | null;
-	private currentPollingFrequency: number | null;
-	private accountFrequencies: Map<string, number>;
-	private lastPollingTimes: Map<string, number>;
-	private defaultPollingFrequency: number;
-
-	/**
-	 * @param connection Connection used for the batched `getMultipleAccounts` polls.
-	 * @param commitment Commitment level applied to every poll.
-	 * @param defaultPollingFrequency Polling cadence in ms (see base `BulkAccountLoader`) used for any account added without an explicit `customPollingFrequency`, and as the floor when computing the shared interval in `startPolling`.
-	 */
-	constructor(
-		connection: Connection,
-		commitment: Commitment,
-		defaultPollingFrequency: number
-	) {
-		super(connection, commitment, defaultPollingFrequency);
-		this.customIntervalId = null;
-		this.currentPollingFrequency = null;
-		this.accountFrequencies = new Map();
-		this.lastPollingTimes = new Map();
-		this.defaultPollingFrequency = defaultPollingFrequency;
-	}
-
-	private getAccountsToLoad(): Array<{
-		publicKey: PublicKey;
-		callbacks: Map<string, (buffer: Buffer, slot: number) => void>;
-	}> {
-		const currentTime = Date.now();
-		const accountsToLoad: Array<{
-			publicKey: PublicKey;
-			callbacks: Map<string, (buffer: Buffer, slot: number) => void>;
-		}> = [];
-
-		for (const [key, frequency] of this.accountFrequencies.entries()) {
-			const lastPollTime = this.lastPollingTimes.get(key) || 0;
-			if (currentTime - lastPollTime >= frequency) {
-				const account = this.accountsToLoad.get(key);
-				if (account) {
-					accountsToLoad.push(account);
-					this.lastPollingTimes.set(key, currentTime);
-				}
-			}
-		}
-
-		return accountsToLoad;
-	}
-
-	/** Immediately runs one due-account loading pass, bypassing the interval timer. Unlike the base class's `load()`, this does not force-load every registered account — only those currently due per their own cadence. */
-	public async load(): Promise<void> {
-		return this.handleAccountLoading();
-	}
-
-	private async handleAccountLoading(): Promise<void> {
-		const accounts = this.getAccountsToLoad();
-
-		if (accounts.length > 0) {
-			const chunks = this.chunks(
-				this.chunks(accounts, GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE),
-				10
-			);
-
-			await Promise.all(
-				chunks.map((chunk) => {
-					return this.loadChunk(chunk);
-				})
-			);
-		}
-	}
-
-	/**
-	 * Updates the polling frequency for an account. This affects all callbacks attached to this account.
-	 *
-	 * @param publicKey The public key of the account to set the custom polling frequency for
-	 * @param newFrequency The new polling frequency in ms
-	 */
-	public setCustomPollingFrequency(
-		publicKey: PublicKey,
-		newFrequency: number
-	): void {
-		const key = publicKey.toBase58();
-		this.accountFrequencies.set(key, newFrequency);
-		this.lastPollingTimes.set(key, 0); // Reset last polling time to ensure immediate load
-		this.restartPollingIfNeeded(newFrequency);
-	}
-
-	private restartPollingIfNeeded(newFrequency: number): void {
-		if (
-			(this.currentPollingFrequency &&
-				newFrequency < this.currentPollingFrequency) ||
-			!this.customIntervalId
-		) {
-			this.stopPolling();
-			this.startPolling();
-		}
-	}
-
-	/**
-	 * Adds an account to be monitored by the bulk account loader
-	 * @param publicKey The public key of the account to monitor
-	 * @param callback Function to be called when account data is received
-	 * @param customPollingFrequency Optional custom polling frequency in ms for this specific account.
-	 * If not provided, will use the default polling frequency
-	 * @returns A unique callback ID that can be used to remove this specific callback later
-	 *
-	 * The method will:
-	 * 1. Create a new callback mapping for the account if it doesn't exist already
-	 * 2. Set up polling frequency tracking for the account if it doesn't exist already. If previous polling frequency is faster than the new one,
-	 *    we will use the previous frequency.
-	 * 3. Reset last polling time to 0 to ensure data fetch is triggered on the next poll. Note that this does not mean the account will be fetched immediately.
-	 * 4. Automatically restart polling if this account needs a faster frequency than existing accounts
-	 */
-	public async addAccount(
-		publicKey: PublicKey,
-		callback: (buffer: Buffer, slot: number) => void,
-		customPollingFrequency?: number
-	): Promise<string> {
-		const callbackId = uuidv4();
-		const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
-
-		if (existingAccountToLoad) {
-			existingAccountToLoad.callbacks.set(callbackId, callback);
-		} else {
-			const callbacks = new Map<
-				string,
-				(buffer: Buffer, slot: number) => void
-			>();
-			callbacks.set(callbackId, callback);
-			const newAccountToLoad = {
-				publicKey,
-				callbacks,
-			};
-			this.accountsToLoad.set(publicKey.toString(), newAccountToLoad);
-		}
-
-		const key = publicKey.toBase58();
-		const previousFrequency =
-			this.accountFrequencies.get(key) || this.defaultPollingFrequency;
-		const updatedFrequency =
-			customPollingFrequency && customPollingFrequency < previousFrequency
-				? customPollingFrequency
-				: previousFrequency;
-
-		this.accountFrequencies.set(key, updatedFrequency);
-		this.lastPollingTimes.set(key, 0); // Reset last polling time to ensure immediate load
-
-		this.restartPollingIfNeeded(updatedFrequency);
-
-		return callbackId;
-	}
-
-	/**
-	 * Unregisters a callback previously returned by `addAccount`. Once an account has no
-	 * remaining callbacks, its cached buffer/slot and cadence bookkeeping (`accountFrequencies`,
-	 * `lastPollingTimes`) are dropped; if no accounts remain at all, polling stops entirely,
-	 * otherwise polling is restarted in case the removed account held the fastest cadence.
-	 * @param publicKey Account the callback was registered against.
-	 * @param callbackId Id returned by `addAccount`.
-	 */
-	public removeAccount(publicKey: PublicKey, callbackId: string): void {
-		const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
-
-		if (existingAccountToLoad) {
-			existingAccountToLoad.callbacks.delete(callbackId);
-
-			if (existingAccountToLoad.callbacks.size === 0) {
-				this.bufferAndSlotMap.delete(publicKey.toString());
-				this.accountsToLoad.delete(existingAccountToLoad.publicKey.toString());
-				const key = publicKey.toBase58();
-				this.accountFrequencies.delete(key);
-				this.lastPollingTimes.delete(key);
-			}
-		}
-
-		if (this.accountsToLoad.size === 0) {
-			this.stopPolling();
-		} else {
-			// Restart polling in case we removed the account with the smallest frequency
-			this.restartPollingIfNeeded(this.defaultPollingFrequency);
-		}
-	}
-
-	/** Returns the polling cadence in ms currently set for `publicKey` (custom or default), or `null` if the account isn't registered. */
-	public getAccountCadence(publicKey: PublicKey): number | null {
-		const key = publicKey.toBase58();
-		return this.accountFrequencies.get(key) || null;
-	}
-
-	/**
-	 * Starts the shared interval timer, ticking at the fastest cadence among all registered
-	 * accounts (or `defaultPollingFrequency` if none are registered). Each tick runs
-	 * `handleAccountLoading()`, which loads only the accounts due at that moment. A no-op if
-	 * already running; call `stopPolling()` first to pick up a new minimum frequency.
-	 */
-	public startPolling(): void {
-		if (this.customIntervalId) {
-			return;
-		}
-
-		const minFrequency = Math.min(
-			...Array.from(this.accountFrequencies.values()),
-			this.defaultPollingFrequency
-		);
-
-		this.currentPollingFrequency = minFrequency;
-
-		this.customIntervalId = setInterval(() => {
-			this.handleAccountLoading().catch((error) => {
-				console.error('Error in account loading:', error);
-			});
-		}, minFrequency);
-	}
-
-	/** Stops the shared interval timer (and the base class's, via `super.stopPolling()`) and clears `lastPollingTimes` so every account is treated as due again once polling restarts. */
-	public stopPolling(): void {
-		super.stopPolling();
-
-		if (this.customIntervalId) {
-			clearInterval(this.customIntervalId);
-			this.customIntervalId = null;
-			this.currentPollingFrequency = null;
-		}
-		this.lastPollingTimes.clear();
-	}
-
-	/**
-	 * Clears all per-account cadence bookkeeping. Because `getAccountsToLoad()` only considers
-	 * accounts with an entry in `accountFrequencies`, this stops polling for every registered
-	 * account until a cadence is re-established via `setCustomPollingFrequency` or `addAccount`.
-	 * Registered accounts/callbacks themselves are untouched.
-	 */
-	public clearAccountFrequencies(): void {
-		this.accountFrequencies.clear();
-	}
-}

package/src/accounts/fetch.ts

@@ -1,200 +0,0 @@
-import { Connection, PublicKey } from '@solana/web3.js';
-import {
-	RevenueShareAccount,
-	RevenueShareEscrowAccount,
-	UserAccount,
-	UserStatsAccount,
-} from '../types';
-import {
-	getRevenueShareAccountPublicKey,
-	getRevenueShareEscrowAccountPublicKey,
-	getUserAccountPublicKey,
-	getUserStatsAccountPublicKey,
-} from '../addresses/pda';
-import { VelocityProgram } from '../config';
-
-/**
- * Fetches every `UserAccount` (sub-account) belonging to `authority`, from sub-account id `0`
- * up to `limit - 1`, in a single batched `getMultipleAccountsInfo` RPC call.
- * @param connection Connection used for the batched fetch.
- * @param program Anchor program used to derive PDAs and decode account data.
- * @param authority Wallet/authority pubkey whose sub-accounts to fetch.
- * @param limit Number of sub-account ids to check, starting at 0. Defaults to 8.
- * @returns One entry per sub-account id in order; `undefined` where no account exists at that id.
- */
-export async function fetchUserAccounts(
-	connection: Connection,
-	program: VelocityProgram,
-	authority: PublicKey,
-	limit = 8
-): Promise<(UserAccount | undefined)[]> {
-	const userAccountPublicKeys = new Array<PublicKey>();
-	for (let i = 0; i < limit; i++) {
-		userAccountPublicKeys.push(
-			await getUserAccountPublicKey(program.programId, authority, i)
-		);
-	}
-
-	return fetchUserAccountsUsingKeys(connection, program, userAccountPublicKeys);
-}
-
-/**
- * Fetches and decodes a specific list of `UserAccount` pubkeys in one batched
- * `getMultipleAccountsInfo` RPC call. Unlike `fetchUserAccounts`, the caller supplies the exact
- * addresses rather than deriving them by sub-account id.
- * @param connection Connection used for the batched fetch.
- * @param program Anchor program used to decode account data.
- * @param userAccountPublicKeys Addresses to fetch, in order.
- * @returns One entry per input pubkey, in the same order; `undefined` where no account exists at that address.
- */
-export async function fetchUserAccountsUsingKeys(
-	connection: Connection,
-	program: VelocityProgram,
-	userAccountPublicKeys: PublicKey[]
-): Promise<(UserAccount | undefined)[]> {
-	const accountInfos = await connection.getMultipleAccountsInfo(
-		userAccountPublicKeys,
-		'confirmed'
-	);
-
-	return accountInfos.map((accountInfo) => {
-		if (!accountInfo) {
-			return undefined;
-		}
-		return (program.account as any).user.coder.accounts.decodeUnchecked(
-			'user',
-			accountInfo.data
-		) as UserAccount;
-	});
-}
-
-/**
- * Fetches and decodes the `UserStatsAccount` for `authority`, if one exists.
- * @param connection Connection used for the fetch.
- * @param program Anchor program used to derive the PDA and decode account data.
- * @param authority Wallet/authority pubkey the stats account belongs to.
- * @returns The decoded account, or `undefined` if it hasn't been initialized on-chain.
- */
-export async function fetchUserStatsAccount(
-	connection: Connection,
-	program: VelocityProgram,
-	authority: PublicKey
-): Promise<UserStatsAccount | undefined> {
-	const userStatsPublicKey = getUserStatsAccountPublicKey(
-		program.programId,
-		authority
-	);
-	const accountInfo = await connection.getAccountInfo(
-		userStatsPublicKey,
-		'confirmed'
-	);
-
-	return accountInfo
-		? ((program.account as any).user.coder.accounts.decodeUnchecked(
-				'userStats',
-				accountInfo.data
-		  ) as UserStatsAccount)
-		: undefined;
-}
-
-/**
- * Fetches and decodes the `RevenueShareAccount` for `authority` (tracks referral/builder revenue
- * share balances), if one exists.
- * @param connection Connection used for the fetch.
- * @param program Anchor program used to derive the PDA and decode account data.
- * @param authority Wallet/authority pubkey the revenue share account belongs to.
- * @returns The decoded account, or `null` if it hasn't been initialized on-chain.
- */
-export async function fetchRevenueShareAccount(
-	connection: Connection,
-	program: VelocityProgram,
-	authority: PublicKey
-): Promise<RevenueShareAccount | null> {
-	const revenueShareAccountPublicKey = getRevenueShareAccountPublicKey(
-		program.programId,
-		authority
-	);
-	const accountInfo = await connection.getAccountInfo(
-		revenueShareAccountPublicKey
-	);
-	if (!accountInfo) return null;
-	return (program.account as any).revenueShare.coder.accounts.decode(
-		'revenueShare',
-		accountInfo.data
-	) as RevenueShareAccount;
-}
-
-/**
- * Fetches and decodes the `RevenueShareEscrowAccount` for `authority` (holds escrowed
- * revenue-share amounts pending distribution), if one exists.
- * @param connection Connection used for the fetch.
- * @param program Anchor program used to derive the PDA and decode account data.
- * @param authority Wallet/authority pubkey the escrow account belongs to.
- * @returns The decoded account, or `null` if it hasn't been initialized on-chain.
- */
-export async function fetchRevenueShareEscrowAccount(
-	connection: Connection,
-	program: VelocityProgram,
-	authority: PublicKey
-): Promise<RevenueShareEscrowAccount | null> {
-	const revenueShareEscrowPubKey = getRevenueShareEscrowAccountPublicKey(
-		program.programId,
-		authority
-	);
-
-	const escrow = await connection.getAccountInfo(revenueShareEscrowPubKey);
-
-	if (!escrow) return null;
-
-	const escrowAccount = (
-		program.account as any
-	).revenueShareEscrow.coder.accounts.decode(
-		'revenueShareEscrow',
-		escrow.data
-	) as RevenueShareEscrowAccount;
-
-	return escrowAccount;
-}
-
-/** Options accepted by `fetchAccount`/`fetchAccounts`. */
-export type FetchAccountOptions = {
-	/** Commitment level for the underlying `getAccountInfo`/`getMultipleAccountsInfo` call; defaults to the connection's configured commitment if omitted. */
-	commitment?: Parameters<Connection['getAccountInfo']>[1];
-};
-
-/**
- * Fetches an account's raw data buffer without decoding it (no Anchor coder involved), for
- * callers that only need the bytes.
- * @param connection Connection used for the fetch.
- * @param publicKey Account address to fetch.
- * @param opts Optional commitment override.
- * @returns The raw account data, or `null` if the account doesn't exist.
- */
-export async function fetchAccount(
-	connection: Connection,
-	publicKey: PublicKey,
-	opts?: FetchAccountOptions
-): Promise<Buffer | null> {
-	const info = await connection.getAccountInfo(publicKey, opts?.commitment);
-	return info?.data ?? null;
-}
-
-/**
- * Batch variant of `fetchAccount` — fetches raw data buffers for multiple accounts in one
- * `getMultipleAccountsInfo` call.
- * @param connection Connection used for the fetch.
- * @param publicKeys Account addresses to fetch, in order.
- * @param opts Optional commitment override.
- * @returns One entry per input pubkey, in the same order; `null` where the account doesn't exist.
- */
-export async function fetchAccounts(
-	connection: Connection,
-	publicKeys: PublicKey[],
-	opts?: FetchAccountOptions
-): Promise<(Buffer | null)[]> {
-	const infos = await connection.getMultipleAccountsInfo(
-		publicKeys,
-		opts?.commitment
-	);
-	return infos.map((info) => info?.data ?? null);
-}

package/src/accounts/grpcAccountSubscriber.ts

@@ -1,225 +0,0 @@
-import { ResubOpts, GrpcConfigs } from './types';
-import { PublicKey } from '@solana/web3.js';
-import { VelocityProgram } from '../config';
-import * as Buffer from 'buffer';
-
-import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
-import {
-	Client,
-	ClientDuplexStream,
-	CommitmentLevel,
-	createClient,
-	SubscribeRequest,
-	SubscribeUpdate,
-} from '../isomorphic/grpc';
-
-/**
- * `AccountSubscriber` for a single account, streamed via a gRPC Geyser plugin (Yellowstone or
- * LaserStream, per `GrpcConfigs`) instead of the standard `connection.onAccountChange` WebSocket.
- * Extends `WebSocketAccountSubscriber` to reuse its buffering/decode/resub-timer logic — only the
- * transport (`subscribe`/`unsubscribe`) is replaced. Construct via the static `create` factory,
- * not the constructor directly, since establishing the gRPC client is asynchronous.
- */
-export class grpcAccountSubscriber<T> extends WebSocketAccountSubscriber<T> {
-	private client: Client;
-	private _stream?: ClientDuplexStream;
-	private get stream(): ClientDuplexStream {
-		if (!this._stream) {
-			throw new Error(
-				'grpcAccountSubscriber: stream accessed before subscribe()'
-			);
-		}
-		return this._stream;
-	}
-	private commitmentLevel: CommitmentLevel;
-	public listenerId?: number;
-
-	private constructor(
-		client: Client,
-		commitmentLevel: CommitmentLevel,
-		accountName: string,
-		program: VelocityProgram,
-		accountPublicKey: PublicKey,
-		decodeBuffer?: (buffer: Buffer) => T,
-		resubOpts?: ResubOpts
-	) {
-		super(accountName, program, accountPublicKey, decodeBuffer, resubOpts);
-		this.client = client;
-		this.commitmentLevel = commitmentLevel;
-	}
-
-	/**
-	 * Creates a gRPC client (or reuses `clientProp`, letting multiple subscribers share one
-	 * connection) and constructs a `grpcAccountSubscriber`. Does not itself start streaming — call
-	 * `subscribe()` on the result.
-	 * @param grpcConfigs gRPC Geyser endpoint/token/commitment config (Yellowstone or LaserStream).
-	 * @param accountName Anchor account type name (used for logging and, absent `decodeBuffer`, for decoding via the program coder).
-	 * @param program Anchor program providing the connection and coder.
-	 * @param accountPublicKey Address of the account to track.
-	 * @param decodeBuffer Optional custom decode function; defaults to `program.coder.accounts.decode(accountName, buffer)`.
-	 * @param resubOpts Resubscription watchdog options; omit to disable the inactivity timer.
-	 * @param clientProp Optional existing gRPC client to reuse instead of creating a new connection.
-	 */
-	public static async create<U>(
-		grpcConfigs: GrpcConfigs,
-		accountName: string,
-		program: VelocityProgram,
-		accountPublicKey: PublicKey,
-		decodeBuffer?: (buffer: Buffer) => U,
-		resubOpts?: ResubOpts,
-		clientProp?: Client
-	): Promise<grpcAccountSubscriber<U>> {
-		const client = clientProp
-			? clientProp
-			: await createClient(
-					grpcConfigs.endpoint,
-					grpcConfigs.token,
-					grpcConfigs.channelOptions ?? {}
-			  );
-		const commitmentLevel =
-			// @ts-ignore :: isomorphic exported enum fails typescript but will work at runtime
-			grpcConfigs.commitmentLevel ?? CommitmentLevel.CONFIRMED;
-
-		return new grpcAccountSubscriber(
-			client,
-			commitmentLevel,
-			accountName,
-			program,
-			accountPublicKey,
-			decodeBuffer,
-			resubOpts
-		);
-	}
-
-	/**
-	 * Seeds `dataAndSlot` with an initial `fetch()` (if not already set), opens a gRPC subscribe
-	 * stream filtered to this single account, and writes the subscribe request. Idempotent: a
-	 * no-op if already subscribed or mid-unsubscribe.
-	 * @param onChange Invoked with the newly decoded account data on each accepted update.
-	 */
-	override async subscribe(onChange: (data: T) => void): Promise<void> {
-		if (this.listenerId != null || this.isUnsubscribing) {
-			return;
-		}
-
-		this.onChange = onChange;
-		if (!this.dataAndSlot) {
-			await this.fetch();
-		}
-
-		// Subscribe with grpc
-		this._stream =
-			(await this.client.subscribe()) as unknown as typeof this.stream;
-		const request: SubscribeRequest = {
-			slots: {},
-			accounts: {
-				account: {
-					account: [this.accountPublicKey.toString()],
-					owner: [],
-					filters: [],
-				},
-			},
-			transactions: {},
-			blocks: {},
-			blocksMeta: {},
-			accountsDataSlice: [],
-			commitment: this.commitmentLevel,
-			entry: {},
-			transactionsStatus: {},
-		};
-		this.stream.on('data', (chunk: SubscribeUpdate) => {
-			if (!chunk.account || !chunk.account.account) {
-				return;
-			}
-			const slot = Number(chunk.account.slot);
-			const accountInfo = {
-				owner: new PublicKey(chunk.account.account.owner),
-				lamports: Number(chunk.account.account.lamports),
-				data: Buffer.Buffer.from(chunk.account.account.data),
-				executable: chunk.account.account.executable,
-				rentEpoch: Number(chunk.account.account.rentEpoch),
-			};
-
-			if (this.resubOpts?.resubTimeoutMs) {
-				this.receivingData = true;
-				clearTimeout(this.timeoutId);
-				this.handleRpcResponse(
-					{
-						slot,
-					},
-					accountInfo
-				);
-				this.setTimeout();
-			} else {
-				this.handleRpcResponse(
-					{
-						slot,
-					},
-					accountInfo
-				);
-			}
-		});
-
-		return new Promise<void>((resolve, reject) => {
-			this.stream.write(request, (err) => {
-				if (err === null || err === undefined) {
-					this.listenerId = 1;
-					if (this.resubOpts?.resubTimeoutMs) {
-						this.receivingData = true;
-						this.setTimeout();
-					}
-					resolve();
-				} else {
-					reject(err);
-				}
-			});
-		}).catch((reason) => {
-			console.error(reason);
-			throw reason;
-		});
-	}
-
-	/**
-	 * Writes an empty subscribe request to clear the stream's account filter and cancels any
-	 * pending resub timeout.
-	 * @param onResub Internal flag set to `true` when called as part of an automatic resubscribe cycle, which preserves `resubOpts.resubTimeoutMs` instead of clearing it. Callers should omit this.
-	 */
-	override async unsubscribe(onResub = false): Promise<void> {
-		if (!onResub && this.resubOpts) {
-			this.resubOpts.resubTimeoutMs = undefined;
-		}
-		this.isUnsubscribing = true;
-		clearTimeout(this.timeoutId);
-		this.timeoutId = undefined;
-
-		if (this.listenerId != null) {
-			const promise = new Promise<void>((resolve, reject) => {
-				const request: SubscribeRequest = {
-					slots: {},
-					accounts: {},
-					transactions: {},
-					blocks: {},
-					blocksMeta: {},
-					accountsDataSlice: [],
-					entry: {},
-					transactionsStatus: {},
-				};
-				this.stream.write(request, (err) => {
-					if (err === null || err === undefined) {
-						this.listenerId = undefined;
-						this.isUnsubscribing = false;
-						resolve();
-					} else {
-						reject(err);
-					}
-				});
-			}).catch((reason) => {
-				console.error(reason);
-				throw reason;
-			});
-			return promise;
-		} else {
-			this.isUnsubscribing = false;
-		}
-	}
-}