@velocity-exchange/sdk 0.4.0 → 0.6.0

package/src/events/eventsServerLogProvider.ts

@@ -1,189 +0,0 @@
-// import WebSocket from 'ws';
-import { logProviderCallback, EventType, LogProvider } from './types';
-import { EventEmitter } from 'events';
-
-// browser support
-let WebSocketImpl: typeof WebSocket;
-if (typeof window !== 'undefined' && window.WebSocket) {
-	WebSocketImpl = window.WebSocket;
-} else {
-	WebSocketImpl = require('ws');
-}
-
-const EVENT_SERVER_HEARTBEAT_INTERVAL_MS = 5000;
-const ALLOWED_MISSED_HEARTBEATS = 3;
-
-/**
- * `LogProvider` backed by the Velocity-hosted events server: a websocket
- * that pushes pre-parsed events per subscribed channel (event type),
- * optionally filtered to one user account, instead of raw RPC logs. Expects
- * a heartbeat message on channel `'heartbeat'` at least every
- * `EVENT_SERVER_HEARTBEAT_INTERVAL_MS` (5s); if none arrives within 3 missed
- * intervals it closes and resubscribes, emitting `'reconnect'` on
- * `eventEmitter` with the attempt count. Each received event is repackaged
- * as a synthetic 3-line log array (`invoke` / raw log / `success`) so it can
- * be run back through the same `parseLogs` pipeline as RPC-sourced logs.
- */
-export class EventsServerLogProvider implements LogProvider {
-	private ws?: WebSocket;
-	private callback?: logProviderCallback;
-	private isUnsubscribing = false;
-	private externalUnsubscribe = false;
-	private lastHeartbeat = 0;
-	private timeoutId?: ReturnType<typeof setTimeout>;
-	private reconnectAttempts = 0;
-	eventEmitter: EventEmitter = new EventEmitter();
-
-	/**
-	 * @param url Websocket URL of the Velocity events server.
-	 * @param eventTypes Event type channels to subscribe to (one `subscribe` message sent per type on connect).
-	 * @param userAccount If provided, scopes the subscription server-side to events for this user account (base58 pubkey string).
-	 */
-	public constructor(
-		private readonly url: string,
-		private readonly eventTypes: EventType[],
-		private readonly userAccount?: string
-	) {}
-
-	public isSubscribed(): boolean {
-		return this.ws !== undefined;
-	}
-
-	/** Opens the websocket and sends a `subscribe` message per configured event type once connected. `skipHistory` is accepted for `LogProvider` interface compatibility but has no effect (the server only ever pushes new events). Always resolves `true`; malformed inbound messages are caught and logged, not thrown. */
-	public async subscribe(callback: logProviderCallback): Promise<boolean> {
-		if (this.ws !== undefined) {
-			return true;
-		}
-		const ws = new WebSocketImpl(this.url);
-		this.ws = ws;
-
-		// reset teardown flags for a fresh subscription cycle — the `ws !== undefined`
-		// unsubscribe path (e.g. a heartbeat-timeout resubscribe) leaves isUnsubscribing
-		// set, which would otherwise disable the watchdog and reconnect on this new socket
-		this.isUnsubscribing = false;
-		this.externalUnsubscribe = false;
-
-		this.callback = callback;
-		ws.addEventListener('open', () => {
-			for (const channel of this.eventTypes) {
-				const subscribeMessage: {
-					type: string;
-					channel: EventType;
-					user?: string;
-				} = {
-					type: 'subscribe',
-					channel: channel,
-				};
-				if (this.userAccount) {
-					subscribeMessage.user = this.userAccount;
-				}
-				ws.send(JSON.stringify(subscribeMessage));
-			}
-			this.reconnectAttempts = 0;
-		});
-
-		ws.addEventListener('message', (data) => {
-			try {
-				if (!this.isUnsubscribing) {
-					clearTimeout(this.timeoutId);
-					this.setTimeout();
-					if (this.reconnectAttempts > 0) {
-						console.log(
-							'eventsServerLogProvider: Resetting reconnect attempts to 0'
-						);
-					}
-					this.reconnectAttempts = 0;
-				}
-
-				const parsedData = JSON.parse(data.data.toString());
-				if (parsedData.channel === 'heartbeat') {
-					this.lastHeartbeat = Date.now();
-					return;
-				}
-				if (parsedData.message !== undefined) {
-					return;
-				}
-				const event = JSON.parse(parsedData.data);
-				if (this.callback === undefined) {
-					return;
-				}
-				this.callback(
-					event.txSig,
-					event.slot,
-					[
-						'Program vELoC1audYbSYVRXn1vPaV8Axoa9oU6BYmNGZZBDZ1P invoke [1]',
-						event.rawLog,
-						'Program vELoC1audYbSYVRXn1vPaV8Axoa9oU6BYmNGZZBDZ1P success',
-					],
-					undefined,
-					event.txSigIndex
-				);
-			} catch (error) {
-				console.error('Error parsing message:', error);
-			}
-		});
-
-		ws.addEventListener('close', () => {
-			console.log('eventsServerLogProvider: WebSocket closed');
-		});
-
-		ws.addEventListener('error', (error) => {
-			console.error('eventsServerLogProvider: WebSocket error:', error);
-		});
-
-		this.setTimeout();
-
-		return true;
-	}
-
-	/**
-	 * Closes the websocket and clears the heartbeat timeout.
-	 * @param external Whether this is a caller-initiated unsubscribe rather than an internal one during a reconnect cycle.
-	 * @returns Always resolves `true`.
-	 */
-	public async unsubscribe(external = false): Promise<boolean> {
-		this.isUnsubscribing = true;
-		this.externalUnsubscribe = external;
-		if (this.timeoutId) {
-			clearInterval(this.timeoutId);
-			this.timeoutId = undefined;
-		}
-
-		if (this.ws !== undefined) {
-			this.ws.close();
-			this.ws = undefined;
-			return true;
-		} else {
-			this.isUnsubscribing = false;
-			return true;
-		}
-	}
-
-	private setTimeout(): void {
-		this.timeoutId = setTimeout(async () => {
-			if (this.isUnsubscribing || this.externalUnsubscribe) {
-				// If we are in the process of unsubscribing, do not attempt to resubscribe
-				return;
-			}
-
-			const timeSinceLastHeartbeat = Date.now() - this.lastHeartbeat;
-			if (
-				timeSinceLastHeartbeat >
-				EVENT_SERVER_HEARTBEAT_INTERVAL_MS * ALLOWED_MISSED_HEARTBEATS
-			) {
-				console.log(
-					`eventServerLogProvider: No heartbeat in ${timeSinceLastHeartbeat}ms, resubscribing on attempt ${
-						this.reconnectAttempts + 1
-					}`
-				);
-				const callback = this.callback;
-				await this.unsubscribe();
-				this.reconnectAttempts++;
-				this.eventEmitter.emit('reconnect', this.reconnectAttempts);
-				if (callback !== undefined) {
-					this.subscribe(callback);
-				}
-			}
-		}, EVENT_SERVER_HEARTBEAT_INTERVAL_MS * 2);
-	}
-}

package/src/events/fetchLogs.ts

@@ -1,219 +0,0 @@
-import { Program } from '../isomorphic/anchor';
-import {
-	Connection,
-	Finality,
-	PublicKey,
-	TransactionResponse,
-	TransactionSignature,
-	VersionedTransactionResponse,
-} from '@solana/web3.js';
-import {
-	DefaultEventSubscriptionOptions,
-	EventType,
-	WrappedEvents,
-} from './types';
-import { promiseTimeout } from '../util/promiseTimeout';
-import { parseLogs } from './parse';
-
-/**
- * Case-insensitive lookup from decoded (camelCase) IDL event names to
- * PascalCase `EventType` keys, mirroring `EventSubscriber`'s
- * `eventTypeByLowercaseName` — `@coral-xyz/anchor` 0.32+ decodes event names
- * in camelCase, but the rest of the SDK keys off the PascalCase `EventType`.
- */
-const eventTypeByLowercaseName = new Map<string, EventType>(
-	(DefaultEventSubscriptionOptions.eventTypes ?? []).map((eventType) => [
-		eventType.toLowerCase(),
-		eventType,
-	])
-);
-
-type Log = { txSig: TransactionSignature; slot: number; logs: string[] };
-type FetchLogsResponse = {
-	earliestTx: string;
-	mostRecentTx: string;
-	earliestSlot: number;
-	mostRecentSlot: number;
-	transactionLogs: Log[];
-	mostRecentBlockTime: number | undefined;
-};
-
-function mapTransactionResponseToLog(
-	transaction: TransactionResponse | VersionedTransactionResponse
-): Log {
-	return {
-		txSig: transaction.transaction.signatures[0],
-		slot: transaction.slot,
-		logs: transaction.meta?.logMessages ?? [],
-	};
-}
-
-/**
- * Fetches raw transaction logs for `address`, newest-first from
- * `getSignaturesForAddress` then batch-fetched via `getTransaction`. Used by
- * both `PollingLogProvider` (incremental polling) and
- * `EventSubscriber.fetchPreviousTx` (historical backfill). Failed
- * transactions (with an `err`) are filtered out before fetching logs.
- * @param connection RPC connection.
- * @param address Account/program address to fetch signatures for.
- * @param finality Commitment for both the signature list and the transaction fetches.
- * @param beforeTx Only return signatures older than this one (pagination cursor).
- * @param untilTx Stop at (exclusive of) this signature.
- * @param limit Max signatures to request from `getSignaturesForAddress`; RPC default applies if omitted.
- * @param batchSize Number of `getTransaction` calls batched per RPC round-trip; defaults to 25.
- * @returns `undefined` if no non-failed signatures were found in range; otherwise the transaction logs plus the earliest/most-recent signature, slot, and block time observed, for use as the next `beforeTx`/`mostRecentSeenTx` cursor.
- */
-export async function fetchLogs(
-	connection: Connection,
-	address: PublicKey,
-	finality: Finality,
-	beforeTx?: TransactionSignature,
-	untilTx?: TransactionSignature,
-	limit?: number,
-	batchSize = 25
-): Promise<FetchLogsResponse | undefined> {
-	const signatures = await connection.getSignaturesForAddress(
-		address,
-		{
-			before: beforeTx,
-			until: untilTx,
-			limit,
-		},
-		finality
-	);
-
-	const sortedSignatures = signatures.sort((a, b) =>
-		a.slot === b.slot ? 0 : a.slot < b.slot ? -1 : 1
-	);
-
-	const filteredSignatures = sortedSignatures.filter(
-		(signature) => !signature.err
-	);
-
-	if (filteredSignatures.length === 0) {
-		return undefined;
-	}
-
-	const chunkedSignatures = chunk(filteredSignatures, batchSize);
-
-	const transactionLogs = (
-		await Promise.all(
-			chunkedSignatures.map(async (chunk) => {
-				return await fetchTransactionLogs(
-					connection,
-					chunk.map((confirmedSignature) => confirmedSignature.signature),
-					finality
-				);
-			})
-		)
-	).flat();
-
-	const earliest = filteredSignatures[0];
-	const mostRecent = filteredSignatures[filteredSignatures.length - 1];
-
-	return {
-		transactionLogs: transactionLogs,
-		earliestTx: earliest.signature,
-		mostRecentTx: mostRecent.signature,
-		earliestSlot: earliest.slot,
-		mostRecentSlot: mostRecent.slot,
-		mostRecentBlockTime: mostRecent.blockTime ?? undefined,
-	};
-}
-
-/**
- * Fetches `getTransaction` for a batch of signatures in a single RPC batch
- * request, with a 10-second overall timeout.
- * @param connection RPC connection.
- * @param signatures Signatures to fetch (fetched as `maxSupportedTransactionVersion: 0`).
- * @param finality Commitment to fetch each transaction at.
- * @returns One `Log` per signature that returned a result (signatures the RPC couldn't resolve are silently dropped, not padded with placeholders).
- * @throws (rejects) if the batch RPC call doesn't complete within 10 seconds.
- */
-export async function fetchTransactionLogs(
-	connection: Connection,
-	signatures: TransactionSignature[],
-	finality: Finality
-): Promise<Log[]> {
-	const requests = new Array<{ methodName: string; args: any }>();
-	for (const signature of signatures) {
-		const args = [
-			signature,
-			{ commitment: finality, maxSupportedTransactionVersion: 0 },
-		];
-
-		requests.push({
-			methodName: 'getTransaction',
-			args,
-		});
-	}
-
-	const rpcResponses: any | null = await promiseTimeout(
-		// @ts-ignore
-		connection._rpcBatchRequest(requests),
-		10 * 1000 // 10 second timeout
-	);
-
-	if (rpcResponses === null) {
-		return Promise.reject('RPC request timed out fetching transactions');
-	}
-
-	const logs = new Array<Log>();
-	for (const rpcResponse of rpcResponses) {
-		if (rpcResponse.result) {
-			logs.push(mapTransactionResponseToLog(rpcResponse.result));
-		}
-	}
-
-	return logs;
-}
-
-function chunk<T>(array: readonly T[], size: number): T[][] {
-	return new Array(Math.ceil(array.length / size))
-		.fill(null)
-		.map((_, index) => index * size)
-		.map((begin) => array.slice(begin, begin + size));
-}
-
-/**
- * Standalone helper to decode events out of an already-fetched transaction or
- * log object, without going through `EventSubscriber`. Useful for one-off
- * decoding (e.g. re-parsing a transaction fetched elsewhere).
- */
-export class LogParser {
-	private program: Program;
-
-	constructor(program: Program) {
-		this.program = program;
-	}
-
-	/** Decodes the events emitted in a fetched `TransactionResponse`. Assigns `txSigIndex` by decode order (0-based), not by any provider-supplied index. */
-	public parseEventsFromTransaction(
-		transaction: TransactionResponse
-	): WrappedEvents {
-		const transactionLogObject = mapTransactionResponseToLog(transaction);
-
-		return this.parseEventsFromLogs(transactionLogObject);
-	}
-
-	/** Decodes the events in a `{ txSig, slot, logs }` log object. Returns an empty array if `logs` is falsy. Assigns `txSigIndex` by decode order (0-based). */
-	public parseEventsFromLogs(event: Log): WrappedEvents {
-		const records: WrappedEvents = [];
-
-		if (!event.logs) return records;
-
-		let runningEventIndex = 0;
-		for (const eventLog of parseLogs(this.program, event.logs)) {
-			eventLog.data.txSig = event.txSig;
-			eventLog.data.slot = event.slot;
-			eventLog.data.eventType =
-				eventTypeByLowercaseName.get(eventLog.name.toLowerCase()) ??
-				eventLog.name;
-			eventLog.data.txSigIndex = runningEventIndex;
-			// @ts-ignore
-			records.push(eventLog.data);
-			runningEventIndex++;
-		}
-		return records;
-	}
-}

package/src/events/parse.ts

@@ -1,271 +0,0 @@
-import { Program, Event } from '../isomorphic/anchor';
-import { CuUsageEvent } from './types';
-
-const velocityProgramId = 'vELoC1audYbSYVRXn1vPaV8Axoa9oU6BYmNGZZBDZ1P';
-const PROGRAM_LOG = 'Program log: ';
-const PROGRAM_INSTRUCTION = 'Program log: Instruction: ';
-const PROGRAM_DATA = 'Program data: ';
-const PROGRAM_LOG_START_INDEX = PROGRAM_LOG.length;
-const PROGRAM_DATA_START_INDEX = PROGRAM_DATA.length;
-const PROGRAM_INSTRUCTION_START_INDEX = PROGRAM_INSTRUCTION.length;
-
-/**
- * Decodes Anchor events from a transaction's raw log lines. Walks the log
- * lines tracking the CPI call stack so only `msg!`/`sol_log_data` lines
- * logged while the Velocity program is the currently-executing program are
- * treated as candidate events; lines after `'Log truncated'` are ignored
- * (the RPC node cut off the log before printing exceeded 10KB).
- * @param program Anchor `Program` whose IDL coder decodes the event discriminator/payload.
- * @param logs Raw `logMessages` for one transaction.
- * @param programId Program ID whose logs are decoded; defaults to the Velocity program.
- * @returns Decoded Anchor `Event`s in log order (does not include `slot`/`txSig`/`txSigIndex` — callers such as `EventSubscriber` attach those).
- */
-export function parseLogs(
-	program: Program,
-	logs: string[],
-	programId = velocityProgramId
-): Event[] {
-	const { events } = parseLogsWithRaw(program, logs, programId);
-	return events;
-}
-
-/** Same as `parseLogs`, but also returns the raw log line each event was decoded from (parallel-indexed to `events`), for callers that need to keep the original log text. */
-export function parseLogsWithRaw(
-	program: Program,
-	logs: string[],
-	programId = velocityProgramId
-): { events: Event[]; rawLogs: string[] } {
-	const events = [];
-	const rawLogs = [];
-	const execution = new ExecutionContext();
-	for (const log of logs) {
-		if (log.startsWith('Log truncated')) {
-			break;
-		}
-
-		const [event, newProgram, didPop] = handleLog(
-			execution,
-			log,
-			program,
-			programId
-		);
-		if (event) {
-			events.push(event);
-			rawLogs.push(log);
-		}
-		if (newProgram) {
-			execution.push(newProgram);
-		}
-		if (didPop) {
-			execution.pop();
-		}
-	}
-	return { events, rawLogs };
-}
-
-function handleLog(
-	execution: ExecutionContext,
-	log: string,
-	program: Program,
-	programId = velocityProgramId
-): [Event | null, string | null, boolean] {
-	// Executing program is velocity program.
-	if (execution.stack.length > 0 && execution.program() === programId) {
-		return handleProgramLog(log, program, programId);
-	}
-	// Executing program is not velocity program.
-	else {
-		return [null, ...handleSystemLog(log, programId)];
-	}
-}
-
-// Handles logs from *velocity* program.
-function handleProgramLog(
-	log: string,
-	program: Program,
-	programId = velocityProgramId
-): [Event | null, string | null, boolean] {
-	// This is a `msg!` log or a `sol_log_data` log.
-	if (log.startsWith(PROGRAM_LOG)) {
-		const logStr = log.slice(PROGRAM_LOG_START_INDEX);
-		const event = program.coder.events.decode(logStr);
-		return [event, null, false];
-	} else if (log.startsWith(PROGRAM_DATA)) {
-		const logStr = log.slice(PROGRAM_DATA_START_INDEX);
-		const event = program.coder.events.decode(logStr);
-		return [event, null, false];
-	} else {
-		return [null, ...handleSystemLog(log, programId)];
-	}
-}
-
-// Handles logs when the current program being executing is *not* velocity.
-function handleSystemLog(
-	log: string,
-	programId = velocityProgramId
-): [string | null, boolean] {
-	// System component.
-	const logStart = log.split(':')[0];
-	const programStart = `Program ${programId} invoke`;
-
-	// Did the program finish executing?
-	if (logStart.match(/^Program (.*) success/g) !== null) {
-		return [null, true];
-		// Recursive call.
-	} else if (logStart.startsWith(programStart)) {
-		return [programId, false];
-	}
-	// CPI call.
-	else if (logStart.includes('invoke')) {
-		return ['cpi', false]; // Any string will do.
-	} else {
-		return [null, false];
-	}
-}
-
-// Stack frame execution context, allowing one to track what program is
-// executing for a given log.
-class ExecutionContext {
-	stack: string[] = [];
-	ixStack: string[] = [];
-
-	program(): string {
-		if (!this.stack.length) {
-			throw new Error('Expected the stack to have elements');
-		}
-		return this.stack[this.stack.length - 1];
-	}
-
-	push(newProgram: string) {
-		this.stack.push(newProgram);
-	}
-
-	pop() {
-		if (!this.stack.length) {
-			throw new Error('Expected the stack to have elements');
-		}
-		this.stack.pop();
-	}
-
-	ix(): string {
-		if (!this.ixStack.length) {
-			throw new Error('Expected the ix stack to have elements');
-		}
-		return this.ixStack[this.ixStack.length - 1];
-	}
-
-	pushIx(newIx: string) {
-		this.ixStack.push(newIx);
-	}
-
-	popIx() {
-		this.ixStack.pop();
-	}
-}
-
-/**
- * Extracts per-instruction compute-unit usage from a transaction's raw logs
- * by matching `Program log: Instruction: <name>` and
- * `Program <id> consumed N of M compute units` lines while `programId` is
- * the currently-executing program. Unlike `parseLogs`, this is not decoding
- * a real on-chain `#[event]` — `CuUsage` is a synthetic event shape for
- * client-side profiling.
- * @param logs Raw `logMessages` for one transaction.
- * @param programId Program ID whose CU consumption is measured; defaults to the Velocity program.
- * @returns One `Event<CuUsage>` per top-level instruction invoking that program, in log order. `cuUsage` is in compute units.
- */
-export function parseLogsForCuUsage(
-	logs: string[],
-	programId = velocityProgramId
-): Event<any, CuUsageEvent>[] {
-	const cuUsageEvents: Event<any, CuUsageEvent>[] = [];
-
-	const execution = new ExecutionContext();
-	for (const log of logs) {
-		if (log.startsWith('Log truncated')) {
-			break;
-		}
-
-		const [newProgram, newIx, didPopProgram, didPopIx] = handleLogForCuUsage(
-			execution,
-			log,
-			programId
-		);
-		if (newProgram) {
-			execution.push(newProgram);
-		}
-		if (newIx) {
-			execution.pushIx(newIx);
-		}
-		if (didPopProgram) {
-			execution.pop();
-		}
-		if (didPopIx !== null) {
-			cuUsageEvents.push({
-				name: 'CuUsage',
-				data: {
-					instruction: execution.ix(),
-					cuUsage: didPopIx!,
-				},
-			} as any);
-			execution.popIx();
-		}
-	}
-	return cuUsageEvents;
-}
-
-function handleLogForCuUsage(
-	execution: ExecutionContext,
-	log: string,
-	programId = velocityProgramId
-): [string | null, string | null, boolean, number | null] {
-	if (execution.stack.length > 0 && execution.program() === programId) {
-		return handleProgramLogForCuUsage(log, programId);
-	} else {
-		return handleSystemLogForCuUsage(log, programId);
-	}
-}
-
-function handleProgramLogForCuUsage(
-	log: string,
-	programId = velocityProgramId
-): [string | null, string | null, boolean, number | null] {
-	if (log.startsWith(PROGRAM_INSTRUCTION)) {
-		const ixStr = log.slice(PROGRAM_INSTRUCTION_START_INDEX);
-		return [null, ixStr, false, null];
-	} else {
-		return handleSystemLogForCuUsage(log, programId);
-	}
-}
-
-function handleSystemLogForCuUsage(
-	log: string,
-	programId = velocityProgramId
-): [string | null, string | null, boolean, number | null] {
-	// System component.
-	const logStart = log.split(':')[0];
-	const programStart = `Program ${programId} invoke`;
-
-	// Did the program finish executing?
-	if (logStart.match(/^Program (.*) success/g) !== null) {
-		return [null, null, true, null];
-		// Recursive call.
-	} else if (logStart.startsWith(programStart)) {
-		return [programId, null, false, null];
-		// Consumed CU log.
-	} else if (log.startsWith(`Program ${programId} consumed `)) {
-		// Extract CU usage, e.g. 'Program ... consumed 29242 of 199700 compute units'
-		// We need to extract the consumed value (29242)
-		const matches = log.match(/consumed (\d+) of \d+ compute units/);
-		if (matches) {
-			return [null, null, false, Number(matches[1])];
-		}
-		return [null, null, false, null];
-	}
-	// CPI call.
-	else if (logStart.includes('invoke')) {
-		return ['cpi', null, false, null]; // Any string will do.
-	} else {
-		return [null, null, false, null];
-	}
-}