@velocity-exchange/sdk 0.4.0 → 0.6.0

package/src/oracles/pythClient.ts

@@ -1,125 +0,0 @@
-import { parsePriceData } from '@pythnetwork/client';
-import { Connection, PublicKey } from '@solana/web3.js';
-import { OracleClient, OraclePriceData } from './types';
-import { BN } from '../isomorphic/anchor';
-import {
-	ONE,
-	PRICE_PRECISION,
-	QUOTE_PRECISION,
-	TEN,
-} from '../constants/numericConstants';
-import { getOracleAccountDataOrThrow } from './utils';
-
-/**
- * `OracleClient` for legacy (push-model) Pyth price accounts, decoded via `@pythnetwork/client`'s
- * `parsePriceData`. Backs the `pyth`, `pyth1K`, `pyth1M`, and `pythStableCoin` `OracleSource`
- * variants — the `pythPull`/`pyth1KPull`/`pyth1MPull`/`pythStableCoinPull` (Pyth pull-oracle)
- * variants have been removed from the SDK and throw in `getOracleClient`.
- */
-export class PythClient implements OracleClient {
-	private connection: Connection;
-	private multiple: BN;
-	private stableCoin: boolean;
-
-	/**
-	 * @param connection - RPC connection used to fetch oracle account data.
-	 * @param multiple - Divisor applied to the raw Pyth precision before rescaling to
-	 * PRICE_PRECISION; pass `1000`/`1000000` for the `pyth1K`/`pyth1M` source variants (feeds
-	 * quoted per 1,000 / 1,000,000 units of the underlying), or the default `ONE` (1) for a
-	 * standard per-unit feed.
-	 * @param stableCoin - When `true` (the `pythStableCoin` variant), snaps the decoded price to
-	 * exactly `QUOTE_PRECISION` (1.0) whenever it is within 5bps (or within `confidence` if
-	 * tighter) of peg — see `getStableCoinPrice`.
-	 */
-	public constructor(
-		connection: Connection,
-		multiple = ONE,
-		stableCoin = false
-	) {
-		this.connection = connection;
-		this.multiple = multiple;
-		this.stableCoin = stableCoin;
-	}
-
-	/**
-	 * Fetches and decodes a Pyth price account's current price data.
-	 * @param pricePublicKey - The Pyth price account's address.
-	 * @returns The decoded, normalized price data.
-	 * @throws Error if the account does not exist.
-	 */
-	public async getOraclePriceData(
-		pricePublicKey: PublicKey
-	): Promise<OraclePriceData> {
-		const data = await getOracleAccountDataOrThrow(
-			this.connection,
-			pricePublicKey,
-			'Pyth oracle'
-		);
-		return this.getOraclePriceDataFromBuffer(data);
-	}
-
-	/**
-	 * Decodes raw Pyth price account bytes into normalized `OraclePriceData`, rescaling from
-	 * Pyth's native exponent to PRICE_PRECISION (1e6) via `convertPythPrice`. `confidence` defaults
-	 * to 0 if the account has no confidence field (e.g. uninitialized), and `hasSufficientNumberOfDataPoints`
-	 * is `true` only when the number of active quoters is at least `min(numComponentPrices, 3)`.
-	 * @param buffer - Raw Pyth price account data.
-	 * @returns `price`, `confidence`, `twap`, `twapConfidence` (all PRICE_PRECISION 1e6), `slot`
-	 * (the price account's last update slot), and `hasSufficientNumberOfDataPoints`.
-	 */
-	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 ?? 0,
-			priceData.exponent,
-			this.multiple
-		);
-		const minPublishers = Math.min(priceData.numComponentPrices, 3);
-		let price = convertPythPrice(
-			priceData.aggregate.price,
-			priceData.exponent,
-			this.multiple
-		);
-		if (this.stableCoin) {
-			price = getStableCoinPrice(price, confidence);
-		}
-
-		return {
-			price,
-			slot: new BN(priceData.lastSlot.toString()),
-			confidence,
-			twap: convertPythPrice(
-				priceData.twap.value,
-				priceData.exponent,
-				this.multiple
-			),
-			twapConfidence: convertPythPrice(
-				priceData.twac.value,
-				priceData.exponent,
-				this.multiple
-			),
-			hasSufficientNumberOfDataPoints: priceData.numQuoters >= minPublishers,
-		};
-	}
-}
-
-function convertPythPrice(price: number, exponent: number, multiple: BN): BN {
-	exponent = Math.abs(exponent);
-	const pythPrecision = TEN.pow(new BN(exponent).abs()).div(multiple);
-	return new BN(price * Math.pow(10, exponent))
-		.mul(PRICE_PRECISION)
-		.div(pythPrecision);
-}
-
-const fiveBPS = new BN(500);
-function getStableCoinPrice(price: BN, confidence: BN): BN {
-	if (price.sub(QUOTE_PRECISION).abs().lte(BN.min(confidence, fiveBPS))) {
-		return QUOTE_PRECISION;
-	} else {
-		return price;
-	}
-}

package/src/oracles/pythLazerClient.ts

@@ -1,141 +0,0 @@
-import { Connection, Keypair, PublicKey } from '@solana/web3.js';
-import { OracleClient, OraclePriceData } from './types';
-import { AnchorProvider, BN, Program } from '../isomorphic/anchor';
-import { Velocity } from '../idl/velocity';
-import { VelocityProgram } from '../config';
-import {
-	ONE,
-	PRICE_PRECISION,
-	QUOTE_PRECISION,
-	TEN,
-} from '../constants/numericConstants';
-import { Wallet } from '../wallet';
-import velocityIDL from '../idl/velocity.json';
-import { getOracleAccountDataOrThrow } from './utils';
-
-/**
- * `OracleClient` for `PythLazerOracle` accounts — Velocity's on-chain cache of a Pyth Lazer
- * push-update feed, decoded via the velocity program's own Anchor coder (Lazer has no dedicated
- * client account layout package, unlike legacy Pyth). Backs the `pythLazer`, `pythLazer1K`,
- * `pythLazer1M`, and `pythLazerStableCoin` `OracleSource` variants.
- */
-export class PythLazerClient implements OracleClient {
-	private connection: Connection;
-	private multiple: BN;
-	private stableCoin: boolean;
-	private program: VelocityProgram;
-	readonly decodeFunc: (name: string, data: Buffer) => any;
-
-	/**
-	 * @param connection - RPC connection used to fetch oracle account data; also used to spin up a
-	 * throwaway `AnchorProvider`/`Program` (with a fresh random keypair, never used to sign) purely
-	 * to get access to the IDL's `pythLazerOracle` account coder.
-	 * @param multiple - Divisor applied to the raw Lazer precision before rescaling to
-	 * PRICE_PRECISION; pass `1000`/`1000000` for the `pythLazer1K`/`pythLazer1M` source variants, or
-	 * the default `ONE` (1) for a standard per-unit feed.
-	 * @param stableCoin - When `true` (the `pythLazerStableCoin` variant), snaps the decoded price
-	 * to exactly `QUOTE_PRECISION` (1.0) whenever it is within 5bps (or within `confidence` if
-	 * tighter) of peg — see `getStableCoinPrice`.
-	 */
-	public constructor(
-		connection: Connection,
-		multiple = ONE,
-		stableCoin = false
-	) {
-		this.connection = connection;
-		this.multiple = multiple;
-		this.stableCoin = stableCoin;
-		const provider = new AnchorProvider(
-			this.connection,
-			//@ts-ignore
-			new Wallet(new Keypair()),
-			{
-				commitment: connection.commitment,
-			}
-		);
-		this.program = new Program<Velocity>(velocityIDL as Velocity, provider);
-		this.decodeFunc = (
-			this.program.account as any
-		).pythLazerOracle.coder.accounts.decodeUnchecked.bind(
-			(this.program.account as any).pythLazerOracle.coder.accounts
-		);
-	}
-
-	/**
-	 * Fetches and decodes a `PythLazerOracle` account's current price data.
-	 * @param pricePublicKey - The `PythLazerOracle` account's address (see `getPythLazerOraclePublicKey`).
-	 * @returns The decoded, normalized price data.
-	 * @throws Error if the account does not exist.
-	 */
-	public async getOraclePriceData(
-		pricePublicKey: PublicKey
-	): Promise<OraclePriceData> {
-		const data = await getOracleAccountDataOrThrow(
-			this.connection,
-			pricePublicKey,
-			'Pyth lazer oracle'
-		);
-		return this.getOraclePriceDataFromBuffer(data);
-	}
-
-	/**
-	 * Decodes raw `PythLazerOracle` account bytes into normalized `OraclePriceData`, rescaling from
-	 * the feed's native exponent to PRICE_PRECISION (1e6) via `convertPythPrice`. Unlike legacy
-	 * Pyth, Lazer has no separate TWAP field on-chain, so `twap`/`twapConfidence` are both set to
-	 * the same converted live `price`/`conf` rather than a genuine time-weighted average.
-	 * `hasSufficientNumberOfDataPoints` is always `true` (no publisher-count concept for this
-	 * source), and `sequenceId` is set to the feed's `publishTime` for staleness/ordering checks.
-	 * @param buffer - Raw `PythLazerOracle` account data.
-	 * @returns `price`, `confidence`, `twap`, `twapConfidence` (all PRICE_PRECISION 1e6), `slot`
-	 * (`postedSlot`, the slot the update landed on-chain), and `sequenceId` (`publishTime`).
-	 */
-	public getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData {
-		const priceData = this.decodeFunc('pythLazerOracle', buffer);
-		const confidence = convertPythPrice(
-			priceData.conf,
-			priceData.exponent,
-			this.multiple
-		);
-		let price = convertPythPrice(
-			priceData.price,
-			priceData.exponent,
-			this.multiple
-		);
-		if (this.stableCoin) {
-			price = getStableCoinPrice(price, confidence);
-		}
-
-		return {
-			price,
-			slot: priceData.postedSlot,
-			confidence,
-			twap: convertPythPrice(
-				priceData.price,
-				priceData.exponent,
-				this.multiple
-			),
-			twapConfidence: convertPythPrice(
-				priceData.price,
-				priceData.exponent,
-				this.multiple
-			),
-			hasSufficientNumberOfDataPoints: true,
-			sequenceId: priceData.publishTime,
-		};
-	}
-}
-
-function convertPythPrice(price: BN, exponent: number, multiple: BN): BN {
-	exponent = Math.abs(exponent);
-	const pythPrecision = TEN.pow(new BN(exponent).abs()).div(multiple);
-	return price.mul(PRICE_PRECISION).div(pythPrecision);
-}
-
-const fiveBPS = new BN(500);
-function getStableCoinPrice(price: BN, confidence: BN): BN {
-	if (price.sub(QUOTE_PRECISION).abs().lte(BN.min(confidence, fiveBPS))) {
-		return QUOTE_PRECISION;
-	} else {
-		return price;
-	}
-}

package/src/oracles/quoteAssetOracleClient.ts

@@ -1,43 +0,0 @@
-import { PublicKey } from '@solana/web3.js';
-import { OracleClient, OraclePriceData } from './types';
-import { BN } from '../isomorphic/anchor';
-import { PRICE_PRECISION } from '../constants/numericConstants';
-
-/**
- * Fixed price of exactly 1.0 (PRICE_PRECISION, 1e6) with a minimal confidence band, returned by
- * `QuoteAssetOracleClient` for any oracle lookup. Represents the quote asset (e.g. USDC) pegged
- * 1:1 to itself with no real oracle needed.
- */
-export const QUOTE_ORACLE_PRICE_DATA: OraclePriceData = {
-	price: PRICE_PRECISION,
-	slot: new BN(0),
-	confidence: new BN(1),
-	hasSufficientNumberOfDataPoints: true,
-};
-
-/**
- * `OracleClient` for the `quoteAsset` `OracleSource` variant — the spot market whose asset *is*
- * the protocol's quote currency. Ignores its inputs entirely and always returns the constant
- * `QUOTE_ORACLE_PRICE_DATA` (price 1.0); never makes an RPC call.
- */
-export class QuoteAssetOracleClient implements OracleClient {
-	public constructor() {}
-
-	/**
-	 * @param _pricePublicKey - Ignored.
-	 * @returns The constant `QUOTE_ORACLE_PRICE_DATA`.
-	 */
-	public async getOraclePriceData(
-		_pricePublicKey: PublicKey
-	): Promise<OraclePriceData> {
-		return Promise.resolve(QUOTE_ORACLE_PRICE_DATA);
-	}
-
-	/**
-	 * @param _buffer - Ignored.
-	 * @returns The constant `QUOTE_ORACLE_PRICE_DATA`.
-	 */
-	public getOraclePriceDataFromBuffer(_buffer: Buffer): OraclePriceData {
-		return QUOTE_ORACLE_PRICE_DATA;
-	}
-}

package/src/oracles/strictOraclePrice.ts

@@ -1,40 +0,0 @@
-import { BN } from '../isomorphic/anchor';
-
-/**
- * Pairs a live oracle price with its 5-minute TWAP so margin/value calculations can pick whichever
- * is more conservative — mirroring the on-chain "strict" price used for collateral valuation, which
- * exists so a transient price spike/dip can't be used to over-value collateral or under-value a
- * liability. All values are PRICE_PRECISION (1e6).
- */
-export class StrictOraclePrice {
-	current: BN;
-	twap?: BN;
-
-	/**
-	 * @param current - Live oracle price, PRICE_PRECISION (1e6).
-	 * @param twap - 5-minute oracle TWAP, PRICE_PRECISION (1e6). If omitted, `max()`/`min()` both
-	 * fall back to `current`.
-	 */
-	constructor(current: BN, twap?: BN) {
-		this.current = current;
-		this.twap = twap;
-	}
-
-	/**
-	 * The higher of `current` and `twap` — use when a higher price is the conservative choice
-	 * (e.g. valuing a liability/borrow, where undervaluing it would overstate free collateral).
-	 * @returns The larger of `current` and `twap` (or just `current` if no `twap` was provided), PRICE_PRECISION (1e6).
-	 */
-	public max(): BN {
-		return this.twap ? BN.max(this.twap, this.current) : this.current;
-	}
-
-	/**
-	 * The lower of `current` and `twap` — use when a lower price is the conservative choice (e.g.
-	 * valuing a deposit/asset, where overvaluing it would overstate free collateral).
-	 * @returns The smaller of `current` and `twap` (or just `current` if no `twap` was provided), PRICE_PRECISION (1e6).
-	 */
-	public min(): BN {
-		return this.twap ? BN.min(this.twap, this.current) : this.current;
-	}
-}

package/src/oracles/types.ts

@@ -1,82 +0,0 @@
-/**
- * Oracle types and the OraclePriceData interface used throughout the SDK.
- * Each oracle source (Pyth, Switchboard, Pyth Lazer, Prelaunch) has a client adapter
- * in this directory that fetches and normalises prices into OraclePriceData.
- * Oracle client selection is configured via VelocityClientConfig and cached in OracleClientCache.
- */
-import { BN } from '../isomorphic/anchor';
-import { PublicKey } from '@solana/web3.js';
-import { OracleSource } from '../types';
-
-/**
- * `OraclePriceData` variant for the market-maker (MM) oracle feed, which has no TWAP or
- * pre-launch `maxPrice` fields but instead flags whether the MM oracle is currently trusted.
- */
-export type MMOraclePriceData = Omit<
-	OraclePriceData,
-	'twap' | 'twapConfidence' | 'maxPrice'
-> & {
-	/** Whether the MM oracle is currently considered active/valid and safe to use in place of the primary oracle. */
-	isMMOracleActive: boolean;
-	/**
-	 * Whether the MM oracle is enabled (has a non-zero price), mirroring `MMOraclePriceData::is_enabled`.
-	 * Populated by `VelocityClient.getMMOracleDataForPerpMarket`; used by the AMM-fill volatility gate
-	 * (`isFallbackAvailableLiquiditySource`). Optional because MM data is sometimes constructed without it.
-	 */
-	isMMOracleEnabled?: boolean;
-	/**
-	 * Whether the MM oracle is at least as recent as the exchange (safe) oracle, mirroring
-	 * `MMOraclePriceData::is_mm_oracle_as_recent`. Used together with `isMMExchangeDiffBpsHigh` by the
-	 * AMM-fill volatility gate.
-	 */
-	isMMOracleAsRecent?: boolean;
-	/**
-	 * Whether the MM-vs-exchange oracle price difference exceeds the 1% fallback threshold
-	 * (`MM_EXCHANGE_FALLBACK_THRESHOLD`), mirroring `MMOraclePriceData::is_mm_exchange_diff_bps_high`.
-	 * When the MM oracle is enabled and as-recent, a high diff suppresses AMM fills (early volatility protection).
-	 */
-	isMMExchangeDiffBpsHigh?: boolean;
-};
-
-/** Normalized oracle price snapshot produced by every `OracleClient`, regardless of underlying source. */
-export type OraclePriceData = {
-	/** Oracle price, PRICE_PRECISION (1e6). */
-	price: BN;
-	/** Slot at which this price was last updated on-chain. */
-	slot: BN;
-	/** Oracle confidence interval (± band around `price`), PRICE_PRECISION (1e6). */
-	confidence: BN;
-	/** Whether the source had enough independent publishers/quoters for the price to be trusted (Pyth-specific; always `true` for sources without a publisher-count concept). */
-	hasSufficientNumberOfDataPoints: boolean;
-	/** Time-weighted average price, PRICE_PRECISION (1e6). Absent for sources with no TWAP (e.g. Pyth Lazer echoes the live price here instead). */
-	twap?: BN;
-	/** Confidence interval of `twap`, PRICE_PRECISION (1e6). */
-	twapConfidence?: BN;
-	/** Upper price bound; only populated for prelaunch-market oracles, PRICE_PRECISION (1e6). */
-	maxPrice?: BN; // pre-launch markets only
-	/** Monotonic sequence/publish-time id used to detect out-of-order updates (Pyth Lazer only). */
-	sequenceId?: BN;
-};
-
-/** Identifies an oracle account and which `OracleSource` variant to decode it as. */
-export type OracleInfo = {
-	publicKey: PublicKey;
-	source: OracleSource;
-};
-
-/** Common interface implemented by every per-source oracle adapter (Pyth, Pyth Lazer, prelaunch, quote-asset). */
-export interface OracleClient {
-	/**
-	 * Decodes raw oracle account bytes into normalized `OraclePriceData` without any RPC call.
-	 * @param buffer - Raw account data as returned by `getAccountInfo`/`getMultipleAccounts`.
-	 * @returns The decoded, normalized price data.
-	 */
-	getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
-	/**
-	 * Fetches and decodes an oracle account's current price data.
-	 * @param publicKey - The oracle account's address.
-	 * @returns The decoded, normalized price data.
-	 * @throws Error if the account does not exist.
-	 */
-	getOraclePriceData(publicKey: PublicKey): Promise<OraclePriceData>;
-}

package/src/oracles/utils.ts

@@ -1,45 +0,0 @@
-import { Connection, PublicKey } from '@solana/web3.js';
-import { BN } from '../isomorphic/anchor';
-import { OraclePriceData } from './types';
-
-/**
- * Fetches an account's raw data, throwing if the account does not exist. Shared by every
- * `OracleClient.getOraclePriceData` implementation so a missing oracle account fails loudly rather
- * than silently decoding garbage/zeroed data.
- * @param connection - RPC connection to fetch from.
- * @param pricePublicKey - The oracle account's address.
- * @param oracleName - Human-readable oracle name used only in the thrown error message (e.g. `"Pyth oracle"`).
- * @returns The account's raw data buffer.
- * @throws Error if the account does not exist.
- */
-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;
-}
-
-/**
- * Derives an effective confidence interval for the market-maker (MM) oracle price by widening the
- * primary oracle's confidence by however far the MM price has diverged from it. Used when
- * validating the MM oracle (via `getOracleValidity`) so a large MM/primary-oracle divergence
- * degrades MM-oracle validity the same way low primary-oracle confidence would, rather than
- * evaluating MM price divergence with an artificially tight confidence band.
- * @param mmOraclePrice - The perp market's cached MM oracle price, PRICE_PRECISION (1e6).
- * @param oraclePriceData - The primary oracle's current price data (`price`/`confidence` in PRICE_PRECISION, 1e6).
- * @returns `oraclePriceData.confidence + |mmOraclePrice - oraclePriceData.price|`, PRICE_PRECISION (1e6).
- */
-export function getOracleConfidenceFromMMOracleData(
-	mmOraclePrice: BN,
-	oraclePriceData: OraclePriceData
-): BN {
-	const mmOracleDiffPremium = mmOraclePrice.sub(oraclePriceData.price).abs();
-	return oraclePriceData.confidence.add(mmOracleDiffPremium);
-}

package/src/orderParams.ts

@@ -1,117 +0,0 @@
-import {
-	DefaultOrderParams,
-	OptionalOrderParams,
-	OrderParams,
-	OrderTriggerCondition,
-	OrderType,
-} from './types';
-import { BN } from './isomorphic/anchor';
-
-/**
- * Builds `OptionalOrderParams` for a resting limit order (`OrderType.LIMIT`).
- * Unlike a market order, a limit order has no auction and rests on the book at `price` until
- * filled, cancelled, or expired.
- * @param params - Order fields (see `OrderParams`); `baseAssetAmount` is in BASE_PRECISION
- * (1e9), `price` is in PRICE_PRECISION (1e6). `orderType` is set automatically and must not be
- * passed in.
- * @returns Params merged onto `DefaultOrderParams`, ready to pass to `placeOrder`/`placePerpOrder`.
- */
-export function getLimitOrderParams(
-	params: Omit<OptionalOrderParams, 'orderType'> & { price: BN }
-): OptionalOrderParams {
-	return getOrderParams(
-		Object.assign({}, params, {
-			orderType: OrderType.LIMIT,
-		})
-	);
-}
-
-/**
- * Builds `OptionalOrderParams` for a trigger market order (`OrderType.TRIGGER_MARKET`) — a
- * conditional order (e.g. stop-loss/take-profit) that becomes an auctioned market order once the
- * oracle price crosses `triggerPrice` per `triggerCondition`.
- * @param params - Order fields (see `OrderParams`); `baseAssetAmount` and `triggerPrice` use
- * BASE_PRECISION (1e9) and PRICE_PRECISION (1e6) respectively. `orderType` is set automatically.
- * @returns Params merged onto `DefaultOrderParams`, ready to pass to `placeOrder`/`placePerpOrder`.
- */
-export function getTriggerMarketOrderParams(
-	params: Omit<OptionalOrderParams, 'orderType'> & {
-		triggerCondition: OrderTriggerCondition;
-		triggerPrice: BN;
-	}
-): OptionalOrderParams {
-	return getOrderParams(
-		Object.assign({}, params, {
-			orderType: OrderType.TRIGGER_MARKET,
-		})
-	);
-}
-
-/**
- * Builds `OptionalOrderParams` for a trigger limit order (`OrderType.TRIGGER_LIMIT`) — a
- * conditional order that becomes a resting limit order at `price` once the oracle price crosses
- * `triggerPrice` per `triggerCondition`.
- * @param params - Order fields (see `OrderParams`); `baseAssetAmount`, `triggerPrice`, and `price`
- * use BASE_PRECISION (1e9) and PRICE_PRECISION (1e6) respectively. `orderType` is set automatically.
- * @returns Params merged onto `DefaultOrderParams`, ready to pass to `placeOrder`/`placePerpOrder`.
- */
-export function getTriggerLimitOrderParams(
-	params: Omit<OptionalOrderParams, 'orderType'> & {
-		triggerCondition: OrderTriggerCondition;
-		triggerPrice: BN;
-		price: BN;
-	}
-): OptionalOrderParams {
-	return getOrderParams(
-		Object.assign({}, params, {
-			orderType: OrderType.TRIGGER_LIMIT,
-		})
-	);
-}
-
-/**
- * Builds `OptionalOrderParams` for a market order (`OrderType.MARKET`), filled immediately via a
- * Dutch auction between `auctionStartPrice` and `auctionEndPrice` (defaults derived on-chain from
- * the oracle price if omitted) over `auctionDuration` slots.
- * @param params - Order fields (see `OrderParams`); `baseAssetAmount` is in BASE_PRECISION (1e9),
- * any price fields are in PRICE_PRECISION (1e6). `orderType` is set automatically and must not be
- * passed in.
- * @returns Params merged onto `DefaultOrderParams`, ready to pass to `placeOrder`/`placePerpOrder`.
- */
-export function getMarketOrderParams(
-	params: Omit<OptionalOrderParams, 'orderType'>
-): OptionalOrderParams {
-	return getOrderParams(
-		Object.assign({}, params, {
-			orderType: OrderType.MARKET,
-		})
-	);
-}
-
-/**
- * Merges `optionalOrderParams` onto `DefaultOrderParams` (filling in any field the caller omitted,
- * e.g. `marketType: MarketType.PERP`, `reduceOnly: false`, no trigger/oracle-offset), then applies
- * `overridingParams` on top of that. Used internally by the `get*OrderParams` factories; call it
- * directly only if you need to force a field that a factory doesn't expose.
- *
- * example:
- * ```
- * const orderParams = getOrderParams(optionalOrderParams, { marketType: MarketType.PERP });
- * ```
- *
- * @param optionalOrderParams - Required order fields plus any optional `OrderParams` overrides.
- * @param overridingParams - Fields applied last, taking precedence over both the defaults and
- * `optionalOrderParams`.
- * @returns A fully-populated `OrderParams` object.
- */
-export function getOrderParams(
-	optionalOrderParams: OptionalOrderParams,
-	overridingParams: Record<string, any> = {}
-): OrderParams {
-	return Object.assign(
-		{},
-		DefaultOrderParams,
-		optionalOrderParams,
-		overridingParams
-	);
-}