@drift-labs/sdk-browser 2.104.0-beta.21

package/src/blockhashSubscriber/BlockhashSubscriber.ts

@@ -0,0 +1,126 @@
+import {
+	BlockhashWithExpiryBlockHeight,
+	Commitment,
+	Connection,
+	Context,
+} from '@solana/web3.js';
+import { BlockhashSubscriberConfig } from './types';
+
+export class BlockhashSubscriber {
+	private connection: Connection;
+	private isSubscribed = false;
+	private latestBlockHeight: number;
+	private latestBlockHeightContext: Context | undefined;
+	private blockhashes: Array<BlockhashWithExpiryBlockHeight> = [];
+	private updateBlockhashIntervalId: NodeJS.Timeout | undefined;
+	private commitment: Commitment;
+	private updateIntervalMs: number;
+
+	constructor(config: BlockhashSubscriberConfig) {
+		if (!config.connection && !config.rpcUrl) {
+			throw new Error(
+				'BlockhashSubscriber requires one of connection or rpcUrl must be provided'
+			);
+		}
+		this.connection = config.connection || new Connection(config.rpcUrl!);
+		this.commitment = config.commitment ?? 'confirmed';
+		this.updateIntervalMs = config.updateIntervalMs ?? 1000;
+	}
+
+	getBlockhashCacheSize(): number {
+		return this.blockhashes.length;
+	}
+
+	getLatestBlockHeight(): number {
+		return this.latestBlockHeight;
+	}
+
+	getLatestBlockHeightContext(): Context | undefined {
+		return this.latestBlockHeightContext;
+	}
+
+	/**
+	 * Returns the latest cached blockhash, based on an offset from the latest obtained
+	 * @param offset Offset to use, defaulting to 0
+	 * @param offsetType If 'seconds', it will use calculate the actual element offset based on the update interval; otherwise it will return a fixed index
+	 * @returns Cached blockhash at the given offset, or undefined
+	 */
+	getLatestBlockhash(
+		offset = 0,
+		offsetType: 'index' | 'seconds' = 'index'
+	): BlockhashWithExpiryBlockHeight | undefined {
+		if (this.blockhashes.length === 0) {
+			return undefined;
+		}
+
+		const elementOffset =
+			offsetType == 'seconds'
+				? Math.floor((offset * 1000) / this.updateIntervalMs)
+				: offset;
+
+		const clampedOffset = Math.max(
+			0,
+			Math.min(this.blockhashes.length - 1, elementOffset)
+		);
+
+		return this.blockhashes[this.blockhashes.length - 1 - clampedOffset];
+	}
+
+	pruneBlockhashes() {
+		if (this.latestBlockHeight) {
+			this.blockhashes = this.blockhashes.filter(
+				(blockhash) => blockhash.lastValidBlockHeight > this.latestBlockHeight!
+			);
+		}
+	}
+
+	async updateBlockhash() {
+		try {
+			const [resp, lastConfirmedBlockHeight] = await Promise.all([
+				this.connection.getLatestBlockhashAndContext({
+					commitment: this.commitment,
+				}),
+				this.connection.getBlockHeight({ commitment: this.commitment }),
+			]);
+			this.latestBlockHeight = lastConfirmedBlockHeight;
+			this.latestBlockHeightContext = resp.context;
+
+			// avoid caching duplicate blockhashes
+			if (this.blockhashes.length > 0) {
+				if (
+					resp.value.blockhash ===
+					this.blockhashes[this.blockhashes.length - 1].blockhash
+				) {
+					return;
+				}
+			}
+
+			this.blockhashes.push(resp.value);
+		} catch (e) {
+			console.error('Error updating blockhash:\n', e);
+		} finally {
+			this.pruneBlockhashes();
+		}
+	}
+
+	async subscribe() {
+		if (this.isSubscribed) {
+			return;
+		}
+		this.isSubscribed = true;
+
+		await this.updateBlockhash();
+		this.updateBlockhashIntervalId = setInterval(
+			this.updateBlockhash.bind(this),
+			this.updateIntervalMs
+		);
+	}
+
+	unsubscribe() {
+		if (this.updateBlockhashIntervalId) {
+			clearInterval(this.updateBlockhashIntervalId);
+			this.updateBlockhashIntervalId = undefined;
+		}
+		this.isSubscribed = false;
+	}
+}

package/src/blockhashSubscriber/index.ts

@@ -0,0 +1 @@
+export * from './BlockhashSubscriber';

package/src/blockhashSubscriber/types.ts

@@ -0,0 +1,12 @@
+import { Commitment, Connection } from '@solana/web3.js';
+
+export type BlockhashSubscriberConfig = {
+	/// rpcUrl to poll block hashes from, one of rpcUrl or Connection must provided
+	rpcUrl?: string;
+	/// connection to poll block hashes from, one of rpcUrl or Connection must provided
+	connection?: Connection;
+	/// commitment to poll block hashes with, default is 'confirmed'
+	commitment?: Commitment;
+	/// interval to poll block hashes, default is 1000 ms
+	updateIntervalMs?: number;
+};

package/src/clock/clockSubscriber.ts

@@ -0,0 +1,121 @@
+import { Commitment, Connection, SYSVAR_CLOCK_PUBKEY } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types/types/src';
+import { BN } from '..';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type ClockSubscriberConfig = {
+	commitment: Commitment;
+	resubTimeoutMs?: number;
+};
+
+export interface ClockSubscriberEvent {
+	clockUpdate: (ts: number) => void;
+}
+
+export class ClockSubscriber {
+	private _latestSlot: number;
+	private _currentTs: number;
+	private subscriptionId: number;
+	commitment: Commitment;
+	eventEmitter: StrictEventEmitter<EventEmitter, ClockSubscriberEvent>;
+
+	public get latestSlot(): number {
+		return this._latestSlot;
+	}
+
+	public get currentTs(): number {
+		return this._currentTs;
+	}
+
+	// Reconnection
+	private timeoutId?: NodeJS.Timeout;
+	private resubTimeoutMs?: number;
+	private isUnsubscribing = false;
+	private receivingData = false;
+
+	public constructor(
+		private connection: Connection,
+		config?: ClockSubscriberConfig
+	) {
+		this.eventEmitter = new EventEmitter();
+		this.resubTimeoutMs = config?.resubTimeoutMs;
+		this.commitment = config?.commitment || 'confirmed';
+		if (this.resubTimeoutMs < 1000) {
+			console.log(
+				'resubTimeoutMs should be at least 1000ms to avoid spamming resub'
+			);
+		}
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.subscriptionId != null) {
+			return;
+		}
+
+		this.subscriptionId = this.connection.onAccountChange(
+			SYSVAR_CLOCK_PUBKEY,
+			(acctInfo, context) => {
+				if (!this.latestSlot || this.latestSlot < context.slot) {
+					if (this.resubTimeoutMs && !this.isUnsubscribing) {
+						this.receivingData = true;
+						clearTimeout(this.timeoutId);
+						this.setTimeout();
+					}
+					this._latestSlot = context.slot;
+					this._currentTs = new BN(
+						acctInfo.data.subarray(32, 39),
+						undefined,
+						'le'
+					).toNumber();
+					this.eventEmitter.emit('clockUpdate', this.currentTs);
+				}
+			},
+			this.commitment
+		);
+
+		if (this.resubTimeoutMs) {
+			this.receivingData = true;
+			this.setTimeout();
+		}
+	}
+
+	private setTimeout(): void {
+		this.timeoutId = setTimeout(async () => {
+			if (this.isUnsubscribing) {
+				// If we are in the process of unsubscribing, do not attempt to resubscribe
+				return;
+			}
+
+			if (this.receivingData) {
+				console.log(
+					`No new slot in ${this.resubTimeoutMs}ms, slot subscriber resubscribing`
+				);
+				await this.unsubscribe(true);
+				this.receivingData = false;
+				await this.subscribe();
+			}
+		}, this.resubTimeoutMs);
+	}
+
+	public getUnixTs(): number {
+		return this.currentTs;
+	}
+
+	public async unsubscribe(onResub = false): Promise<void> {
+		if (!onResub) {
+			this.resubTimeoutMs = undefined;
+		}
+		this.isUnsubscribing = true;
+		clearTimeout(this.timeoutId);
+		this.timeoutId = undefined;
+
+		if (this.subscriptionId != null) {
+			await this.connection.removeAccountChangeListener(this.subscriptionId);
+			this.subscriptionId = undefined;
+			this.isUnsubscribing = false;
+		} else {
+			this.isUnsubscribing = false;
+		}
+	}
+}

package/src/config.ts

@@ -0,0 +1,212 @@
+import { ConfirmOptions } from '@solana/web3.js';
+import { PerpMarketAccount, PublicKey, SpotMarketAccount } from '.';
+import {
+	DevnetPerpMarkets,
+	MainnetPerpMarkets,
+	PerpMarketConfig,
+	PerpMarkets,
+} from './constants/perpMarkets';
+import {
+	SpotMarketConfig,
+	SpotMarkets,
+	DevnetSpotMarkets,
+	MainnetSpotMarkets,
+} from './constants/spotMarkets';
+import { OracleInfo } from './oracles/types';
+import { Program, ProgramAccount } from '@coral-xyz/anchor';
+import {
+	ON_DEMAND_DEVNET_PID,
+	ON_DEMAND_MAINNET_PID,
+} from '@switchboard-xyz/on-demand';
+import { getOracleId } from './oracles/oracleId';
+
+type DriftConfig = {
+	ENV: DriftEnv;
+	PYTH_ORACLE_MAPPING_ADDRESS: string;
+	DRIFT_PROGRAM_ID: string;
+	JIT_PROXY_PROGRAM_ID?: string;
+	DRIFT_ORACLE_RECEIVER_ID: string;
+	USDC_MINT_ADDRESS: string;
+	SERUM_V3: string;
+	PHOENIX: string;
+	OPENBOOK: string;
+	V2_ALPHA_TICKET_MINT_ADDRESS: string;
+	PERP_MARKETS: PerpMarketConfig[];
+	SPOT_MARKETS: SpotMarketConfig[];
+	MARKET_LOOKUP_TABLE: string;
+	SERUM_LOOKUP_TABLE?: string;
+	PYTH_PULL_ORACLE_LOOKUP_TABLE?: string;
+	SB_ON_DEMAND_PID: PublicKey;
+};
+
+export type DriftEnv = 'devnet' | 'mainnet-beta';
+
+export const DRIFT_PROGRAM_ID = 'dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH';
+export const DRIFT_ORACLE_RECEIVER_ID =
+	'G6EoTTTgpkNBtVXo96EQp2m6uwwVh2Kt6YidjkmQqoha';
+export const SWIFT_ID = 'SW1fThqrxLzVprnCMpiybiqYQfoNCdduC5uWsSUKChS';
+export const ANCHOR_TEST_SWIFT_ID =
+	'DpaEdAPW3ZX67fnczT14AoX12Lx9VMkxvtT81nCHy3Nv';
+export const PTYH_LAZER_PROGRAM_ID =
+	'pytd2yyk641x7ak7mkaasSJVXh6YYZnC7wTmtgAyxPt';
+export const PYTH_LAZER_STORAGE_ACCOUNT_KEY = new PublicKey(
+	'3rdJbqfnagQ4yx9HXJViD4zc4xpiSqmFsKpPuSCQVyQL'
+);
+
+export const DEFAULT_CONFIRMATION_OPTS: ConfirmOptions = {
+	preflightCommitment: 'confirmed',
+	commitment: 'confirmed',
+};
+
+export const configs: { [key in DriftEnv]: DriftConfig } = {
+	devnet: {
+		ENV: 'devnet',
+		PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
+		DRIFT_PROGRAM_ID,
+		JIT_PROXY_PROGRAM_ID: 'J1TnP8zvVxbtF5KFp5xRmWuvG9McnhzmBd9XGfCyuxFP',
+		USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
+		SERUM_V3: 'DESVgJVGajEgKGXhb6XmqDHGz3VjdgP7rEVESBgxmroY',
+		PHOENIX: 'PhoeNiXZ8ByJGLkxNfZRnkUfjvmuYqLR89jjFHGqdXY',
+		OPENBOOK: 'opnb2LAfJYbRMAHHvqjCwQxanZn7ReEHp1k81EohpZb',
+		V2_ALPHA_TICKET_MINT_ADDRESS:
+			'DeEiGWfCMP9psnLGkxGrBBMEAW5Jv8bBGMN8DCtFRCyB',
+		PERP_MARKETS: DevnetPerpMarkets,
+		SPOT_MARKETS: DevnetSpotMarkets,
+		MARKET_LOOKUP_TABLE: 'FaMS3U4uBojvGn5FSDEPimddcXsCfwkKsFgMVVnDdxGb',
+		DRIFT_ORACLE_RECEIVER_ID,
+		SB_ON_DEMAND_PID: ON_DEMAND_DEVNET_PID,
+	},
+	'mainnet-beta': {
+		ENV: 'mainnet-beta',
+		PYTH_ORACLE_MAPPING_ADDRESS: 'AHtgzX45WTKfkPG53L6WYhGEXwQkN1BVknET3sVsLL8J',
+		DRIFT_PROGRAM_ID,
+		JIT_PROXY_PROGRAM_ID: 'J1TnP8zvVxbtF5KFp5xRmWuvG9McnhzmBd9XGfCyuxFP',
+		USDC_MINT_ADDRESS: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+		SERUM_V3: 'srmqPvymJeFKQ4zGQed1GFppgkRHL9kaELCbyksJtPX',
+		PHOENIX: 'PhoeNiXZ8ByJGLkxNfZRnkUfjvmuYqLR89jjFHGqdXY',
+		OPENBOOK: 'opnb2LAfJYbRMAHHvqjCwQxanZn7ReEHp1k81EohpZb',
+		V2_ALPHA_TICKET_MINT_ADDRESS:
+			'Cmvhycb6LQvvzaShGw4iDHRLzeSSryioAsU98DSSkMNa',
+		PERP_MARKETS: MainnetPerpMarkets,
+		SPOT_MARKETS: MainnetSpotMarkets,
+		MARKET_LOOKUP_TABLE: 'Fpys8GRa5RBWfyeN7AaDUwFGD1zkDCA4z3t4CJLV8dfL',
+		SERUM_LOOKUP_TABLE: 'GPZkp76cJtNL2mphCvT6FXkJCVPpouidnacckR6rzKDN',
+		DRIFT_ORACLE_RECEIVER_ID,
+		SB_ON_DEMAND_PID: ON_DEMAND_MAINNET_PID,
+	},
+};
+
+let currentConfig: DriftConfig = configs.devnet;
+
+export const getConfig = (): DriftConfig => currentConfig;
+
+/**
+ * Allows customization of the SDK's environment and endpoints. You can pass individual settings to override the settings with your own presets.
+ *
+ * Defaults to master environment if you don't use this function.
+ * @param props
+ * @returns
+ */
+export const initialize = (props: {
+	env: DriftEnv;
+	overrideEnv?: Partial<DriftConfig>;
+}): DriftConfig => {
+	//@ts-ignore
+	if (props.env === 'master')
+		return { ...configs['devnet'], ...(props.overrideEnv ?? {}) };
+
+	currentConfig = { ...configs[props.env], ...(props.overrideEnv ?? {}) };
+
+	return currentConfig;
+};
+
+export function getMarketsAndOraclesForSubscription(
+	env: DriftEnv,
+	perpMarkets?: PerpMarketConfig[],
+	spotMarkets?: SpotMarketConfig[]
+): {
+	perpMarketIndexes: number[];
+	spotMarketIndexes: number[];
+	oracleInfos: OracleInfo[];
+} {
+	const perpMarketsToUse =
+		perpMarkets?.length > 0 ? perpMarkets : PerpMarkets[env];
+	const spotMarketsToUse =
+		spotMarkets?.length > 0 ? spotMarkets : SpotMarkets[env];
+
+	const perpMarketIndexes = [];
+	const spotMarketIndexes = [];
+	const oracleInfos = new Map<string, OracleInfo>();
+
+	for (const market of perpMarketsToUse) {
+		perpMarketIndexes.push(market.marketIndex);
+		oracleInfos.set(getOracleId(market.oracle, market.oracleSource), {
+			publicKey: market.oracle,
+			source: market.oracleSource,
+		});
+	}
+
+	for (const spotMarket of spotMarketsToUse) {
+		spotMarketIndexes.push(spotMarket.marketIndex);
+		oracleInfos.set(getOracleId(spotMarket.oracle, spotMarket.oracleSource), {
+			publicKey: spotMarket.oracle,
+			source: spotMarket.oracleSource,
+		});
+	}
+
+	return {
+		perpMarketIndexes: perpMarketIndexes,
+		spotMarketIndexes: spotMarketIndexes,
+		oracleInfos: Array.from(oracleInfos.values()),
+	};
+}
+
+export async function findAllMarketAndOracles(program: Program): Promise<{
+	perpMarketIndexes: number[];
+	perpMarketAccounts: PerpMarketAccount[];
+	spotMarketIndexes: number[];
+	oracleInfos: OracleInfo[];
+	spotMarketAccounts: SpotMarketAccount[];
+}> {
+	const perpMarketIndexes = [];
+	const spotMarketIndexes = [];
+	const oracleInfos = new Map<string, OracleInfo>();
+
+	const perpMarketProgramAccounts =
+		(await program.account.perpMarket.all()) as ProgramAccount<PerpMarketAccount>[];
+	const spotMarketProgramAccounts =
+		(await program.account.spotMarket.all()) as ProgramAccount<SpotMarketAccount>[];
+
+	for (const perpMarketProgramAccount of perpMarketProgramAccounts) {
+		const perpMarket = perpMarketProgramAccount.account as PerpMarketAccount;
+		perpMarketIndexes.push(perpMarket.marketIndex);
+		oracleInfos.set(
+			getOracleId(perpMarket.amm.oracle, perpMarket.amm.oracleSource),
+			{
+				publicKey: perpMarket.amm.oracle,
+				source: perpMarket.amm.oracleSource,
+			}
+		);
+	}
+
+	for (const spotMarketProgramAccount of spotMarketProgramAccounts) {
+		const spotMarket = spotMarketProgramAccount.account as SpotMarketAccount;
+		spotMarketIndexes.push(spotMarket.marketIndex);
+		oracleInfos.set(getOracleId(spotMarket.oracle, spotMarket.oracleSource), {
+			publicKey: spotMarket.oracle,
+			source: spotMarket.oracleSource,
+		});
+	}
+
+	return {
+		perpMarketIndexes,
+		perpMarketAccounts: perpMarketProgramAccounts.map(
+			(account) => account.account
+		),
+		spotMarketIndexes,
+		spotMarketAccounts: spotMarketProgramAccounts.map(
+			(account) => account.account
+		),
+		oracleInfos: Array.from(oracleInfos.values()),
+	};
+}

package/src/constants/numericConstants.ts

@@ -0,0 +1,113 @@
+import { LAMPORTS_PER_SOL } from '@solana/web3.js';
+import { BN } from '../';
+
+export const ZERO = new BN(0);
+export const ONE = new BN(1);
+export const TWO = new BN(2);
+export const THREE = new BN(3);
+export const FOUR = new BN(4);
+export const FIVE = new BN(5);
+export const SIX = new BN(6);
+export const SEVEN = new BN(7);
+export const EIGHT = new BN(8);
+export const NINE = new BN(9);
+export const TEN = new BN(10);
+export const TEN_THOUSAND = new BN(10000);
+export const BN_MAX = new BN(Number.MAX_SAFE_INTEGER);
+export const TEN_MILLION = TEN_THOUSAND.mul(TEN_THOUSAND);
+
+export const MAX_LEVERAGE = new BN(5);
+export const MAX_LEVERAGE_ORDER_SIZE = new BN('18446744073709551615');
+
+export const PERCENTAGE_PRECISION_EXP = new BN(6);
+export const PERCENTAGE_PRECISION = new BN(10).pow(PERCENTAGE_PRECISION_EXP);
+export const CONCENTRATION_PRECISION = PERCENTAGE_PRECISION;
+
+export const QUOTE_PRECISION_EXP = new BN(6);
+export const FUNDING_RATE_BUFFER_PRECISION_EXP = new BN(3);
+export const PRICE_PRECISION_EXP = new BN(6);
+export const FUNDING_RATE_PRECISION_EXP = PRICE_PRECISION_EXP.add(
+	FUNDING_RATE_BUFFER_PRECISION_EXP
+);
+export const PEG_PRECISION_EXP = new BN(6);
+export const AMM_RESERVE_PRECISION_EXP = new BN(9);
+
+export const SPOT_MARKET_RATE_PRECISION_EXP = new BN(6);
+export const SPOT_MARKET_RATE_PRECISION = new BN(10).pow(
+	SPOT_MARKET_RATE_PRECISION_EXP
+);
+
+export const SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION_EXP = new BN(10);
+export const SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION = new BN(10).pow(
+	SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION_EXP
+);
+
+export const SPOT_MARKET_UTILIZATION_PRECISION_EXP = new BN(6);
+export const SPOT_MARKET_UTILIZATION_PRECISION = new BN(10).pow(
+	SPOT_MARKET_UTILIZATION_PRECISION_EXP
+);
+
+export const SPOT_MARKET_WEIGHT_PRECISION = new BN(10000);
+export const SPOT_MARKET_BALANCE_PRECISION_EXP = new BN(9);
+export const SPOT_MARKET_BALANCE_PRECISION = new BN(10).pow(
+	SPOT_MARKET_BALANCE_PRECISION_EXP
+);
+export const SPOT_MARKET_IMF_PRECISION_EXP = new BN(6);
+
+export const SPOT_MARKET_IMF_PRECISION = new BN(10).pow(
+	SPOT_MARKET_IMF_PRECISION_EXP
+);
+export const LIQUIDATION_FEE_PRECISION = new BN(1000000);
+
+export const QUOTE_PRECISION = new BN(10).pow(QUOTE_PRECISION_EXP);
+export const PRICE_PRECISION = new BN(10).pow(PRICE_PRECISION_EXP);
+export const FUNDING_RATE_PRECISION = new BN(10).pow(
+	FUNDING_RATE_PRECISION_EXP
+);
+export const FUNDING_RATE_BUFFER_PRECISION = new BN(10).pow(
+	FUNDING_RATE_BUFFER_PRECISION_EXP
+);
+export const PEG_PRECISION = new BN(10).pow(PEG_PRECISION_EXP);
+
+export const AMM_RESERVE_PRECISION = new BN(10).pow(AMM_RESERVE_PRECISION_EXP);
+
+export const BASE_PRECISION = AMM_RESERVE_PRECISION;
+export const BASE_PRECISION_EXP = AMM_RESERVE_PRECISION_EXP;
+
+export const AMM_TO_QUOTE_PRECISION_RATIO =
+	AMM_RESERVE_PRECISION.div(QUOTE_PRECISION); // 10^3
+export const PRICE_DIV_PEG = PRICE_PRECISION.div(PEG_PRECISION); //10^1
+export const PRICE_TO_QUOTE_PRECISION = PRICE_PRECISION.div(QUOTE_PRECISION); // 10^1
+export const AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO =
+	AMM_RESERVE_PRECISION.mul(PEG_PRECISION).div(QUOTE_PRECISION); // 10^9
+export const MARGIN_PRECISION = TEN_THOUSAND;
+export const BID_ASK_SPREAD_PRECISION = new BN(1000000); // 10^6
+export const LIQUIDATION_PCT_PRECISION = TEN_THOUSAND;
+export const FUNDING_RATE_OFFSET_DENOMINATOR = new BN(5000);
+
+export const FIVE_MINUTE = new BN(60 * 5);
+export const ONE_HOUR = new BN(60 * 60);
+export const ONE_YEAR = new BN(31536000);
+
+export const QUOTE_SPOT_MARKET_INDEX = 0;
+export const GOV_SPOT_MARKET_INDEX = 15;
+
+export const LAMPORTS_PRECISION = new BN(LAMPORTS_PER_SOL);
+export const LAMPORTS_EXP = new BN(Math.log10(LAMPORTS_PER_SOL));
+
+export const OPEN_ORDER_MARGIN_REQUIREMENT = QUOTE_PRECISION.div(new BN(100));
+
+export const DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT = new BN(
+	-25
+).mul(QUOTE_PRECISION);
+
+export const ACCOUNT_AGE_DELETION_CUTOFF_SECONDS = 60 * 60 * 24 * 13; // 13 days
+export const IDLE_TIME_SLOTS = 9000;
+export const SLOT_TIME_ESTIMATE_MS = 400;
+
+export const DUST_POSITION_SIZE = QUOTE_PRECISION.divn(100); // Dust position is any position smaller than 1c
+
+export const FUEL_WINDOW = new BN(60 * 60 * 24 * 28); // 28 days
+export const FUEL_START_TS = new BN(1723147200); // unix timestamp
+
+export const MAX_PREDICTION_PRICE = PRICE_PRECISION;