> ## Documentation Index
> Fetch the complete documentation index at: https://docs.nilemarkets.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Supported Pairs
> Nile Markets currently supports EUR/USD (fixing 16:00 UTC, 5 display decimals) and USD/JPY (fixing 16:00 UTC, 3 display decimals) — Pyth-native ordering end-to-end, Pyth spot oracle + publisher forward prices across both
EUR/USD is the world's most traded currency pair — over \$1 trillion in daily spot volume, accounting
for roughly 23% of all global FX turnover. It was the first pair to launch on the Nile Markets
protocol, and USD/JPY was added as the second pair (see below).
## Why EUR/USD Matters for DeFi
While USD dominates onchain finance, most crypto companies, protocols, and globally distributed
teams have costs, revenues, or liabilities in EUR. European payroll, invoices from EU vendors,
and treasury management all create EUR/USD exposure that currently has no efficient onchain
hedging solution.
EUR/USD is the single most liquid currency pair in the world. This means reliable, frequently
updated oracle prices, tight confidence intervals, and deep publisher coverage from Pyth Network
— the ideal conditions for a non-deliverable forward (NDF) protocol.
## EUR/USD Basics
The EUR/USD exchange rate represents how many US Dollars one Euro is worth:
| Rate | Meaning |
| -------------- | ----------------------------------------------- |
| 1.0800 | 1 EUR = 1.08 USD |
| Rate goes up | Euro is strengthening (good for LONG positions) |
| Rate goes down | Euro is weakening (good for SHORT positions) |
EUR/USD typically moves in the 4th and 5th decimal place (pips). A move from 1.0800 to 1.0850 is a
50-pip move, representing a \~0.46% change. Major economic events (central bank decisions, employment
data) can cause moves of 50-200 pips in minutes.
## Three Price Types
The EUR/USD pair has three distinct price types, each serving a different purpose.
The real-time EUR/USD rate, sourced from Pyth Network. Pyth aggregates prices from institutional
publishers (exchanges, market makers, trading firms) and provides a confidence-weighted median.
* **Used for:** Recording the fixing price at settlement
* **Freshness:** Updated whenever a transaction includes Pyth price data
The expected EUR/USD rate at a future maturity date, computed using the interest rate differential
between EUR and USD. When USD rates exceed EUR rates, the forward trades above spot.
* **Used for:** Position entry prices, real-time PnL, early termination, liquidation
* **Freshness:** Published every \~30 seconds by the publisher service
The Pyth EUR/USD spot price captured at 4:00 PM UTC on a position's maturity business day. This
is the authoritative rate for cash settlement.
* **Used for:** Final PnL calculation at maturity
* **Timing:** 4 PM UTC, matching the ECB reference rate convention
* **Permanence:** Once recorded, a fixing price cannot be changed
## Why EUR/USD First?
The most traded pair in the world ensures deep, reliable oracle feeds with minimal latency and
high-confidence price data.
Pyth Network has extensive publisher coverage for EUR/USD, providing frequent updates with tight
confidence intervals.
EUR/USD is the pair most traders start with. Its macro drivers (ECB/Fed policy, trade balances)
are widely understood and covered.
## USD/JPY
USD/JPY is Nile Markets' second supported pair — the second-most-traded currency pair globally (\~13% of daily FX turnover) and the primary way to express a view on yen strength against USD.
### USD/JPY Basics
The USD/JPY exchange rate represents how many Japanese Yen one US Dollar is worth:
| Rate | Meaning |
| -------------- | ----------------------------------------------------------- |
| 150.00 | 1 USD = 150 JPY |
| Rate goes up | Yen is weakening against USD (good for LONG positions) |
| Rate goes down | Yen is strengthening against USD (good for SHORT positions) |
### Pyth-Native Ordering End-to-End
USD/JPY is registered on-chain using Pyth Network's native convention: `pairId = keccak256("USD/JPY")`, base = USD, quote = JPY, price ≈ 150. The same orientation flows through every layer — contracts, subgraph, services, CLI, MCP / x402, and the UI — with no inversion anywhere. A LONG USD/JPY position is long USD / short JPY.
* **On-chain pair name:** `USD/JPY` (matches Pyth feed `0xef2c98c8…`)
* **Display label:** `USD/JPY`
* **Display decimals:** 3
* **Pyth exponent:** -3 (smaller range than EUR/USD's -5)
* **Fixing time:** 16:00 UTC (the WM/Reuters London fix — the same institutional benchmark used for EUR/USD and every other registered pair)
### Trading USD/JPY
* **CLI:** pass `--pair USD/JPY` to `nile position open`, `nile oracle price`, `nile oracle state`, and `nile simulate open`.
* **MCP / x402:** pass `pairId: "0x35b8bafff3570683af968b8d36b91b1a19465141d9712425e9f76c68ff8cb152"` to any tool or endpoint that accepts a pair parameter.
* **App:** the pair selector in the top navigation switches the active pair for the trade form, dashboard, and position tables. Side labels ("Long USD", "Long EUR") are derived from the pair's base currency.
## Adding Future Pairs
The protocol is designed for multi-currency expansion. Each pair gets independent oracle state, enabled status in the PositionManager, fixing time in Config, and per-(pair, maturity) bucket exposure tracking — while sharing the same USDC liquidity pool.
Onboarding a third pair (GBP/USD, USD/CHF, etc.) requires no contract redeploy — operators run an admin script that calls `OracleModule.registerPair`, `PositionManager.enablePair`, and `Config.setPairFixingTime` from the protocol admin key.
For code examples using pair identifiers in TypeScript and Rust, see [TypeScript SDK](/build/typescript-sdk) and [Code Examples](/build/code-examples).