@velocity-exchange/sdk 0.3.0 → 0.6.0

package/src/events/fetchLogs.ts

@@ -1,169 +0,0 @@
-import { Program } from '../isomorphic/anchor';
-import {
-	Connection,
-	Finality,
-	PublicKey,
-	TransactionResponse,
-	TransactionSignature,
-	VersionedTransactionResponse,
-} from '@solana/web3.js';
-import { WrappedEvents } from './types';
-import { promiseTimeout } from '../util/promiseTimeout';
-import { parseLogs } from './parse';
-
-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 ?? [],
-	};
-}
-
-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,
-	};
-}
-
-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));
-}
-
-export class LogParser {
-	private program: Program;
-
-	constructor(program: Program) {
-		this.program = program;
-	}
-
-	public parseEventsFromTransaction(
-		transaction: TransactionResponse
-	): WrappedEvents {
-		const transactionLogObject = mapTransactionResponseToLog(transaction);
-
-		return this.parseEventsFromLogs(transactionLogObject);
-	}
-
-	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 = eventLog.name;
-			eventLog.data.txSigIndex = runningEventIndex;
-			// @ts-ignore
-			records.push(eventLog.data);
-			runningEventIndex++;
-		}
-		return records;
-	}
-}

package/src/events/parse.ts

@@ -1,248 +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;
-
-export function parseLogs(
-	program: Program,
-	logs: string[],
-	programId = velocityProgramId
-): Event[] {
-	const { events } = parseLogsWithRaw(program, logs, programId);
-	return events;
-}
-
-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();
-	}
-}
-
-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];
-	}
-}

package/src/events/pollingLogProvider.ts

@@ -1,89 +0,0 @@
-import { LogProvider, logProviderCallback } from './types';
-import {
-	Commitment,
-	Connection,
-	Finality,
-	PublicKey,
-	TransactionSignature,
-} from '@solana/web3.js';
-import { fetchLogs } from './fetchLogs';
-
-export class PollingLogProvider implements LogProvider {
-	private finality: Finality;
-	private intervalId?: ReturnType<typeof setTimeout>;
-	private mostRecentSeenTx?: TransactionSignature;
-	private mutex = 0;
-	private firstFetch = true;
-
-	public constructor(
-		private connection: Connection,
-		private address: PublicKey,
-		commitment: Commitment,
-		private frequency = 15 * 1000,
-		private batchSize?: number
-	) {
-		this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
-	}
-
-	public async subscribe(
-		callback: logProviderCallback,
-		skipHistory?: boolean
-	): Promise<boolean> {
-		if (this.intervalId) {
-			return true;
-		}
-
-		this.intervalId = setInterval(async () => {
-			if (this.mutex === 1) {
-				return;
-			}
-			this.mutex = 1;
-
-			try {
-				const response = await fetchLogs(
-					this.connection,
-					this.address,
-					this.finality,
-					undefined,
-					this.mostRecentSeenTx,
-					// If skipping history, only fetch one log back, not the maximum amount available
-					skipHistory && this.firstFetch ? 1 : undefined,
-					this.batchSize
-				);
-
-				if (response === undefined) {
-					return;
-				}
-
-				this.firstFetch = false;
-
-				const { mostRecentTx, transactionLogs } = response;
-
-				for (const { txSig, slot, logs } of transactionLogs) {
-					callback(txSig, slot, logs, response.mostRecentBlockTime, undefined);
-				}
-
-				this.mostRecentSeenTx = mostRecentTx;
-			} catch (e) {
-				console.error('PollingLogProvider threw an Error');
-				console.error(e);
-			} finally {
-				this.mutex = 0;
-			}
-		}, this.frequency);
-
-		return true;
-	}
-
-	public isSubscribed(): boolean {
-		return this.intervalId !== undefined;
-	}
-
-	public async unsubscribe(): Promise<boolean> {
-		if (this.intervalId !== undefined) {
-			clearInterval(this.intervalId);
-			this.intervalId = undefined;
-		}
-		return true;
-	}
-}

package/src/events/sort.ts

@@ -1,39 +0,0 @@
-import {
-	EventMap,
-	EventSubscriptionOrderBy,
-	EventSubscriptionOrderDirection,
-	EventType,
-	SortFn,
-} from './types';
-
-function clientSortAscFn(): 'less than' {
-	return 'less than';
-}
-
-function clientSortDescFn(): 'greater than' {
-	return 'greater than';
-}
-
-function blockchainSortFn(
-	currentEvent: EventMap[EventType],
-	newEvent: EventMap[EventType]
-): 'less than' | 'greater than' {
-	if (currentEvent.slot == newEvent.slot) {
-		return currentEvent.txSigIndex < newEvent.txSigIndex
-			? 'less than'
-			: 'greater than';
-	}
-
-	return currentEvent.slot < newEvent.slot ? 'less than' : 'greater than';
-}
-
-export function getSortFn(
-	orderBy: EventSubscriptionOrderBy,
-	orderDir: EventSubscriptionOrderDirection
-): SortFn {
-	if (orderBy === 'client') {
-		return orderDir === 'asc' ? clientSortAscFn : clientSortDescFn;
-	}
-
-	return blockchainSortFn;
-}

package/src/events/txEventCache.ts

@@ -1,80 +0,0 @@
-import { WrappedEvent, EventType } from './types';
-
-class Node {
-	constructor(
-		public key: string,
-		public value: WrappedEvent<EventType>[],
-		public next?: Node,
-		public prev?: Node
-	) {}
-}
-
-// lru cache
-export class TxEventCache {
-	size = 0;
-	head?: Node;
-	tail?: Node;
-	cacheMap: { [key: string]: Node } = {};
-
-	constructor(public maxTx = 1024) {}
-
-	public add(key: string, events: WrappedEvent<EventType>[]): void {
-		const existingNode = this.cacheMap[key];
-		if (existingNode) {
-			this.detach(existingNode);
-			this.size--;
-		} else if (this.size === this.maxTx) {
-			const tail = this.tail;
-			if (tail === undefined) {
-				throw new Error(
-					'TxEventCache.add: cache at capacity but tail is unset'
-				);
-			}
-			delete this.cacheMap[tail.key];
-			this.detach(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++;
-	}
-
-	public has(key: string): boolean {
-		return this.cacheMap.hasOwnProperty(key);
-	}
-
-	public get(key: string): WrappedEvent<EventType>[] | undefined {
-		return this.cacheMap[key]?.value;
-	}
-
-	detach(node: Node): void {
-		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;
-		}
-	}
-
-	public clear(): void {
-		this.head = undefined;
-		this.tail = undefined;
-		this.size = 0;
-		this.cacheMap = {};
-	}
-}