@velocity-exchange/sdk 0.3.0 → 0.6.0

package/src/math/market.ts

@@ -1,356 +0,0 @@
-import { BN } from '../isomorphic/anchor';
-import {
-	PerpMarketAccount,
-	PositionDirection,
-	MarginCategory,
-	SpotMarketAccount,
-	SpotBalanceType,
-	isVariant,
-} from '../types';
-import {
-	calculatePrice,
-	calculateUpdatedAMMSpreadReserves,
-	calculateUpdatedAMM,
-} from './amm';
-import {
-	calculateSizeDiscountAssetWeight,
-	calculateSizePremiumLiabilityWeight,
-} from './margin';
-import { MMOraclePriceData, OraclePriceData } from '../oracles/types';
-import {
-	BASE_PRECISION,
-	MARGIN_PRECISION,
-	PRICE_TO_QUOTE_PRECISION,
-	ZERO,
-	QUOTE_SPOT_MARKET_INDEX,
-	PRICE_PRECISION,
-	PERCENTAGE_PRECISION,
-	FUNDING_RATE_PRECISION,
-} from '../constants/numericConstants';
-import { getTokenAmount } from './spotBalance';
-import { assert } from '../assert/assert';
-
-/**
- * Calculates market mark price
- *
- * @param market
- * @return markPrice : Precision PRICE_PRECISION
- */
-export function calculateReservePrice(
-	market: PerpMarketAccount,
-	mmOraclePriceData?: MMOraclePriceData
-): BN {
-	const newAmm = calculateUpdatedAMM(market.amm, mmOraclePriceData);
-	return calculatePrice(
-		newAmm.baseAssetReserve,
-		newAmm.quoteAssetReserve,
-		newAmm.pegMultiplier
-	);
-}
-
-/**
- * Calculates market bid price
- *
- * @param market
- * @return bidPrice : Precision PRICE_PRECISION
- */
-export function calculateBidPrice(
-	market: PerpMarketAccount,
-	mmOraclePriceData?: MMOraclePriceData,
-	latestSlot?: BN
-): BN {
-	const { baseAssetReserve, quoteAssetReserve, newPeg } =
-		calculateUpdatedAMMSpreadReserves(
-			market.amm,
-			market.marketStats,
-			PositionDirection.SHORT,
-			mmOraclePriceData,
-			latestSlot
-		);
-
-	return calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
-}
-
-/**
- * Calculates market ask price
- *
- * @param market
- * @return askPrice : Precision PRICE_PRECISION
- */
-export function calculateAskPrice(
-	market: PerpMarketAccount,
-	mmOraclePriceData?: MMOraclePriceData,
-	latestSlot?: BN
-): BN {
-	const { baseAssetReserve, quoteAssetReserve, newPeg } =
-		calculateUpdatedAMMSpreadReserves(
-			market.amm,
-			market.marketStats,
-			PositionDirection.LONG,
-			mmOraclePriceData,
-			latestSlot
-		);
-
-	return calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
-}
-
-export function calculateOracleSpread(
-	price: BN,
-	oraclePriceData: OraclePriceData
-): BN {
-	return price.sub(oraclePriceData.price);
-}
-
-export function calculateMarketMarginRatio(
-	market: PerpMarketAccount,
-	size: BN,
-	marginCategory: MarginCategory,
-	customMarginRatio = 0
-): number {
-	if (market.status === 'Settlement') return 0;
-
-	let defaultMarginRatio: number;
-	switch (marginCategory) {
-		case 'Initial':
-			defaultMarginRatio = market.marginRatioInitial;
-			break;
-		case 'Maintenance':
-			defaultMarginRatio = market.marginRatioMaintenance;
-			break;
-		default:
-			throw new Error('Invalid margin category');
-	}
-
-	let marginRatio: number;
-
-	const sizeAdjMarginRatio = calculateSizePremiumLiabilityWeight(
-		size,
-		new BN(market.imfFactor),
-		new BN(defaultMarginRatio),
-		MARGIN_PRECISION,
-		true
-	).toNumber();
-
-	marginRatio = Math.max(defaultMarginRatio, sizeAdjMarginRatio);
-
-	if (marginCategory === 'Initial') {
-		marginRatio = Math.max(marginRatio, customMarginRatio);
-	}
-
-	return marginRatio;
-}
-
-export function calculateUnrealizedAssetWeight(
-	market: PerpMarketAccount,
-	quoteSpotMarket: SpotMarketAccount,
-	unrealizedPnl: BN,
-	marginCategory: MarginCategory,
-	oraclePriceData: Pick<OraclePriceData, 'price'>
-): BN {
-	let assetWeight: BN;
-	switch (marginCategory) {
-		case 'Initial':
-			assetWeight = new BN(market.unrealizedPnlInitialAssetWeight);
-
-			if (market.unrealizedPnlMaxImbalance.gt(ZERO)) {
-				const netUnsettledPnl = calculateNetUserPnlImbalance(
-					market,
-					quoteSpotMarket,
-					oraclePriceData
-				);
-				if (netUnsettledPnl.gt(market.unrealizedPnlMaxImbalance)) {
-					assetWeight = assetWeight
-						.mul(market.unrealizedPnlMaxImbalance)
-						.div(netUnsettledPnl);
-				}
-			}
-
-			assetWeight = calculateSizeDiscountAssetWeight(
-				unrealizedPnl,
-				new BN(market.unrealizedPnlImfFactor),
-				assetWeight
-			);
-			break;
-		case 'Maintenance':
-			assetWeight = new BN(market.unrealizedPnlMaintenanceAssetWeight);
-			break;
-	}
-
-	return assetWeight;
-}
-
-export function calculateMarketAvailablePNL(
-	perpMarket: PerpMarketAccount,
-	spotMarket: SpotMarketAccount
-): BN {
-	return getTokenAmount(
-		perpMarket.pnlPool.scaledBalance,
-		spotMarket,
-		SpotBalanceType.DEPOSIT
-	);
-}
-
-export function calculateMarketMaxAvailableInsurance(
-	perpMarket: PerpMarketAccount,
-	spotMarket: SpotMarketAccount
-): BN {
-	assert(spotMarket.marketIndex == QUOTE_SPOT_MARKET_INDEX);
-
-	// todo: insuranceFundAllocation technically not guaranteed to be in Insurance Fund
-	const insuranceFundAllocation =
-		perpMarket.insuranceClaim.quoteMaxInsurance.sub(
-			perpMarket.insuranceClaim.quoteSettledInsurance
-		);
-	const ammFeePool = getTokenAmount(
-		perpMarket.amm.feePool.scaledBalance,
-		spotMarket,
-		SpotBalanceType.DEPOSIT
-	);
-	return insuranceFundAllocation.add(ammFeePool);
-}
-
-export function calculateNetUserPnl(
-	perpMarket: PerpMarketAccount,
-	oraclePriceData: Pick<OraclePriceData, 'price'>
-): BN {
-	const netUserPositionValue = perpMarket.amm.baseAssetAmountWithAmm
-		.mul(oraclePriceData.price)
-		.div(BASE_PRECISION)
-		.div(PRICE_TO_QUOTE_PRECISION);
-
-	const netUserCostBasis = perpMarket.quoteAssetAmount.add(
-		perpMarket.netUnsettledFundingPnl
-	);
-
-	const netUserPnl = netUserPositionValue.add(netUserCostBasis);
-
-	return netUserPnl;
-}
-
-export function calculateNetUserPnlImbalance(
-	perpMarket: PerpMarketAccount,
-	spotMarket: SpotMarketAccount,
-	oraclePriceData: Pick<OraclePriceData, 'price'>,
-	applyFeePoolDiscount = true
-): BN {
-	const netUserPnl = calculateNetUserPnl(perpMarket, oraclePriceData);
-
-	const pnlPool = getTokenAmount(
-		perpMarket.pnlPool.scaledBalance,
-		spotMarket,
-		SpotBalanceType.DEPOSIT
-	);
-	let feePool = getTokenAmount(
-		perpMarket.amm.feePool.scaledBalance,
-		spotMarket,
-		SpotBalanceType.DEPOSIT
-	);
-	if (applyFeePoolDiscount) {
-		feePool = feePool.div(new BN(5));
-	}
-
-	const imbalance = netUserPnl.sub(pnlPool.add(feePool));
-
-	return imbalance;
-}
-
-/**
- * Calculates trigger price for a perp market based on oracle price and current time
- * Implements the same logic as the Rust get_trigger_price function
- *
- * @param market - The perp market account
- * @param oraclePrice - Current oracle price (precision: PRICE_PRECISION)
- * @param now - Current timestamp in seconds
- * @returns trigger price (precision: PRICE_PRECISION)
- */
-export function getTriggerPrice(
-	market: PerpMarketAccount,
-	oraclePrice: BN,
-	now: BN,
-	useMedianPrice: boolean
-): BN {
-	if (!useMedianPrice) {
-		return oraclePrice.abs();
-	}
-
-	const lastFillPrice = market.lastFillPrice;
-
-	// Calculate 5-minute basis
-	const markPrice5minTwap = market.marketStats.lastMarkPriceTwap5Min;
-	const lastOraclePriceTwap5min =
-		market.marketStats.historicalOracleData.lastOraclePriceTwap5Min;
-	const basis5min = markPrice5minTwap.sub(lastOraclePriceTwap5min);
-
-	const oraclePlusBasis5min = oraclePrice.add(basis5min);
-
-	// Calculate funding basis
-	const lastFundingBasis = getLastFundingBasis(market, oraclePrice, now);
-	const oraclePlusFundingBasis = oraclePrice.add(lastFundingBasis);
-
-	const prices = [
-		lastFillPrice.gt(ZERO) ? lastFillPrice : oraclePrice,
-		oraclePlusFundingBasis,
-		oraclePlusBasis5min,
-	].sort((a, b) => a.cmp(b));
-	const medianPrice = prices[1];
-
-	return clampTriggerPrice(market, oraclePrice.abs(), medianPrice);
-}
-
-/**
- * Calculates the last funding basis for trigger price calculation
- * Implements the same logic as the Rust get_last_funding_basis function
- */
-function getLastFundingBasis(
-	market: PerpMarketAccount,
-	oraclePrice: BN,
-	now: BN
-): BN {
-	if (market.marketStats.lastFundingOracleTwap.gt(ZERO)) {
-		const lastFundingRate = market.lastFundingRate
-			.mul(PRICE_PRECISION)
-			.div(market.marketStats.lastFundingOracleTwap)
-			.muln(24);
-		const lastFundingRatePreAdj = lastFundingRate.sub(
-			FUNDING_RATE_PRECISION.div(new BN(3333)) // FUNDING_RATE_OFFSET_PERCENTAGE
-		);
-		const timeLeftUntilFundingUpdate = BN.min(
-			BN.max(now.sub(market.lastFundingRateTs), ZERO),
-			market.marketStats.fundingPeriod
-		);
-		const lastFundingBasis = oraclePrice
-			.mul(lastFundingRatePreAdj)
-			.div(PERCENTAGE_PRECISION)
-			.mul(market.marketStats.fundingPeriod.sub(timeLeftUntilFundingUpdate))
-			.div(market.marketStats.fundingPeriod)
-			.div(new BN(1000)); // FUNDING_RATE_BUFFER
-		return lastFundingBasis;
-	} else {
-		return ZERO;
-	}
-}
-
-/**
- * Clamps trigger price based on contract tier
- * Implements the same logic as the Rust clamp_trigger_price function
- */
-function clampTriggerPrice(
-	market: PerpMarketAccount,
-	oraclePrice: BN,
-	medianPrice: BN
-): BN {
-	let maxBpsDiff: BN;
-	const tier = market.contractTier;
-	if (isVariant(tier, 'a') || isVariant(tier, 'b')) {
-		maxBpsDiff = new BN(500); // 20 BPS
-	} else if (isVariant(tier, 'c')) {
-		maxBpsDiff = new BN(100); // 100 BPS
-	} else {
-		maxBpsDiff = new BN(40); // 250 BPS
-	}
-	const maxOracleDiff = oraclePrice.div(maxBpsDiff);
-	return BN.min(
-		BN.max(medianPrice, oraclePrice.sub(maxOracleDiff)),
-		oraclePrice.add(maxOracleDiff)
-	);
-}

package/src/math/oracles.ts

@@ -1,353 +0,0 @@
-import {
-	HistoricalOracleData,
-	MarketStats,
-	OracleGuardRails,
-	OracleSource,
-	OracleValidity,
-	PerpMarketAccount,
-	isOneOfVariant,
-	isVariant,
-} from '../types';
-import { OraclePriceData } from '../oracles/types';
-import {
-	BID_ASK_SPREAD_PRECISION,
-	MARGIN_PRECISION,
-	ONE,
-	ZERO,
-	FIVE_MINUTE,
-	PERCENTAGE_PRECISION,
-	FIVE,
-} from '../constants/numericConstants';
-import { assert } from '../assert/assert';
-import { BN } from '../isomorphic/anchor';
-
-export function oraclePriceBands(
-	market: PerpMarketAccount,
-	oraclePriceData: Pick<OraclePriceData, 'price'>
-): [BN, BN] {
-	const maxPercentDiff =
-		market.marginRatioInitial - market.marginRatioMaintenance;
-	const offset = oraclePriceData.price
-		.mul(new BN(maxPercentDiff))
-		.div(MARGIN_PRECISION);
-
-	assert(offset.gte(ZERO));
-
-	return [oraclePriceData.price.sub(offset), oraclePriceData.price.add(offset)];
-}
-
-export function getMaxConfidenceIntervalMultiplier(
-	market: PerpMarketAccount
-): BN {
-	let maxConfidenceIntervalMultiplier;
-	if (isVariant(market.contractTier, 'a')) {
-		maxConfidenceIntervalMultiplier = new BN(1);
-	} else if (isVariant(market.contractTier, 'b')) {
-		maxConfidenceIntervalMultiplier = new BN(1);
-	} else if (isVariant(market.contractTier, 'c')) {
-		maxConfidenceIntervalMultiplier = new BN(2);
-	} else if (isVariant(market.contractTier, 'speculative')) {
-		maxConfidenceIntervalMultiplier = new BN(10);
-	} else {
-		maxConfidenceIntervalMultiplier = new BN(50);
-	}
-	return maxConfidenceIntervalMultiplier;
-}
-
-export function getOracleValidity(
-	market: PerpMarketAccount,
-	oraclePriceData: OraclePriceData,
-	oracleGuardRails: OracleGuardRails,
-	slot: BN,
-	oracleStalenessBuffer = FIVE
-): OracleValidity {
-	const isNonPositive = oraclePriceData.price.lte(ZERO);
-	const isTooVolatile = BN.max(
-		oraclePriceData.price,
-		market.marketStats.historicalOracleData.lastOraclePriceTwap
-	)
-		.div(
-			BN.max(
-				ONE,
-				BN.min(
-					oraclePriceData.price,
-					market.marketStats.historicalOracleData.lastOraclePriceTwap
-				)
-			)
-		)
-		.gt(oracleGuardRails.validity.tooVolatileRatio);
-
-	const confPctOfPrice = oraclePriceData.confidence
-		.mul(BID_ASK_SPREAD_PRECISION)
-		.div(oraclePriceData.price);
-	const isConfTooLarge = confPctOfPrice.gt(
-		oracleGuardRails.validity.confidenceIntervalMaxSize.mul(
-			getMaxConfidenceIntervalMultiplier(market)
-		)
-	);
-
-	const oracleDelay = slot.sub(oraclePriceData.slot).sub(oracleStalenessBuffer);
-
-	let isStaleForAmmImmediate = true;
-	if (market.oracleSlotDelayOverride != 0) {
-		isStaleForAmmImmediate = oracleDelay.gt(
-			BN.max(new BN(market.oracleSlotDelayOverride), ZERO)
-		);
-	}
-
-	let isStaleForAmmLowRisk = false;
-	if (market.oracleLowRiskSlotDelayOverride != 0) {
-		isStaleForAmmLowRisk = oracleDelay.gt(
-			BN.max(new BN(market.oracleLowRiskSlotDelayOverride), ZERO)
-		);
-	} else {
-		isStaleForAmmLowRisk = oracleDelay.gt(
-			oracleGuardRails.validity.slotsBeforeStaleForAmm
-		);
-	}
-
-	let isStaleForMargin = oracleDelay.gt(
-		new BN(oracleGuardRails.validity.slotsBeforeStaleForMargin)
-	);
-	if (isVariant(market.oracleSource, 'pythLazerStableCoin')) {
-		isStaleForMargin = oracleDelay.gt(
-			new BN(oracleGuardRails.validity.slotsBeforeStaleForMargin).muln(3)
-		);
-	}
-
-	if (isNonPositive) {
-		return OracleValidity.NonPositive;
-	} else if (isTooVolatile) {
-		return OracleValidity.TooVolatile;
-	} else if (isConfTooLarge) {
-		return OracleValidity.TooUncertain;
-	} else if (isStaleForMargin) {
-		return OracleValidity.StaleForMargin;
-	} else if (!oraclePriceData.hasSufficientNumberOfDataPoints) {
-		return OracleValidity.InsufficientDataPoints;
-	} else if (isStaleForAmmLowRisk) {
-		return OracleValidity.StaleForAMMLowRisk;
-	} else if (isStaleForAmmImmediate) {
-		return OracleValidity.isStaleForAmmImmediate;
-	} else {
-		return OracleValidity.Valid;
-	}
-}
-
-export function isOracleValid(
-	market: PerpMarketAccount,
-	oraclePriceData: OraclePriceData,
-	oracleGuardRails: OracleGuardRails,
-	slot: number
-): boolean {
-	// checks if oracle is valid for an AMM only fill
-
-	const stats = market.marketStats;
-	const isOraclePriceNonPositive = oraclePriceData.price.lte(ZERO);
-	const isOraclePriceTooVolatile =
-		oraclePriceData.price
-			.div(BN.max(ONE, stats.historicalOracleData.lastOraclePriceTwap))
-			.gt(oracleGuardRails.validity.tooVolatileRatio) ||
-		stats.historicalOracleData.lastOraclePriceTwap
-			.div(BN.max(ONE, oraclePriceData.price))
-			.gt(oracleGuardRails.validity.tooVolatileRatio);
-
-	const maxConfidenceIntervalMultiplier =
-		getMaxConfidenceIntervalMultiplier(market);
-	const isConfidenceTooLarge = BN.max(ONE, oraclePriceData.confidence)
-		.mul(BID_ASK_SPREAD_PRECISION)
-		.div(oraclePriceData.price)
-		.gt(
-			oracleGuardRails.validity.confidenceIntervalMaxSize.mul(
-				maxConfidenceIntervalMultiplier
-			)
-		);
-
-	const oracleIsStale = new BN(slot)
-		.sub(oraclePriceData.slot)
-		.gt(oracleGuardRails.validity.slotsBeforeStaleForAmm);
-
-	return !(
-		!oraclePriceData.hasSufficientNumberOfDataPoints ||
-		oracleIsStale ||
-		isOraclePriceNonPositive ||
-		isOraclePriceTooVolatile ||
-		isConfidenceTooLarge
-	);
-}
-
-export function isOracleTooDivergent(
-	marketStats: MarketStats,
-	oraclePriceData: OraclePriceData,
-	oracleGuardRails: OracleGuardRails
-): boolean {
-	const oracleSpreadPct = oraclePriceData.price
-		.sub(marketStats.historicalOracleData.lastOraclePriceTwap5Min)
-		.mul(PERCENTAGE_PRECISION)
-		.div(marketStats.historicalOracleData.lastOraclePriceTwap5Min);
-	const maxDivergence = BN.max(
-		oracleGuardRails.priceDivergence.oracleTwap5MinPercentDivergence,
-		PERCENTAGE_PRECISION.div(new BN(2))
-	);
-	const tooDivergent = oracleSpreadPct.abs().gte(maxDivergence);
-	return tooDivergent;
-}
-
-export function calculateLiveOracleTwap(
-	histOracleData: HistoricalOracleData,
-	oraclePriceData: OraclePriceData,
-	now: BN,
-	period: BN
-): BN {
-	let oracleTwap = undefined;
-	if (period.eq(FIVE_MINUTE)) {
-		oracleTwap = histOracleData.lastOraclePriceTwap5Min;
-	} else {
-		//todo: assumes its fundingPeriod (1hr)
-		// period = amm.fundingPeriod;
-		oracleTwap = histOracleData.lastOraclePriceTwap;
-	}
-
-	const sinceLastUpdate = BN.max(
-		ONE,
-		now.sub(histOracleData.lastOraclePriceTwapTs)
-	);
-	const sinceStart = BN.max(ZERO, period.sub(sinceLastUpdate));
-
-	const clampRange = oracleTwap.div(new BN(3));
-
-	const clampedOraclePrice = BN.min(
-		oracleTwap.add(clampRange),
-		BN.max(oraclePriceData.price, oracleTwap.sub(clampRange))
-	);
-
-	const newOracleTwap = oracleTwap
-		.mul(sinceStart)
-		.add(clampedOraclePrice.mul(sinceLastUpdate))
-		.div(sinceStart.add(sinceLastUpdate));
-
-	return newOracleTwap;
-}
-
-export function calculateLiveOracleStd(
-	marketStats: MarketStats,
-	oraclePriceData: OraclePriceData,
-	now: BN
-): BN {
-	const sinceLastUpdate = BN.max(
-		ONE,
-		now.sub(marketStats.historicalOracleData.lastOraclePriceTwapTs)
-	);
-	const sinceStart = BN.max(
-		ZERO,
-		marketStats.fundingPeriod.sub(sinceLastUpdate)
-	);
-
-	const liveOracleTwap = calculateLiveOracleTwap(
-		marketStats.historicalOracleData,
-		oraclePriceData,
-		now,
-		marketStats.fundingPeriod
-	);
-
-	const liveOracleTwap5MIN = calculateLiveOracleTwap(
-		marketStats.historicalOracleData,
-		oraclePriceData,
-		now,
-		FIVE_MINUTE
-	);
-
-	const priceDeltaVsTwap = BN.max(
-		oraclePriceData.price.sub(liveOracleTwap).abs(),
-		oraclePriceData.price.sub(liveOracleTwap5MIN).abs()
-	);
-
-	const oracleStd = priceDeltaVsTwap.add(
-		marketStats.oracleStd.mul(sinceStart).div(sinceStart.add(sinceLastUpdate))
-	);
-
-	return oracleStd;
-}
-
-export function getNewOracleConfPct(
-	marketStats: MarketStats,
-	oraclePriceData: OraclePriceData,
-	reservePrice: BN,
-	now: BN
-): BN {
-	const confInterval = oraclePriceData.confidence || ZERO;
-
-	const sinceLastUpdate = BN.max(
-		ZERO,
-		now.sub(marketStats.historicalOracleData.lastOraclePriceTwapTs)
-	);
-	let lowerBoundConfPct = marketStats.lastOracleConfPct;
-	if (sinceLastUpdate.gt(ZERO)) {
-		const lowerBoundConfDivisor = BN.max(
-			new BN(21).sub(sinceLastUpdate),
-			new BN(5)
-		);
-		lowerBoundConfPct = marketStats.lastOracleConfPct.sub(
-			marketStats.lastOracleConfPct.div(lowerBoundConfDivisor)
-		);
-	}
-	const confIntervalPct = confInterval
-		.mul(BID_ASK_SPREAD_PRECISION)
-		.div(reservePrice);
-
-	const confIntervalPctResult = BN.max(confIntervalPct, lowerBoundConfPct);
-
-	return confIntervalPctResult;
-}
-
-export function getMultipleBetweenOracleSources(
-	firstOracleSource: OracleSource,
-	secondOracleSource: OracleSource
-): { numerator: BN; denominator: BN } {
-	if (
-		isOneOfVariant(firstOracleSource, [
-			'pythPull',
-			'pyth1KPull',
-			'pyth1MPull',
-			'pythStableCoinPull',
-		]) ||
-		isOneOfVariant(secondOracleSource, [
-			'pythPull',
-			'pyth1KPull',
-			'pyth1MPull',
-			'pythStableCoinPull',
-		])
-	) {
-		throw new Error('Pyth pull oracle support has been removed from the SDK');
-	}
-
-	if (
-		isVariant(firstOracleSource, 'pythLazer') &&
-		isVariant(secondOracleSource, 'pythLazer1M')
-	) {
-		return { numerator: new BN(1000000), denominator: new BN(1) };
-	}
-
-	if (
-		isVariant(firstOracleSource, 'pythLazer') &&
-		isVariant(secondOracleSource, 'pythLazer1K')
-	) {
-		return { numerator: new BN(1000), denominator: new BN(1) };
-	}
-
-	if (
-		isVariant(firstOracleSource, 'pythLazer1M') &&
-		isVariant(secondOracleSource, 'pythLazer')
-	) {
-		return { numerator: new BN(1), denominator: new BN(1000000) };
-	}
-
-	if (
-		isVariant(firstOracleSource, 'pythLazer1K') &&
-		isVariant(secondOracleSource, 'pythLazer')
-	) {
-		return { numerator: new BN(1), denominator: new BN(1000) };
-	}
-
-	return { numerator: new BN(1), denominator: new BN(1) };
-}