@lifi/perps-sdk 0.1.1-alpha.4 → 0.1.1-alpha.40

package/src/utils/calculations.ts

@@ -0,0 +1,209 @@
+/**
+ * Universal perpetual futures calculation utilities.
+ *
+ * Pure functions for computing position-related values that any consumer
+ * of the perps SDK would need. All parameters are required — no default
+ * values for critical financial parameters.
+ */
+
+/**
+ * Calculate position size in asset units from margin.
+ *
+ * @param marginUsd - Margin amount in USD
+ * @param leverage - Position leverage
+ * @param price - Current asset price
+ * @returns Position size in asset units
+ */
+export function calculatePositionSize(
+  marginUsd: number,
+  leverage: number,
+  price: number
+): number {
+  return (marginUsd * leverage) / price
+}
+
+/**
+ * Calculate notional value of a position.
+ *
+ * @param size - Position size in asset units
+ * @param price - Current asset price
+ * @returns Notional value in USD
+ */
+export function calculateNotionalValue(size: number, price: number): number {
+  return Math.abs(size) * price
+}
+
+/**
+ * Calculate unrealized PnL.
+ *
+ * @param entryPrice - Position entry price
+ * @param currentPrice - Current market price
+ * @param size - Position size (positive for long, negative for short)
+ * @returns Unrealized PnL in USD
+ */
+export function calculateUnrealizedPnl(
+  entryPrice: number,
+  currentPrice: number,
+  size: number
+): number {
+  return (currentPrice - entryPrice) * size
+}
+
+/**
+ * Calculate return on equity (ROE) percentage.
+ *
+ * @param pnl - Profit/loss in USD
+ * @param margin - Initial margin in USD
+ * @returns ROE as percentage (e.g., 10 for 10%)
+ */
+export function calculateRoe(pnl: number, margin: number): number {
+  if (margin === 0) {
+    return 0
+  }
+  return (pnl / margin) * 100
+}
+
+/**
+ * Calculate required margin for a position.
+ *
+ * @param notionalValue - Position notional value in USD
+ * @param leverage - Position leverage
+ * @returns Required margin in USD
+ */
+export function calculateRequiredMargin(
+  notionalValue: number,
+  leverage: number
+): number {
+  return notionalValue / leverage
+}
+
+/**
+ * Estimate trading fees.
+ *
+ * @param sizeUsd - Position size in USD (notional value)
+ * @param feeRate - Fee rate as decimal (e.g., 0.00035 for 0.035%)
+ * @returns Estimated fee in USD
+ */
+export function estimateFees(sizeUsd: number, feeRate: number): number {
+  return sizeUsd * feeRate
+}
+
+/**
+ * Apply slippage to a price for order execution.
+ *
+ * @param price - Base price
+ * @param slippagePercent - Slippage tolerance as percentage (e.g., 0.5 for 0.5%)
+ * @param isBuy - True if buying (price goes up), false if selling (price goes down)
+ * @returns Price adjusted for slippage
+ */
+export function applySlippage(
+  price: number,
+  slippagePercent: number,
+  isBuy: boolean
+): number {
+  const multiplier = 1 + slippagePercent / 100
+  return isBuy ? price * multiplier : price / multiplier
+}
+
+// ---------------------------------------------------------------------------
+// TP/SL expected P&L calculations
+// ---------------------------------------------------------------------------
+
+export interface ExpectedPnl {
+  amount: number
+  percent: number
+}
+
+/**
+ * Calculate expected gain/loss for a TP or SL trigger price.
+ * Returns signed values — positive means profit, negative means loss.
+ *
+ * @param triggerPrice - The TP or SL target price
+ * @param entryPrice - Position entry / current market price
+ * @param leverage - Position leverage multiplier
+ * @param isLong - True for long positions, false for short
+ * @param margin - Margin amount in USD
+ */
+export function calculateExpectedPnl(
+  triggerPrice: number,
+  entryPrice: number,
+  leverage: number,
+  isLong: boolean,
+  margin: number
+): ExpectedPnl | null {
+  if (!triggerPrice || entryPrice === 0 || margin === 0) {
+    return null
+  }
+  const priceDiff = isLong
+    ? triggerPrice - entryPrice
+    : entryPrice - triggerPrice
+  const percent = (priceDiff / entryPrice) * leverage * 100
+  const amount = margin * (percent / 100)
+  return { amount, percent }
+}
+
+/**
+ * Convert a percentage gain/loss to a target price.
+ *
+ * @param percent - Target gain/loss percentage (positive = profitable direction)
+ * @param entryPrice - Position entry price
+ * @param leverage - Position leverage multiplier
+ * @param isLong - True for long positions, false for short
+ */
+export function priceFromPercent(
+  percent: number,
+  entryPrice: number,
+  leverage: number,
+  isLong: boolean
+): number {
+  if (entryPrice === 0 || leverage === 0) {
+    return 0
+  }
+  const priceDelta = (percent / 100 / leverage) * entryPrice
+  return isLong ? entryPrice + priceDelta : entryPrice - priceDelta
+}
+
+/**
+ * Convert a target price to a percentage gain/loss.
+ *
+ * @param price - Target price
+ * @param entryPrice - Position entry price
+ * @param leverage - Position leverage multiplier
+ * @param isLong - True for long positions, false for short
+ */
+export function percentFromPrice(
+  price: number,
+  entryPrice: number,
+  leverage: number,
+  isLong: boolean
+): number {
+  if (entryPrice === 0 || leverage === 0) {
+    return 0
+  }
+  const priceDiff = isLong ? price - entryPrice : entryPrice - price
+  return (priceDiff / entryPrice) * leverage * 100
+}
+
+// ---------------------------------------------------------------------------
+// Realized PnL percentage
+// ---------------------------------------------------------------------------
+
+/**
+ * Calculate realized PnL as a percentage of position value at close.
+ *
+ * @param realizedPnl - The realized profit/loss in USD
+ * @param size - Position size in asset units at close
+ * @param price - Price at close
+ * @returns PnL as a percentage of position value
+ */
+export function calculateRealizedPnlPercent(
+  realizedPnl: number,
+  size: number,
+  price: number
+): number {
+  const positionValue = Math.abs(size) * price
+  if (positionValue === 0) {
+    return 0
+  }
+  return (realizedPnl / positionValue) * 100
+}

package/src/utils/hyperliquid/index.ts

@@ -0,0 +1,9 @@
+export {
+  calculateLiquidationPrice,
+  calculateMaintenanceMarginRate,
+} from './liquidation.js'
+export {
+  formatOrderPrice,
+  formatOrderSize,
+  getMaxPriceDecimals,
+} from './orderFormatting.js'

package/src/utils/hyperliquid/liquidation.ts

@@ -0,0 +1,71 @@
+/**
+ * Hyperliquid-specific liquidation price calculation.
+ *
+ * Uses the exact formula from Hyperliquid docs:
+ * https://hyperliquid.gitbook.io/hyperliquid-docs/trading/liquidations
+ *
+ * liq_price = price - side * margin_available / position_size / (1 - l * side)
+ *
+ * Where:
+ * - l = 1 / (2 * maxLeverage) (maintenance margin fraction)
+ * - side = 1 (long) or -1 (short)
+ * - margin_available = isolated_margin - maintenance_margin_required
+ */
+
+/**
+ * Calculate the maintenance margin fraction for a Hyperliquid asset.
+ *
+ * Maintenance margin is half of the initial margin at max leverage.
+ *
+ * @param maxLeverage - Maximum leverage for the asset (e.g., 50 for BTC)
+ * @returns Maintenance margin fraction (e.g., 0.01 for 50x max leverage),
+ *   or undefined if maxLeverage is zero
+ */
+export function calculateMaintenanceMarginRate(
+  maxLeverage: number
+): number | undefined {
+  if (maxLeverage === 0) {
+    return undefined
+  }
+  return 1 / (2 * maxLeverage)
+}
+
+/**
+ * Calculate liquidation price using the exact Hyperliquid formula.
+ *
+ * For isolated margin, new position prediction. For existing positions,
+ * prefer Position.liquidationPrice from the API.
+ *
+ * Formula derivation (isolated margin, single position):
+ *   margin_per_unit        = entryPrice / leverage
+ *   maintenance_per_unit   = entryPrice * mmr
+ *   margin_available       = margin_per_unit - maintenance_per_unit
+ *   liq_price              = entryPrice - side * margin_available / (1 - mmr * side)
+ *
+ * Where mmr = 1 / (2 * maxLeverage).
+ *
+ * @param entryPrice - Position entry price
+ * @param leverage - User-selected leverage (e.g., 10)
+ * @param isLong - True if long position, false if short
+ * @param maxLeverage - Asset's maximum leverage (e.g., 50 for BTC). Determines
+ *   the maintenance margin rate: mmr = 1 / (2 * maxLeverage)
+ * @returns Estimated liquidation price, or undefined if inputs are invalid
+ */
+export function calculateLiquidationPrice(
+  entryPrice: number,
+  leverage: number,
+  isLong: boolean,
+  maxLeverage: number
+): number | undefined {
+  if (leverage === 0 || maxLeverage === 0) {
+    return undefined
+  }
+  const mmr = 1 / (2 * maxLeverage)
+  const side = isLong ? 1 : -1
+  const denominator = 1 - mmr * side
+  if (denominator === 0) {
+    return undefined
+  }
+  const marginAvailable = entryPrice * (1 / leverage - mmr)
+  return entryPrice - (side * marginAvailable) / denominator
+}

package/src/utils/hyperliquid/orderFormatting.ts

@@ -0,0 +1,96 @@
+/**
+ * Hyperliquid order size and price formatting for exchange submission.
+ *
+ * These encode Hyperliquid-specific order submission rules. Getting size/price
+ * formatting wrong causes rejected orders.
+ *
+ * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/tick-and-lot-size
+ */
+
+import { stringToFloat } from '../parse.js'
+
+/**
+ * Max combined decimals (size + price) enforced by Hyperliquid.
+ * Perps: 6, Spot: 8
+ */
+const MAX_DECIMALS_PERPS = 6
+const MAX_DECIMALS_SPOT = 8
+
+function getMaxDecimals(market?: string): number {
+  return market === 'spot' ? MAX_DECIMALS_SPOT : MAX_DECIMALS_PERPS
+}
+
+/**
+ * Derive the maximum number of price decimal places for a given asset.
+ *
+ * @param szDecimals - The asset's szDecimals (from market meta)
+ * @param market - Optional market type (e.g. 'spot'). Defaults to perps rules.
+ * @returns Maximum allowed price decimals
+ */
+export function getMaxPriceDecimals(
+  szDecimals: number,
+  market?: string
+): number {
+  return Math.max(0, getMaxDecimals(market) - szDecimals)
+}
+
+/**
+ * Format a size value for order submission.
+ *
+ * Per Hyperliquid docs (tick-and-lot-size):
+ * - Size must be rounded to the asset's szDecimals
+ * - Trailing zeroes must be removed for signing
+ *
+ * @param size - The size value to format
+ * @param szDecimals - Number of decimal places allowed for this asset (from meta)
+ * @returns Size as a string with correct precision, no trailing zeros
+ */
+export function formatOrderSize(size: number, szDecimals: number): string {
+  // Truncate (don't round up) to avoid exceeding available balance
+  const multiplier = 10 ** szDecimals
+  const truncated = Math.floor(size * multiplier) / multiplier
+  // Remove trailing zeros by round-tripping through stringToFloat
+  return stringToFloat(truncated.toFixed(szDecimals)).toString()
+}
+
+/**
+ * Format a price value for order submission.
+ *
+ * Per Hyperliquid docs (tick-and-lot-size):
+ * - Maximum 5 significant figures
+ * - Max decimals = MAX_DECIMALS - szDecimals (6 for perps, 8 for spot)
+ * - Integer prices always allowed regardless of significant figures
+ * - Trailing zeroes must be removed for signing
+ *
+ * @param price - The price value to format
+ * @param szDecimals - The asset's szDecimals (affects max price decimals)
+ * @param market - Optional market type (e.g. 'spot'). Defaults to perps rules.
+ * @returns Price as a string with correct precision, no trailing zeros
+ */
+export function formatOrderPrice(
+  price: number,
+  szDecimals: number,
+  market?: string
+): string {
+  const maxPriceDecimals = getMaxPriceDecimals(szDecimals, market)
+
+  // Round to max allowed decimals
+  let rounded = stringToFloat(price.toFixed(maxPriceDecimals))
+
+  // Integer prices are always allowed regardless of significant figures
+  if (Number.isInteger(rounded)) {
+    return rounded.toString()
+  }
+
+  // Count significant figures (digits excluding leading zeros)
+  const absStr = Math.abs(rounded).toString().replace('.', '')
+  const sigFigs = absStr.replace(/^0+/, '').length
+
+  // If more than 5 significant figures, round to 5
+  if (sigFigs > 5) {
+    rounded = stringToFloat(rounded.toPrecision(5))
+  }
+
+  // Return without trailing zeros
+  return rounded.toString()
+}

package/src/utils/orderClassification.ts

@@ -0,0 +1,64 @@
+/**
+ * Order classification utilities.
+ *
+ * Type guards and classifiers that operate on SDK types to determine
+ * order categories (TP/SL, open/close). These use the OrderType enum
+ * for classification — no string matching.
+ */
+
+import type { OpenOrder } from '@lifi/perps-types'
+import { FillClassification, OrderSide, OrderType } from '@lifi/perps-types'
+import { stringToFloat } from './parse.js'
+
+export { FillClassification }
+
+const TP_TYPES = new Set<OrderType>([
+  OrderType.TAKE_PROFIT_MARKET,
+  OrderType.TAKE_PROFIT_LIMIT,
+])
+
+const SL_TYPES = new Set<OrderType>([
+  OrderType.STOP_MARKET,
+  OrderType.STOP_LIMIT,
+])
+
+/**
+ * Check if an open order is a Take Profit trigger order.
+ */
+export function isTakeProfitOrder(order: Pick<OpenOrder, 'type'>): boolean {
+  return TP_TYPES.has(order.type)
+}
+
+/**
+ * Check if an open order is a Stop Loss trigger order.
+ */
+export function isStopLossOrder(order: Pick<OpenOrder, 'type'>): boolean {
+  return SL_TYPES.has(order.type)
+}
+
+/**
+ * Check if an open order is a TP or SL trigger order.
+ */
+export function isTpSlOrder(order: Pick<OpenOrder, 'type'>): boolean {
+  return TP_TYPES.has(order.type) || SL_TYPES.has(order.type)
+}
+
+/**
+ * Classify a fill as open or close based on realizedPnl.
+ * @deprecated Use `Fill.classification` instead — it uses startPosition
+ * for accurate open/increase/reduce/close/reverse classification.
+ */
+export function classifyFill(
+  side: OrderSide,
+  realizedPnl: string | null | undefined
+): FillClassification {
+  const isClose = realizedPnl != null && stringToFloat(realizedPnl) !== 0
+  if (side === OrderSide.BUY) {
+    return isClose
+      ? FillClassification.CLOSED_SHORT
+      : FillClassification.OPENED_LONG
+  }
+  return isClose
+    ? FillClassification.CLOSED_LONG
+    : FillClassification.OPENED_SHORT
+}

package/src/utils/parse.ts

@@ -0,0 +1,28 @@
+/**
+ * Robust string-to-number parsing utilities.
+ */
+
+/**
+ * Parse a string to a float, stripping common formatting artefacts.
+ *
+ * Handles:
+ * - Currency prefixes/suffixes ($, USD, etc.)
+ * - Explicit sign prefixes (+/-)
+ * - Thousands separators (commas)
+ * - Percentage suffixes (%)
+ * - Whitespace
+ *
+ * @param value - The string to parse
+ * @returns Parsed number, or NaN if the string contains no valid number
+ */
+export function stringToFloat(value: string): number {
+  if (!value) {
+    return 0
+  }
+  // Strip whitespace, currency symbols, thousands commas, and % suffix
+  const cleaned = value.trim().replace(/[$%]/g, '').replace(/,/g, '').trim()
+  if (!cleaned) {
+    return 0
+  }
+  return parseFloat(cleaned)
+}

package/src/utils/request.ts

@@ -1,9 +1,9 @@
+import type { PerpsErrorBody } from '@lifi/perps-types'
 import { PerpsErrorCode } from '@lifi/perps-types'
 import type {
   PerpsBaseConfig,
   SDKRequestOptions,
 } from '../client/createPerpsClient.js'
-import { HTTPError } from '../errors/HTTPError.js'
 import { PerpsError } from '../errors/PerpsError.js'
 import { version } from '../version.js'
 import { sleep } from './sleep.js'
@@ -23,8 +23,7 @@ const DEFAULT_RETRIES = 1
  * @param options - Fetch options plus retries
  * @param sdkOptions - SDK-specific options (signal, etc.)
  * @returns Parsed JSON response
- * @throws {HTTPError} On non-2xx responses
- * @throws {PerpsError} On network or parsing errors
+ * @throws {PerpsError} On non-2xx responses or network errors
  */
 export async function request<T>(
   config: PerpsBaseConfig,
@@ -61,10 +60,13 @@ export async function request<T>(
     const response = await fetch(url, finalOptions)
 
     if (!response.ok) {
-      const error = new HTTPError(response, url)
-      await error.buildAdditionalDetails()
+      // Parse the backend's error body
+      let body: PerpsErrorBody | undefined
+      try {
+        body = await response.json()
+      } catch {}
 
-      // Retry on 5xx errors
+      // Retry on 5xx before throwing
       if (retries > 0 && response.status >= 500) {
         await sleep(500)
         return request<T>(
@@ -75,12 +77,25 @@ export async function request<T>(
         )
       }
 
+      // Rehydrate backend error — code/message/tool come straight from the response
+      const fallbackMessage = `Request failed with status code ${response.status}`
+      if (
+        body &&
+        typeof body.code === 'number' &&
+        typeof body.message === 'string'
+      ) {
+        const error = new PerpsError(body.code, body.message)
+        error.tool = body.tool ?? 'unknown'
+        throw error
+      }
+      const error = new PerpsError(PerpsErrorCode.DefaultError, fallbackMessage)
+      error.tool = 'unknown'
       throw error
     }
 
     return (await response.json()) as T
   } catch (error) {
-    if (error instanceof HTTPError || error instanceof PerpsError) {
+    if (error instanceof PerpsError) {
       throw error
     }
 

package/src/utils/units.ts

@@ -0,0 +1,32 @@
+/**
+ * Token unit conversion utilities.
+ */
+
+import { formatUnits } from 'viem'
+
+/**
+ * Convert a base-unit amount (bigint string) to a human-readable decimal string.
+ *
+ * @param amount - Amount in base units (e.g. "1000000" for 1 USDC)
+ * @param decimals - Token decimals (e.g. 6 for USDC)
+ * @returns Decimal string (e.g. "1.0")
+ */
+export function fromBaseUnits(amount: string, decimals: number): string {
+  try {
+    return formatUnits(BigInt(amount), decimals)
+  } catch {
+    return '0'
+  }
+}
+
+/**
+ * Convert a base-unit amount to a number.
+ *
+ * @param amount - Amount in base units
+ * @param decimals - Token decimals
+ * @returns Numeric value, or 0 if parsing fails
+ */
+export function fromBaseUnitsNumber(amount: string, decimals: number): number {
+  const value = Number(fromBaseUnits(amount, decimals))
+  return Number.isFinite(value) ? value : 0
+}

package/src/utils/validation.ts

@@ -0,0 +1,35 @@
+/**
+ * Order validation utilities.
+ */
+
+/**
+ * Validate margin input against available balance and exchange minimums.
+ *
+ * @param margin - Margin amount in USD
+ * @param leverage - Position leverage
+ * @param availableBalance - Available balance, or null if unknown
+ * @param feeRate - Fee rate as decimal, or null if unknown
+ * @param minMarginUsd - Minimum margin requirement in USD (exchange-specific)
+ * @returns Error code: 'insufficient' | 'below-minimum' | '' (valid)
+ */
+export function validateMargin(
+  margin: number,
+  leverage: number,
+  availableBalance: number | null,
+  feeRate: number | null,
+  minMarginUsd: number
+): string {
+  if (margin <= 0) {
+    return ''
+  }
+
+  if (availableBalance !== null && margin > availableBalance) {
+    return 'insufficient'
+  }
+
+  if (margin < minMarginUsd) {
+    return 'below-minimum'
+  }
+
+  return ''
+}

package/src/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/perps-sdk'
-export const version = '0.1.1-alpha.4'
+export const version = '0.1.1-alpha.40'

package/dist/cjs/dex/hyperliquid.d.ts

@@ -1,3 +0,0 @@
-import type { DexAuthProvider } from './types.js';
-export declare const hyperliquidAuthProvider: DexAuthProvider;
-//# sourceMappingURL=hyperliquid.d.ts.map

package/dist/cjs/dex/hyperliquid.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hyperliquid.d.ts","sourceRoot":"","sources":["../../../src/dex/hyperliquid.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD,eAAO,MAAM,uBAAuB,EAAE,eAiBrC,CAAA"}

package/dist/cjs/dex/hyperliquid.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hyperliquidAuthProvider = void 0;
-exports.hyperliquidAuthProvider = {
-    getAuthorizationInputs({ signingMode, agentAddress }) {
-        if (signingMode === 'USER') {
-            return {
-                user: [{ key: 'ApproveBuilderFee' }, { key: 'UserSetAbstraction' }],
-                agent: [],
-            };
-        }
-        return {
-            user: [
-                { key: 'ApproveAgent', params: { agentAddress } },
-                { key: 'ApproveBuilderFee' },
-            ],
-            agent: [{ key: 'AgentSetAbstraction' }],
-        };
-    },
-};
-//# sourceMappingURL=hyperliquid.js.map

package/dist/cjs/dex/hyperliquid.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hyperliquid.js","sourceRoot":"","sources":["../../../src/dex/hyperliquid.ts"],"names":[],"mappings":";;;AAEa,QAAA,uBAAuB,GAAoB;IACtD,sBAAsB,CAAC,EAAE,WAAW,EAAE,YAAY,EAAE;QAClD,IAAI,WAAW,KAAK,MAAM,EAAE,CAAC;YAC3B,OAAO;gBACL,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,mBAAmB,EAAE,EAAE,EAAE,GAAG,EAAE,oBAAoB,EAAE,CAAC;gBACnE,KAAK,EAAE,EAAE;aACV,CAAA;QACH,CAAC;QAED,OAAO;YACL,IAAI,EAAE;gBACJ,EAAE,GAAG,EAAE,cAAc,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,EAAE;gBACjD,EAAE,GAAG,EAAE,mBAAmB,EAAE;aAC7B;YACD,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,qBAAqB,EAAE,CAAC;SACxC,CAAA;IACH,CAAC;CACF,CAAA"}

package/dist/cjs/dex/registry.d.ts

@@ -1,3 +0,0 @@
-import type { DexAuthProvider } from './types.js';
-export declare function getDexAuthProvider(dex: string): DexAuthProvider;
-//# sourceMappingURL=registry.d.ts.map

package/dist/cjs/dex/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/dex/registry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAMjD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAM/D"}

package/dist/cjs/dex/registry.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDexAuthProvider = getDexAuthProvider;
-const PerpsSDKError_js_1 = require("../errors/PerpsSDKError.js");
-const hyperliquid_js_1 = require("./hyperliquid.js");
-const providers = {
-    hyperliquid: hyperliquid_js_1.hyperliquidAuthProvider,
-};
-function getDexAuthProvider(dex) {
-    const provider = providers[dex];
-    if (!provider) {
-        throw new PerpsSDKError_js_1.PerpsSDKError(new Error(`Unsupported dex: ${dex}`));
-    }
-    return provider;
-}
-//# sourceMappingURL=registry.js.map

package/dist/cjs/dex/registry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/dex/registry.ts"],"names":[],"mappings":";;AAQA,gDAMC;AAdD,iEAA0D;AAC1D,qDAA0D;AAG1D,MAAM,SAAS,GAAoC;IACjD,WAAW,EAAE,wCAAuB;CACrC,CAAA;AAED,SAAgB,kBAAkB,CAAC,GAAW;IAC5C,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,CAAA;IAC/B,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,gCAAa,CAAC,IAAI,KAAK,CAAC,oBAAoB,GAAG,EAAE,CAAC,CAAC,CAAA;IAC/D,CAAC;IACD,OAAO,QAAQ,CAAA;AACjB,CAAC"}