@velocity-exchange/sdk 0.0.5 → 0.2.0

package/src/events/eventSubscriber.ts

@@ -1,5 +1,5 @@
 /**
- * EventSubscriber — streams and parses Drift program events from transaction logs.
+ * EventSubscriber — streams and parses Velocity program events from transaction logs.
  *
  * Decodes all program events (OrderActionRecord, DepositRecord, LiquidationRecord,
  * FundingPaymentRecord, etc.) from `state/events.rs` into typed TypeScript objects.
@@ -21,6 +21,7 @@ import {
 	LogProviderType,
 	StreamingLogProviderConfig,
 	PollingLogProviderConfig,
+	LogProviderConfig,
 } from './types';
 import { TxEventCache } from './txEventCache';
 import { EventList } from './eventList';
@@ -39,12 +40,21 @@ export class EventSubscriber {
 	private txEventCache: TxEventCache;
 	private awaitTxPromises = new Map<string, Promise<void>>();
 	private awaitTxResolver = new Map<string, () => void>();
-	private logProvider: LogProvider;
+	private _logProvider?: LogProvider;
 	private _currentProviderType: LogProviderType;
 	public eventEmitter: StrictEventEmitter<EventEmitter, EventSubscriberEvents>;
-	private lastSeenSlot: number;
+	private lastSeenSlot: number | undefined;
 	private lastSeenBlockTime: number | undefined;
-	public lastSeenTxSig: string;
+	public lastSeenTxSig: string | undefined;
+
+	private get logProvider(): LogProvider {
+		if (!this._logProvider) {
+			throw new Error(
+				'EventSubscriber: logProvider accessed before initializeLogProvider()'
+			);
+		}
+		return this._logProvider;
+	}
 
 	public constructor(
 		private connection: Connection,
@@ -57,26 +67,38 @@ export class EventSubscriber {
 		this.eventListMap = new Map<EventType, EventList<EventType>>();
 		this.eventEmitter = new EventEmitter();
 
-		this._currentProviderType = this.options.logProviderConfig.type;
+		this._currentProviderType = this.getLogProviderConfig().type;
 		this.initializeLogProvider();
 	}
 
+	private getLogProviderConfig(): LogProviderConfig {
+		if (this.options.logProviderConfig === undefined) {
+			throw new Error('EventSubscriber: logProviderConfig is not set');
+		}
+		return this.options.logProviderConfig;
+	}
+
+	private getEventTypes(): EventType[] {
+		if (this.options.eventTypes === undefined) {
+			throw new Error('EventSubscriber: eventTypes is not set');
+		}
+		return this.options.eventTypes;
+	}
+
 	get currentProviderType() {
 		return this._currentProviderType;
 	}
 
 	private initializeLogProvider(subscribe = false) {
-		const logProviderConfig = this.options.logProviderConfig;
+		const logProviderConfig = this.getLogProviderConfig();
 
 		if (this._currentProviderType === 'websocket') {
-			this.logProvider = new WebSocketLogProvider(
+			this._logProvider = new WebSocketLogProvider(
 				// @ts-ignore
 				this.connection,
 				this.address,
-				this.options.commitment,
-				(
-					this.options.logProviderConfig as WebSocketLogProviderConfig
-				).resubTimeoutMs
+				this.options.commitment ?? 'confirmed',
+				(logProviderConfig as WebSocketLogProviderConfig).resubTimeoutMs
 			);
 		} else if (this._currentProviderType === 'polling') {
 			const frequency =
@@ -88,18 +110,18 @@ export class EventSubscriber {
 					? (logProviderConfig as PollingLogProviderConfig).batchSize
 					: (logProviderConfig as StreamingLogProviderConfig).fallbackBatchSize;
 
-			this.logProvider = new PollingLogProvider(
+			this._logProvider = new PollingLogProvider(
 				// @ts-ignore
 				this.connection,
 				this.address,
-				this.options.commitment,
+				this.options.commitment ?? 'confirmed',
 				frequency,
 				batchSize
 			);
 		} else if (this._currentProviderType === 'events-server') {
-			this.logProvider = new EventsServerLogProvider(
+			this._logProvider = new EventsServerLogProvider(
 				(logProviderConfig as EventsServerLogProviderConfig).url,
-				this.options.eventTypes,
+				this.getEventTypes(),
 				this.options.address ? this.options.address.toString() : undefined
 			);
 		} else {
@@ -126,14 +148,26 @@ export class EventSubscriber {
 	}
 
 	private populateInitialEventListMap() {
-		for (const eventType of this.options.eventTypes) {
+		const maxEventsPerType = this.options.maxEventsPerType;
+		const orderBy = this.options.orderBy;
+		const orderDir = this.options.orderDir;
+		if (
+			maxEventsPerType === undefined ||
+			orderBy === undefined ||
+			orderDir === undefined
+		) {
+			throw new Error(
+				'EventSubscriber: maxEventsPerType, orderBy and orderDir must be set'
+			);
+		}
+		for (const eventType of this.getEventTypes()) {
 			this.eventListMap.set(
 				eventType,
 				new EventList(
 					eventType,
-					this.options.maxEventsPerType,
-					getSortFn(this.options.orderBy, this.options.orderDir),
-					this.options.orderDir
+					maxEventsPerType,
+					getSortFn(orderBy, orderDir),
+					orderDir
 				)
 			);
 		}
@@ -175,30 +209,33 @@ export class EventSubscriber {
 			this.populateInitialEventListMap();
 
 			if (
-				this.options.logProviderConfig.type === 'websocket' ||
-				this.options.logProviderConfig.type === 'events-server'
+				this.getLogProviderConfig().type === 'websocket' ||
+				this.getLogProviderConfig().type === 'events-server'
 			) {
-				const logProviderConfig = this.options
-					.logProviderConfig as StreamingLogProviderConfig;
-
-				if (this.logProvider.eventEmitter) {
-					this.logProvider.eventEmitter.on(
-						'reconnect',
-						async (reconnectAttempts) => {
-							if (reconnectAttempts > logProviderConfig.maxReconnectAttempts) {
-								console.log(
-									`EventSubscriber: Reconnect attempts ${reconnectAttempts}/${logProviderConfig.maxReconnectAttempts}, reconnecting...`
-								);
-								this.logProvider.eventEmitter.removeAllListeners('reconnect');
-								await this.unsubscribe();
-								this.updateFallbackProviderType(
-									reconnectAttempts,
-									logProviderConfig.maxReconnectAttempts
-								);
-								this.initializeLogProvider(true);
-							}
+				const logProviderConfig =
+					this.getLogProviderConfig() as StreamingLogProviderConfig;
+				// `maxReconnectAttempts` is optional; when unset the original
+				// `reconnectAttempts > undefined` comparison was always false, so
+				// fall back to Infinity to preserve that never-trigger behavior.
+				const maxReconnectAttempts =
+					logProviderConfig.maxReconnectAttempts ?? Infinity;
+
+				const eventEmitter = this.logProvider.eventEmitter;
+				if (eventEmitter) {
+					eventEmitter.on('reconnect', async (reconnectAttempts) => {
+						if (reconnectAttempts > maxReconnectAttempts) {
+							console.log(
+								`EventSubscriber: Reconnect attempts ${reconnectAttempts}/${maxReconnectAttempts}, reconnecting...`
+							);
+							eventEmitter.removeAllListeners('reconnect');
+							await this.unsubscribe();
+							this.updateFallbackProviderType(
+								reconnectAttempts,
+								maxReconnectAttempts
+							);
+							this.initializeLogProvider(true);
 						}
-					);
+					});
 				}
 			}
 			this.logProvider.subscribe(
@@ -243,7 +280,13 @@ export class EventSubscriber {
 		);
 
 		for (const wrappedEvent of wrappedEvents) {
-			this.eventListMap.get(wrappedEvent.eventType).insert(wrappedEvent);
+			const eventList = this.eventListMap.get(wrappedEvent.eventType);
+			if (eventList === undefined) {
+				throw new Error(
+					`EventSubscriber: no EventList for eventType ${wrappedEvent.eventType}`
+				);
+			}
+			eventList.insert(wrappedEvent);
 		}
 
 		// dont emit event till we've added all the events to the eventListMap
@@ -253,7 +296,10 @@ export class EventSubscriber {
 
 		if (this.awaitTxPromises.has(txSig)) {
 			this.awaitTxPromises.delete(txSig);
-			this.awaitTxResolver.get(txSig)();
+			const resolver = this.awaitTxResolver.get(txSig);
+			if (resolver !== undefined) {
+				resolver();
+			}
 			this.awaitTxResolver.delete(txSig);
 		}
 
@@ -264,7 +310,8 @@ export class EventSubscriber {
 
 		if (
 			this.lastSeenBlockTime === undefined ||
-			mostRecentBlockTime > this.lastSeenBlockTime
+			(mostRecentBlockTime !== undefined &&
+				mostRecentBlockTime > this.lastSeenBlockTime)
 		) {
 			this.lastSeenBlockTime = mostRecentBlockTime;
 		}
@@ -278,9 +325,13 @@ export class EventSubscriber {
 		}
 
 		let txFetched = 0;
-		let beforeTx: TransactionSignature = undefined;
-		const untilTx: TransactionSignature = this.options.untilTx;
-		while (txFetched < this.options.maxTx) {
+		let beforeTx: TransactionSignature | undefined = undefined;
+		const untilTx: TransactionSignature | undefined = this.options.untilTx;
+		const maxTx = this.options.maxTx;
+		if (maxTx === undefined) {
+			throw new Error('EventSubscriber: maxTx is not set');
+		}
+		while (txFetched < maxTx) {
 			const response = await fetchLogs(
 				// @ts-ignore
 				this.connection,
@@ -343,8 +394,9 @@ export class EventSubscriber {
 	}
 
 	public awaitTx(txSig: TransactionSignature): Promise<void> {
-		if (this.awaitTxPromises.has(txSig)) {
-			return this.awaitTxPromises.get(txSig);
+		const existingPromise = this.awaitTxPromises.get(txSig);
+		if (existingPromise !== undefined) {
+			return existingPromise;
 		}
 
 		if (this.txEventCache.has(txSig)) {
@@ -373,7 +425,13 @@ export class EventSubscriber {
 	public getEventsArray<Type extends EventType>(
 		eventType: Type
 	): EventMap[Type][] {
-		return this.eventListMap.get(eventType).toArray() as EventMap[Type][];
+		const eventList = this.eventListMap.get(eventType);
+		if (eventList === undefined) {
+			throw new Error(
+				`EventSubscriber: no EventList for eventType ${eventType}`
+			);
+		}
+		return eventList.toArray() as EventMap[Type][];
 	}
 
 	public getEventsByTx(txSig: TransactionSignature): WrappedEvents | undefined {

package/src/events/eventsServerLogProvider.ts

@@ -21,15 +21,13 @@ export class EventsServerLogProvider implements LogProvider {
 	private lastHeartbeat = 0;
 	private timeoutId?: ReturnType<typeof setTimeout>;
 	private reconnectAttempts = 0;
-	eventEmitter?: EventEmitter;
+	eventEmitter: EventEmitter = new EventEmitter();
 
 	public constructor(
 		private readonly url: string,
 		private readonly eventTypes: EventType[],
 		private readonly userAccount?: string
-	) {
-		this.eventEmitter = new EventEmitter();
-	}
+	) {}
 
 	public isSubscribed(): boolean {
 		return this.ws !== undefined;
@@ -39,24 +37,29 @@ export class EventsServerLogProvider implements LogProvider {
 		if (this.ws !== undefined) {
 			return true;
 		}
-		this.ws = new WebSocketImpl(this.url);
+		const ws = new WebSocketImpl(this.url);
+		this.ws = ws;
 
 		this.callback = callback;
-		this.ws.addEventListener('open', () => {
+		ws.addEventListener('open', () => {
 			for (const channel of this.eventTypes) {
-				const subscribeMessage = {
+				const subscribeMessage: {
+					type: string;
+					channel: EventType;
+					user?: string;
+				} = {
 					type: 'subscribe',
 					channel: channel,
 				};
 				if (this.userAccount) {
-					subscribeMessage['user'] = this.userAccount;
+					subscribeMessage.user = this.userAccount;
 				}
-				this.ws.send(JSON.stringify(subscribeMessage));
+				ws.send(JSON.stringify(subscribeMessage));
 			}
 			this.reconnectAttempts = 0;
 		});
 
-		this.ws.addEventListener('message', (data) => {
+		ws.addEventListener('message', (data) => {
 			try {
 				if (!this.isUnsubscribing) {
 					clearTimeout(this.timeoutId);
@@ -78,13 +81,16 @@ export class EventsServerLogProvider implements LogProvider {
 					return;
 				}
 				const event = JSON.parse(parsedData.data);
+				if (this.callback === undefined) {
+					return;
+				}
 				this.callback(
 					event.txSig,
 					event.slot,
 					[
-						'Program dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH invoke [1]',
+						'Program vELoC1audYbSYVRXn1vPaV8Axoa9oU6BYmNGZZBDZ1P invoke [1]',
 						event.rawLog,
-						'Program dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH success',
+						'Program vELoC1audYbSYVRXn1vPaV8Axoa9oU6BYmNGZZBDZ1P success',
 					],
 					undefined,
 					event.txSigIndex
@@ -94,11 +100,11 @@ export class EventsServerLogProvider implements LogProvider {
 			}
 		});
 
-		this.ws.addEventListener('close', () => {
+		ws.addEventListener('close', () => {
 			console.log('eventsServerLogProvider: WebSocket closed');
 		});
 
-		this.ws.addEventListener('error', (error) => {
+		ws.addEventListener('error', (error) => {
 			console.error('eventsServerLogProvider: WebSocket error:', error);
 		});
 
@@ -142,10 +148,13 @@ export class EventsServerLogProvider implements LogProvider {
 						this.reconnectAttempts + 1
 					}`
 				);
+				const callback = this.callback;
 				await this.unsubscribe();
 				this.reconnectAttempts++;
 				this.eventEmitter.emit('reconnect', this.reconnectAttempts);
-				this.subscribe(this.callback);
+				if (callback !== undefined) {
+					this.subscribe(callback);
+				}
 			}
 		}, EVENT_SERVER_HEARTBEAT_INTERVAL_MS * 2);
 	}

package/src/events/fetchLogs.ts

@@ -27,7 +27,7 @@ function mapTransactionResponseToLog(
 	return {
 		txSig: transaction.transaction.signatures[0],
 		slot: transaction.slot,
-		logs: transaction.meta.logMessages,
+		logs: transaction.meta?.logMessages ?? [],
 	};
 }
 
@@ -39,7 +39,7 @@ export async function fetchLogs(
 	untilTx?: TransactionSignature,
 	limit?: number,
 	batchSize = 25
-): Promise<FetchLogsResponse> {
+): Promise<FetchLogsResponse | undefined> {
 	const signatures = await connection.getSignaturesForAddress(
 		address,
 		{
@@ -85,7 +85,7 @@ export async function fetchLogs(
 		mostRecentTx: mostRecent.signature,
 		earliestSlot: earliest.slot,
 		mostRecentSlot: mostRecent.slot,
-		mostRecentBlockTime: mostRecent.blockTime,
+		mostRecentBlockTime: mostRecent.blockTime ?? undefined,
 	};
 }
 

package/src/events/parse.ts

@@ -1,7 +1,7 @@
 import { Program, Event } from '../isomorphic/anchor';
 import { CuUsageEvent } from './types';
 
-const driftProgramId = 'dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH';
+const velocityProgramId = 'vELoC1audYbSYVRXn1vPaV8Axoa9oU6BYmNGZZBDZ1P';
 const PROGRAM_LOG = 'Program log: ';
 const PROGRAM_INSTRUCTION = 'Program log: Instruction: ';
 const PROGRAM_DATA = 'Program data: ';
@@ -12,7 +12,7 @@ const PROGRAM_INSTRUCTION_START_INDEX = PROGRAM_INSTRUCTION.length;
 export function parseLogs(
 	program: Program,
 	logs: string[],
-	programId = driftProgramId
+	programId = velocityProgramId
 ): Event[] {
 	const { events } = parseLogsWithRaw(program, logs, programId);
 	return events;
@@ -21,7 +21,7 @@ export function parseLogs(
 export function parseLogsWithRaw(
 	program: Program,
 	logs: string[],
-	programId = driftProgramId
+	programId = velocityProgramId
 ): { events: Event[]; rawLogs: string[] } {
 	const events = [];
 	const rawLogs = [];
@@ -55,23 +55,23 @@ function handleLog(
 	execution: ExecutionContext,
 	log: string,
 	program: Program,
-	programId = driftProgramId
+	programId = velocityProgramId
 ): [Event | null, string | null, boolean] {
-	// Executing program is drift program.
+	// Executing program is velocity program.
 	if (execution.stack.length > 0 && execution.program() === programId) {
 		return handleProgramLog(log, program, programId);
 	}
-	// Executing program is not drift program.
+	// Executing program is not velocity program.
 	else {
 		return [null, ...handleSystemLog(log, programId)];
 	}
 }
 
-// Handles logs from *drift* program.
+// Handles logs from *velocity* program.
 function handleProgramLog(
 	log: string,
 	program: Program,
-	programId = driftProgramId
+	programId = velocityProgramId
 ): [Event | null, string | null, boolean] {
 	// This is a `msg!` log or a `sol_log_data` log.
 	if (log.startsWith(PROGRAM_LOG)) {
@@ -87,10 +87,10 @@ function handleProgramLog(
 	}
 }
 
-// Handles logs when the current program being executing is *not* drift.
+// Handles logs when the current program being executing is *not* velocity.
 function handleSystemLog(
 	log: string,
-	programId = driftProgramId
+	programId = velocityProgramId
 ): [string | null, boolean] {
 	// System component.
 	const logStart = log.split(':')[0];
@@ -153,7 +153,7 @@ class ExecutionContext {
 
 export function parseLogsForCuUsage(
 	logs: string[],
-	programId = driftProgramId
+	programId = velocityProgramId
 ): Event<any, CuUsageEvent>[] {
 	const cuUsageEvents: Event<any, CuUsageEvent>[] = [];
 
@@ -194,7 +194,7 @@ export function parseLogsForCuUsage(
 function handleLogForCuUsage(
 	execution: ExecutionContext,
 	log: string,
-	programId = driftProgramId
+	programId = velocityProgramId
 ): [string | null, string | null, boolean, number | null] {
 	if (execution.stack.length > 0 && execution.program() === programId) {
 		return handleProgramLogForCuUsage(log, programId);
@@ -205,7 +205,7 @@ function handleLogForCuUsage(
 
 function handleProgramLogForCuUsage(
 	log: string,
-	programId = driftProgramId
+	programId = velocityProgramId
 ): [string | null, string | null, boolean, number | null] {
 	if (log.startsWith(PROGRAM_INSTRUCTION)) {
 		const ixStr = log.slice(PROGRAM_INSTRUCTION_START_INDEX);
@@ -217,7 +217,7 @@ function handleProgramLogForCuUsage(
 
 function handleSystemLogForCuUsage(
 	log: string,
-	programId = driftProgramId
+	programId = velocityProgramId
 ): [string | null, string | null, boolean, number | null] {
 	// System component.
 	const logStart = log.split(':')[0];

package/src/events/pollingLogProvider.ts

@@ -10,9 +10,9 @@ import { fetchLogs } from './fetchLogs';
 
 export class PollingLogProvider implements LogProvider {
 	private finality: Finality;
-	private intervalId: ReturnType<typeof setTimeout>;
+	private intervalId?: ReturnType<typeof setTimeout>;
 	private mostRecentSeenTx?: TransactionSignature;
-	private mutex: number;
+	private mutex = 0;
 	private firstFetch = true;
 
 	public constructor(

package/src/events/txEventCache.ts

@@ -24,8 +24,14 @@ export class TxEventCache {
 			this.detach(existingNode);
 			this.size--;
 		} else if (this.size === this.maxTx) {
-			delete this.cacheMap[this.tail.key];
-			this.detach(this.tail);
+			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--;
 		}
 

package/src/events/types.ts

@@ -11,13 +11,11 @@ import {
 	InsuranceFundRecord,
 	SpotInterestRecord,
 	InsuranceFundStakeRecord,
-	CurveRecord,
+	AmmCurveChanged,
 	SwapRecord,
 	SpotMarketVaultDepositRecord,
 	SignedMsgOrderRecord,
 	DeleteUserRecord,
-	InsuranceFundSwapRecord,
-	TransferProtocolIfSharesToRevenuePoolRecord,
 	LPMintRedeemRecord,
 	LPSettleRecord,
 	LPSwapRecord,
@@ -52,13 +50,11 @@ export const DefaultEventSubscriptionOptions: EventSubscriptionOptions = {
 		'InsuranceFundRecord',
 		'SpotInterestRecord',
 		'InsuranceFundStakeRecord',
-		'CurveRecord',
+		'AmmCurveChanged',
 		'SwapRecord',
 		'SpotMarketVaultDepositRecord',
 		'SignedMsgOrderRecord',
 		'DeleteUserRecord',
-		'InsuranceFundSwapRecord',
-		'TransferProtocolIfSharesToRevenuePoolRecord',
 		'LPMintRedeemRecord',
 		'LPSettleRecord',
 		'LPSwapRecord',
@@ -101,13 +97,11 @@ export type EventMap = {
 	InsuranceFundRecord: Event<InsuranceFundRecord>;
 	SpotInterestRecord: Event<SpotInterestRecord>;
 	InsuranceFundStakeRecord: Event<InsuranceFundStakeRecord>;
-	CurveRecord: Event<CurveRecord>;
+	AmmCurveChanged: Event<AmmCurveChanged>;
 	SwapRecord: Event<SwapRecord>;
 	SpotMarketVaultDepositRecord: Event<SpotMarketVaultDepositRecord>;
 	SignedMsgOrderRecord: Event<SignedMsgOrderRecord>;
 	DeleteUserRecord: Event<DeleteUserRecord>;
-	InsuranceFundSwapRecord: Event<InsuranceFundSwapRecord>;
-	TransferProtocolIfSharesToRevenuePoolRecord: Event<TransferProtocolIfSharesToRevenuePoolRecord>;
 	LPSettleRecord: Event<LPSettleRecord>;
 	LPMintRedeemRecord: Event<LPMintRedeemRecord>;
 	LPSwapRecord: Event<LPSwapRecord>;
@@ -127,22 +121,17 @@ export type VelocityEvent =
 	| Event<InsuranceFundRecord>
 	| Event<SpotInterestRecord>
 	| Event<InsuranceFundStakeRecord>
-	| Event<CurveRecord>
+	| Event<AmmCurveChanged>
 	| Event<SwapRecord>
 	| Event<SpotMarketVaultDepositRecord>
 	| Event<SignedMsgOrderRecord>
 	| Event<DeleteUserRecord>
-	| Event<InsuranceFundSwapRecord>
-	| Event<TransferProtocolIfSharesToRevenuePoolRecord>
 	| Event<LPSettleRecord>
 	| Event<LPMintRedeemRecord>
 	| Event<LPSwapRecord>
 	| Event<LPBorrowLendDepositRecord>
 	| Event<CuUsage>;
 
-/** @deprecated Use `VelocityEvent` instead. `DriftEvent` will be removed in a future major. */
-export type DriftEvent = VelocityEvent;
-
 export interface EventSubscriberEvents {
 	newEvent: (event: WrappedEvent<EventType>) => void;
 }

package/src/events/webSocketLogProvider.ts

@@ -9,7 +9,7 @@ import {
 import { EventEmitter } from 'events';
 
 export class WebSocketLogProvider implements LogProvider {
-	private subscriptionId: number;
+	private subscriptionId?: number;
 	private isUnsubscribing = false;
 	private externalUnsubscribe = false;
 	private receivingData = false;
@@ -113,8 +113,10 @@ export class WebSocketLogProvider implements LogProvider {
 				await this.unsubscribe();
 				this.receivingData = false;
 				this.reconnectAttempts++;
-				this.eventEmitter.emit('reconnect', this.reconnectAttempts);
-				this.subscribe(this.callback);
+				this.eventEmitter?.emit('reconnect', this.reconnectAttempts);
+				if (this.callback) {
+					this.subscribe(this.callback);
+				}
 			}
 		}, this.resubTimeoutMs);
 	}

package/src/factory/bigNum.ts

@@ -259,7 +259,7 @@ export class BigNum {
 		).split(BigNum.delim);
 
 		let formattedLeftSide = leftSide;
-		let formattedRightSide = rightSide;
+		let formattedRightSide: string | undefined = rightSide;
 
 		// Apply decimal override if specified
 		if (decimalOverride !== undefined) {
@@ -658,7 +658,7 @@ export class BigNum {
 		precision?: BN | number | string
 	): BigNum {
 		assert(
-			new BN(precision).lt(new BN(100)),
+			new BN(precision ?? 0).lt(new BN(100)),
 			'Tried to create a bignum with precision higher than 10^100'
 		);
 		return new BigNum(val, precision);