@velocity-exchange/sdk 0.1.0 → 0.2.1

package/src/math/spotPosition.ts

@@ -25,14 +25,14 @@ export type OrderFillSimulation = {
 	tokenValue: BN;
 	weight: BN;
 	weightedTokenValue: BN;
-	freeCollateralContribution;
+	freeCollateralContribution: BN;
 };
 
 export function getWorstCaseTokenAmounts(
 	spotPosition: SpotPosition,
 	spotMarketAccount: SpotMarketAccount,
 	strictOraclePrice: StrictOraclePrice,
-	marginCategory: MarginCategory,
+	marginCategory: MarginCategory | undefined,
 	customMarginRatio?: number,
 	includeOpenOrders: boolean = true
 ): OrderFillSimulation {
@@ -108,7 +108,7 @@ export function calculateWeightedTokenValue(
 	tokenValue: BN,
 	oraclePrice: BN,
 	spotMarket: SpotMarketAccount,
-	marginCategory: MarginCategory,
+	marginCategory: MarginCategory | undefined,
 	customMarginRatio?: number
 ): { weight: BN; weightedTokenValue: BN } {
 	let weight: BN;
@@ -158,7 +158,7 @@ export function simulateOrderFill(
 	openOrders: BN,
 	strictOraclePrice: StrictOraclePrice,
 	spotMarket: SpotMarketAccount,
-	marginCategory: MarginCategory,
+	marginCategory: MarginCategory | undefined,
 	customMarginRatio?: number
 ): OrderFillSimulation {
 	const ordersValue = getTokenValue(openOrders.neg(), spotMarket.decimals, {

package/src/math/state.ts

@@ -38,11 +38,3 @@ export function useMedianTriggerPrice(stateAccount: StateAccount): boolean {
 		(stateAccount.featureBitFlags & FeatureBitFlags.MEDIAN_TRIGGER_PRICE) > 0
 	);
 }
-
-export function builderCodesEnabled(stateAccount: StateAccount): boolean {
-	return (stateAccount.featureBitFlags & FeatureBitFlags.BUILDER_CODES) > 0;
-}
-
-export function builderReferralEnabled(stateAccount: StateAccount): boolean {
-	return (stateAccount.featureBitFlags & FeatureBitFlags.BUILDER_REFERRAL) > 0;
-}

package/src/math/superStake.ts

@@ -95,7 +95,7 @@ export async function findBestSuperStakeIxs({
 	} else if (marketIndex === 8) {
 		return findBestLstSuperStakeIxs({
 			amount,
-			lstMint: velocityClient.getSpotMarketAccount(8).mint,
+			lstMint: velocityClient.getSpotMarketAccountOrThrow(8).mint,
 			lstMarketIndex: 8,
 			jupiterClient,
 			velocityClient,
@@ -137,10 +137,10 @@ export async function findBestMSolSuperStakeIxs({
 		price = await getMarinadeMSolPrice(marinadeProgram);
 	}
 
-	const solSpotMarketAccount = velocityClient.getSpotMarketAccount(1);
-	const mSolSpotMarketAccount = velocityClient.getSpotMarketAccount(2);
+	const solSpotMarketAccount = velocityClient.getSpotMarketAccountOrThrow(1);
+	const mSolSpotMarketAccount = velocityClient.getSpotMarketAccountOrThrow(2);
 
-	let jupiterPrice: number;
+	let jupiterPrice: number | undefined;
 	let quote = jupiterQuote;
 	if (!jupiterQuote) {
 		try {
@@ -152,7 +152,7 @@ export async function findBestMSolSuperStakeIxs({
 				onlyDirectRoutes,
 			});
 
-			jupiterPrice = +quote.outAmount / +quote.inAmount;
+			jupiterPrice = +fetchedQuote.outAmount / +fetchedQuote.inAmount;
 
 			quote = fetchedQuote;
 		} catch (e) {
@@ -216,7 +216,7 @@ export async function findBestJitoSolSuperStakeIxs({
 		velocityClient,
 		userAccountPublicKey,
 		onlyDirectRoutes,
-		lstMint: velocityClient.getSpotMarketAccount(6).mint,
+		lstMint: velocityClient.getSpotMarketAccountOrThrow(6).mint,
 		lstMarketIndex: 6,
 		jupiterQuote,
 	});
@@ -326,63 +326,6 @@ export async function fetchJitoSolMetrics() {
 	return data;
 }
 
-export type MSOL_METRICS_ENDPOINT_RESPONSE = {
-	total_active_balance: number;
-	available_reserve_balance: number;
-	emergency_cooling_down: number;
-	tvl_sol: number;
-	msol_directed_stake_sol: number;
-	msol_directed_stake_msol: number;
-	mnde_total_supply: number;
-	mnde_circulating_supply: number;
-	validators_count: number;
-	stake_accounts: number;
-	staking_sol_cap: number;
-	m_sol_price: number;
-	avg_staking_apy: number;
-	msol_price_apy_14d: number;
-	msol_price_apy_30d: number;
-	msol_price_apy_90d: number;
-	msol_price_apy_365d: number;
-	reserve_pda: number;
-	treasury_m_sol_amount: number;
-	m_sol_mint_supply: number;
-	m_sol_supply_state: number;
-	liq_pool_sol: number;
-	liq_pool_m_sol: number;
-	liq_pool_value: number;
-	liq_pool_token_supply: number;
-	liq_pool_token_price: number;
-	liq_pool_target: number;
-	liq_pool_min_fee: number;
-	liq_pool_max_fee: number;
-	liq_pool_current_fee: number;
-	liq_pool_treasury_cut: number;
-	liq_pool_cap: number;
-	total_cooling_down: number;
-	last_stake_delta_epoch: number;
-	circulating_ticket_count: number;
-	circulating_ticket_balance: number;
-	reward_fee_bp: number;
-	lido_staking: number;
-	lido_st_sol_price: number;
-	lido_stsol_price_apy_14d: number;
-	lido_stsol_price_apy_30d: number;
-	lido_stsol_price_apy_90d: number;
-	lido_stsol_price_apy_365d: number;
-	stake_delta: number;
-	bot_balance: number;
-	treasury_farm_claim_mnde_balance: number;
-	last_3_epochs_avg_duration_hs: number;
-	mnde_votes_validators: number;
-};
-
-export const fetchMSolMetrics = async () => {
-	const res = await fetch('https://api2.marinade.finance/metrics_json');
-	const data: MSOL_METRICS_ENDPOINT_RESPONSE = await res.json();
-	return data;
-};
-
 const getJitoSolHistoricalPriceMap = async (timestamps: number[]) => {
 	try {
 		const data = await fetchJitoSolMetrics();
@@ -436,7 +379,7 @@ export async function calculateSolEarned({
 
 	let lstRatios = new Map<number, number>();
 
-	const getMsolPrice = async (timestamp) => {
+	const getMsolPrice = async (timestamp: number) => {
 		const date = new Date(timestamp * 1000); // Convert Unix timestamp to milliseconds
 		const swaggerApiDateTime = date.toISOString(); // Format date as swagger API date-time
 		const url = `https://api.marinade.finance/msol/price_sol?time=${swaggerApiDateTime}`;
@@ -465,7 +408,10 @@ export async function calculateSolEarned({
 	if (marketIndex === 2) {
 		await Promise.all(timestamps.map(getMsolPrice));
 	} else if (marketIndex === 6) {
-		lstRatios = await getJitoSolHistoricalPriceMap(timestamps);
+		const jitoSolRatios = await getJitoSolHistoricalPriceMap(timestamps);
+		if (jitoSolRatios) {
+			lstRatios = jitoSolRatios;
+		}
 	} else if (marketIndex === 8) {
 		await getBSolPrice(timestamps);
 	}
@@ -484,6 +430,11 @@ export async function calculateSolEarned({
 			record.marketIndex === 8
 		) {
 			const lstRatio = lstRatios.get(record.ts.toNumber());
+			if (lstRatio === undefined) {
+				throw new Error(
+					`Missing LST/SOL ratio for deposit record at timestamp ${record.ts.toNumber()}`
+				);
+			}
 			const lstRatioBN = new BN(lstRatio * LAMPORTS_PER_SOL);
 
 			const solAmount = record.amount.mul(lstRatioBN).div(LAMPORTS_PRECISION);
@@ -497,6 +448,9 @@ export async function calculateSolEarned({
 
 	const currentLstTokenAmount = await user.getTokenAmount(marketIndex);
 	const currentLstRatio = lstRatios.get(now);
+	if (currentLstRatio === undefined) {
+		throw new Error(`Missing current LST/SOL ratio for timestamp ${now}`);
+	}
 	const currentLstRatioBN = new BN(currentLstRatio * LAMPORTS_PER_SOL);
 
 	solEarned = solEarned.add(

package/src/math/trade.ts

@@ -114,7 +114,6 @@ export function calculateTradeSlippage(
 			calculateUpdatedAMMSpreadReserves(
 				market.amm,
 				market.marketStats,
-				market.totalExchangeFee,
 				direction,
 				mmOraclePriceData,
 				latestSlot
@@ -187,7 +186,6 @@ export function calculateTradeAcquiredAmounts(
 			calculateUpdatedAMMSpreadReserves(
 				market.amm,
 				market.marketStats,
-				market.totalExchangeFee,
 				direction,
 				mmOraclePriceData,
 				latestSlot
@@ -279,7 +277,6 @@ export function calculateTargetPriceTrade(
 			calculateUpdatedAMMSpreadReserves(
 				market.amm,
 				market.marketStats,
-				market.totalExchangeFee,
 				direction,
 				mmOraclePriceData,
 				latestSlot
@@ -376,7 +373,7 @@ export function calculateTargetPriceTrade(
 
 	assert(tp1.sub(tp2).lte(originalDiff), 'Target Price Calculation incorrect');
 	assert(
-		tp2.lte(tp1) || tp2.sub(tp1).abs() < 100000,
+		tp2.lte(tp1) || tp2.sub(tp1).abs().ltn(100000),
 		'Target Price Calculation incorrect' +
 			tp2.toString() +
 			'>=' +
@@ -443,7 +440,6 @@ export function calculateEstimatedPerpEntryPrice(
 		calculateUpdatedAMMSpreadReserves(
 			market.amm,
 			market.marketStats,
-			market.totalExchangeFee,
 			direction,
 			mmOraclePriceData,
 			new BN(slot)
@@ -493,7 +489,7 @@ export function calculateEstimatedPerpEntryPrice(
 
 	let limitOrder = limitOrders.next().value;
 	if (limitOrder) {
-		const limitOrderPrice = limitOrder.getPrice(mmOraclePriceData, slot);
+		const limitOrderPrice = limitOrder.getPriceOrThrow(mmOraclePriceData, slot);
 		bestPrice = takerIsLong
 			? BN.min(limitOrderPrice, bestPrice)
 			: BN.max(limitOrderPrice, bestPrice);

package/src/memcmp.ts

@@ -48,15 +48,6 @@ export function getUserWithAuctionFilter(): MemcmpFilter {
 	};
 }
 
-export function getUserThatHasBeenLP(): MemcmpFilter {
-	return {
-		memcmp: {
-			offset: 4267,
-			bytes: bs58.encode(Uint8Array.from([99])),
-		},
-	};
-}
-
 export function getUserWithName(name: string): MemcmpFilter {
 	return {
 		memcmp: {

package/src/oracles/prelaunchOracleClient.ts

@@ -2,6 +2,7 @@ import { Connection, PublicKey } from '@solana/web3.js';
 import { OracleClient, OraclePriceData } from './types';
 import { VelocityProgram } from '../config';
 import { PrelaunchOracle } from '../types';
+import { getOracleAccountDataOrThrow } from './utils';
 
 export class PrelaunchOracleClient implements OracleClient {
 	private connection: Connection;
@@ -15,8 +16,12 @@ export class PrelaunchOracleClient implements OracleClient {
 	public async getOraclePriceData(
 		pricePublicKey: PublicKey
 	): Promise<OraclePriceData> {
-		const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
-		return this.getOraclePriceDataFromBuffer(accountInfo.data);
+		const data = await getOracleAccountDataOrThrow(
+			this.connection,
+			pricePublicKey,
+			'Prelaunch oracle'
+		);
+		return this.getOraclePriceDataFromBuffer(data);
 	}
 
 	public getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData {

package/src/oracles/pythClient.ts

@@ -8,6 +8,7 @@ import {
 	QUOTE_PRECISION,
 	TEN,
 } from '../constants/numericConstants';
+import { getOracleAccountDataOrThrow } from './utils';
 
 export class PythClient implements OracleClient {
 	private connection: Connection;
@@ -27,14 +28,22 @@ export class PythClient implements OracleClient {
 	public async getOraclePriceData(
 		pricePublicKey: PublicKey
 	): Promise<OraclePriceData> {
-		const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
-		return this.getOraclePriceDataFromBuffer(accountInfo.data);
+		const data = await getOracleAccountDataOrThrow(
+			this.connection,
+			pricePublicKey,
+			'Pyth oracle'
+		);
+		return this.getOraclePriceDataFromBuffer(data);
 	}
 
 	public getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData {
 		const priceData = parsePriceData(buffer);
+		// `confidence` is absent on uninitialized/invalid price accounts. Base passed it
+		// straight into convertPythPrice, where `undefined * 10**exponent` is `NaN` and
+		// `new BN(NaN)` coerces to 0 — so base already yielded a zero-confidence price.
+		// `?? 0` makes that explicit and type-checks, preserving the same result.
 		const confidence = convertPythPrice(
-			priceData.confidence,
+			priceData.confidence ?? 0,
 			priceData.exponent,
 			this.multiple
 		);

package/src/oracles/pythLazerClient.ts

@@ -11,6 +11,7 @@ import {
 } from '../constants/numericConstants';
 import { Wallet } from '../wallet';
 import velocityIDL from '../idl/velocity.json';
+import { getOracleAccountDataOrThrow } from './utils';
 
 export class PythLazerClient implements OracleClient {
 	private connection: Connection;
@@ -46,8 +47,12 @@ export class PythLazerClient implements OracleClient {
 	public async getOraclePriceData(
 		pricePublicKey: PublicKey
 	): Promise<OraclePriceData> {
-		const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
-		return this.getOraclePriceDataFromBuffer(accountInfo.data);
+		const data = await getOracleAccountDataOrThrow(
+			this.connection,
+			pricePublicKey,
+			'Pyth lazer oracle'
+		);
+		return this.getOraclePriceDataFromBuffer(data);
 	}
 
 	public getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData {

package/src/oracles/utils.ts

@@ -1,6 +1,21 @@
+import { Connection, PublicKey } from '@solana/web3.js';
 import { BN } from '../isomorphic/anchor';
 import { OraclePriceData } from './types';
 
+export async function getOracleAccountDataOrThrow(
+	connection: Connection,
+	pricePublicKey: PublicKey,
+	oracleName: string
+): Promise<Buffer> {
+	const accountInfo = await connection.getAccountInfo(pricePublicKey);
+	if (!accountInfo) {
+		throw new Error(
+			`${oracleName} account not found: ${pricePublicKey.toBase58()}`
+		);
+	}
+	return accountInfo.data;
+}
+
 export function getOracleConfidenceFromMMOracleData(
 	mmOraclePrice: BN,
 	oraclePriceData: OraclePriceData

package/src/orderSubscriber/OrderSubscriber.ts

@@ -27,9 +27,9 @@ export class OrderSubscriber {
 	eventEmitter: StrictEventEmitter<EventEmitter, OrderSubscriberEvents>;
 
 	fetchPromise?: Promise<void>;
-	fetchPromiseResolver: () => void;
+	private fetchPromiseResolver: () => void = () => {};
 
-	mostRecentSlot: number;
+	mostRecentSlot = 0;
 	decodeFn: (name: string, data: Buffer) => UserAccount;
 	decodeData?: boolean;
 
@@ -276,7 +276,7 @@ export class OrderSubscriber {
 				userAccountPublicKey,
 				this.commitment
 			);
-		if (accountInfo) {
+		if (accountInfo.value) {
 			this.tryUpdateUserAccount(
 				userAccountPublicKey.toString(),
 				'buffer',
@@ -290,7 +290,13 @@ export class OrderSubscriber {
 		if (!this.usersAccounts.has(key)) {
 			await this.addPubkey(new PublicKey(key));
 		}
-		return this.usersAccounts.get(key).userAccount;
+		const slotAndUserAccount = this.usersAccounts.get(key);
+		if (!slotAndUserAccount) {
+			throw new Error(
+				`OrderSubscriber: user account ${key} not found after addPubkey`
+			);
+		}
+		return slotAndUserAccount.userAccount;
 	}
 
 	public async unsubscribe(): Promise<void> {

package/src/priorityFee/heliusPriorityFeeMethod.ts

@@ -28,7 +28,7 @@ export async function fetchHeliusPriorityFee(
 	heliusRpcUrl: string,
 	lookbackDistance: number,
 	addresses: string[]
-): Promise<HeliusPriorityFeeResponse> {
+): Promise<HeliusPriorityFeeResponse | undefined> {
 	try {
 		const response = await fetch(heliusRpcUrl, {
 			method: 'POST',

package/src/priorityFee/priorityFeeSubscriber.ts

@@ -19,7 +19,7 @@ import {
 } from './velocityPriorityFeeMethod';
 
 export class PriorityFeeSubscriber {
-	connection: Connection;
+	connection?: Connection;
 	frequencyMs: number;
 	addresses: string[];
 	velocityMarkets?: VelocityMarketInfo[];
@@ -64,7 +64,7 @@ export class PriorityFeeSubscriber {
 
 			if (this.priorityFeeMethod === PriorityFeeMethod.HELIUS) {
 				if (config.heliusRpcUrl === undefined) {
-					if (this.connection.rpcEndpoint.includes('helius')) {
+					if (this.connection?.rpcEndpoint.includes('helius')) {
 						this.heliusRpcUrl = this.connection.rpcEndpoint;
 					} else {
 						throw new Error(
@@ -103,11 +103,19 @@ export class PriorityFeeSubscriber {
 	}
 
 	private async loadForSolana(): Promise<void> {
+		if (this.connection === undefined) {
+			throw new Error(
+				'connection must be provided to use SOLANA priority fee API'
+			);
+		}
 		const samples = await fetchSolanaPriorityFee(
-			this.connection!,
+			this.connection,
 			this.lookbackDistance,
 			this.addresses
 		);
+		if (samples === undefined) {
+			throw new Error('fetchSolanaPriorityFee returned no samples');
+		}
 		if (samples.length > 0) {
 			this.latestPriorityFee = samples[0].prioritizationFee;
 			this.lastSlotSeen = samples[0].slot;
@@ -121,6 +129,11 @@ export class PriorityFeeSubscriber {
 	}
 
 	private async loadForHelius(): Promise<void> {
+		if (this.heliusRpcUrl === undefined) {
+			throw new Error(
+				'heliusRpcUrl must be provided to use PriorityFeeMethod.HELIUS'
+			);
+		}
 		const sample = await fetchHeliusPriorityFee(
 			this.heliusRpcUrl,
 			this.lookbackDistance,
@@ -128,13 +141,13 @@ export class PriorityFeeSubscriber {
 		);
 		this.lastHeliusSample = sample?.result?.priorityFeeLevels ?? undefined;
 
-		if (this.lastHeliusSample) {
+		if (sample !== undefined && this.lastHeliusSample) {
 			this.lastAvgStrategyResult =
 				this.lastHeliusSample[HeliusPriorityLevel.MEDIUM];
 			this.lastMaxStrategyResult =
 				this.lastHeliusSample[HeliusPriorityLevel.UNSAFE_MAX];
 			if (this.customStrategy) {
-				this.lastCustomStrategyResult = this.customStrategy.calculate(sample!);
+				this.lastCustomStrategyResult = this.customStrategy.calculate(sample);
 			}
 		}
 	}
@@ -143,16 +156,39 @@ export class PriorityFeeSubscriber {
 		if (!this.velocityMarkets) {
 			return;
 		}
+		if (this.velocityPriorityFeeEndpoint === undefined) {
+			throw new Error(
+				'velocityPriorityFeeEndpoint must be provided to use PriorityFeeMethod.VELOCITY'
+			);
+		}
 		const sample = await fetchVelocityPriorityFee(
-			this.velocityPriorityFeeEndpoint!,
+			this.velocityPriorityFeeEndpoint,
 			this.velocityMarkets.map((m) => m.marketType),
 			this.velocityMarkets.map((m) => m.marketIndex)
 		);
 		if (sample.length > 0) {
-			this.lastAvgStrategyResult = sample[HeliusPriorityLevel.MEDIUM];
-			this.lastMaxStrategyResult = sample[HeliusPriorityLevel.UNSAFE_MAX];
+			// The endpoint returns one fee-level set per requested market. Take the
+			// max level across markets so a transaction touching several markets is
+			// covered by the most expensive one. (Base indexed the array itself with
+			// a string enum key — `sample['medium']` — which yielded `undefined` and
+			// produced NaN strategy results; the missing per-element index is fixed
+			// here.)
+			this.lastAvgStrategyResult = Math.max(
+				...sample.map((s) => s[HeliusPriorityLevel.MEDIUM])
+			);
+			this.lastMaxStrategyResult = Math.max(
+				...sample.map((s) => s[HeliusPriorityLevel.UNSAFE_MAX])
+			);
 			if (this.customStrategy) {
-				this.lastCustomStrategyResult = this.customStrategy.calculate(sample);
+				// Custom strategies expect `{ slot, prioritizationFee }[]`; map each
+				// market's medium level into that shape so they aggregate real values
+				// instead of summing the absent `prioritizationFee` field (NaN).
+				this.lastCustomStrategyResult = this.customStrategy.calculate(
+					sample.map((s) => ({
+						slot: 0,
+						prioritizationFee: s[HeliusPriorityLevel.MEDIUM],
+					}))
+				);
 			}
 		}
 	}

package/src/priorityFee/solanaPriorityFeeMethod.ts

@@ -9,7 +9,7 @@ export async function fetchSolanaPriorityFee(
 	connection: Connection,
 	lookbackDistance: number,
 	addresses: string[]
-): Promise<SolanaPriorityFeeResponse[]> {
+): Promise<SolanaPriorityFeeResponse[] | undefined> {
 	try {
 		// @ts-ignore
 		const rpcJSONResponse: any = await connection._rpcRequest(

package/src/pyth/types.ts

@@ -4445,8 +4445,6 @@ export const IDL: PythSolanaReceiver = {
 		},
 	],
 };
-
-export declare const PYTH_SOLANA_RECEIVER_IDL: PythSolanaReceiver;
 //# sourceMappingURL=pyth_solana_receiver.d.ts.map
 
 export type PriceUpdateAccount =

package/src/slot/SlotSubscriber.ts

@@ -12,8 +12,8 @@ export interface SlotSubscriberEvents {
 }
 
 export class SlotSubscriber {
-	currentSlot: number;
-	subscriptionId: number;
+	currentSlot = 0;
+	subscriptionId?: number;
 	eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
 
 	// Reconnection
@@ -28,7 +28,7 @@ export class SlotSubscriber {
 	) {
 		this.eventEmitter = new EventEmitter();
 		this.resubTimeoutMs = config?.resubTimeoutMs;
-		if (this.resubTimeoutMs < 1000) {
+		if (this.resubTimeoutMs !== undefined && this.resubTimeoutMs < 1000) {
 			console.log(
 				'resubTimeoutMs should be at least 1000ms to avoid spamming resub'
 			);

package/src/slot/SlothashSubscriber.ts

@@ -18,8 +18,16 @@ export type Slothash = {
 };
 
 export class SlothashSubscriber {
-	currentSlothash: Slothash;
-	subscriptionId: number;
+	private _currentSlothash?: Slothash;
+	private get currentSlothash(): Slothash {
+		if (!this._currentSlothash) {
+			throw new Error(
+				'SlothashSubscriber: slothash accessed before subscribe()'
+			);
+		}
+		return this._currentSlothash;
+	}
+	subscriptionId?: number;
 	commitment: Commitment;
 
 	// Reconnection
@@ -34,7 +42,7 @@ export class SlothashSubscriber {
 	) {
 		this.resubTimeoutMs = config?.resubTimeoutMs;
 		this.commitment = config?.commitment ?? 'processed';
-		if (this.resubTimeoutMs < 1000) {
+		if (this.resubTimeoutMs != null && this.resubTimeoutMs < 1000) {
 			console.log(
 				'resubTimeoutMs should be at least 1000ms to avoid spamming resub'
 			);
@@ -53,18 +61,21 @@ export class SlothashSubscriber {
 		if (currentAccountData == null) {
 			throw new Error('Failed to retrieve current slot hash');
 		}
-		this.currentSlothash = deserializeSlothash(currentAccountData.data);
+		this._currentSlothash = deserializeSlothash(currentAccountData.data);
 
 		this.subscriptionId = this.connection.onAccountChange(
 			SYSVAR_SLOT_HASHES_PUBKEY,
 			(slothashInfo, context) => {
-				if (!this.currentSlothash || this.currentSlothash.slot < context.slot) {
+				if (
+					!this._currentSlothash ||
+					this._currentSlothash.slot < context.slot
+				) {
 					if (this.resubTimeoutMs && !this.isUnsubscribing) {
 						this.receivingData = true;
 						clearTimeout(this.timeoutId);
 						this.setTimeout();
 					}
-					this.currentSlothash = deserializeSlothash(slothashInfo.data);
+					this._currentSlothash = deserializeSlothash(slothashInfo.data);
 				}
 			},
 			this.commitment

package/src/swift/grpcSignedMsgUserAccountSubscriber.ts

@@ -10,7 +10,6 @@ import {
 
 export class grpcSignedMsgUserOrdersAccountSubscriber extends SignedMsgUserOrdersAccountSubscriber {
 	private grpcConfigs: GrpcConfigs;
-	override subscriber: grpcProgramAccountSubscriber<SignedMsgUserOrdersAccount>;
 
 	constructor({
 		grpcConfigs,
@@ -23,8 +22,8 @@ export class grpcSignedMsgUserOrdersAccountSubscriber extends SignedMsgUserOrder
 	}
 
 	public async subscribe(): Promise<void> {
-		if (!this.subscriber) {
-			this.subscriber =
+		if (!this._subscriber) {
+			this._subscriber =
 				await grpcProgramAccountSubscriber.create<SignedMsgUserOrdersAccount>(
 					this.grpcConfigs,
 					'SingedMsgUserOrdersAccountMap',
@@ -71,9 +70,9 @@ export class grpcSignedMsgUserOrdersAccountSubscriber extends SignedMsgUserOrder
 	}
 
 	public async unsubscribe(): Promise<void> {
-		if (!this.subscriber) return;
-		await this.subscriber.unsubscribe();
-		this.subscriber = undefined;
+		if (!this._subscriber) return;
+		await this._subscriber.unsubscribe();
+		this._subscriber = undefined;
 		if (this.resyncTimeoutId !== undefined) {
 			clearTimeout(this.resyncTimeoutId);
 			this.resyncTimeoutId = undefined;