<!--
Sitemap:
- [Interop SDK Documentation](/index): Build multichain TypeScript apps with interoperable addresses, cross-chain quotes, transfer execution, and order tracking across providers.
- [Install Interop SDK](/installation): Install @wonderland/interop-addresses and @wonderland/interop-cross-chain, then choose the package that fits your multichain app.
- [Addresses Module](/addresses/): Parse, encode, and resolve chain-aware addresses that combine an account, chain, and optional ENS name into one unambiguous identifier.
- [Addresses: Getting Started](/addresses/getting-started): Parse an interoperable address and extract its components — go from a human-readable name like vitalik.eth@eip155:1 to address and chain ID.
- [Addresses: Concepts](/addresses/concepts): How EIP-7930, ERC-7828, and CAIP-350 combine address and chain into a single, unambiguous, validated identifier for multichain apps.
- [Parsing an Interoperable Name](/addresses/example): Walkthrough for wallet developers — extract the raw address and chain ID from an interop address so legacy contracts keep working.
- [Addresses: Advanced Usage](/addresses/advanced-usage): Advanced patterns for interoperable addresses — checksums, validation, error handling, and round-trip conversions between formats.
- [Addresses: API Reference](/addresses/api): Function signatures and types for the interop-addresses package — high-level helpers, name-layer methods, and binary-layer primitives.
- [Cross-Chain Module](/cross-chain/): One open source integration for cross-chain actions — compare quotes across providers, execute orders, and track completion.
- [Cross-Chain: Getting Started](/cross-chain/getting-started): Execute a cross-chain token transfer end-to-end — create a provider, fetch a quote, send the transaction, and track the order to completion.
- [Cross-Chain: Concepts](/cross-chain/concepts): The intent-based architecture behind the cross-chain package and how the SDK unifies heterogeneous bridge providers behind a common interface.
- [Supported Providers](/cross-chain/providers): Supported cross-chain providers (Across, Relay, OIF, Bungee, LiFi Intents) and how to configure each via createCrossChainProvider.
- [Across Provider](/cross-chain/across-provider): Configure and use the Across Protocol provider for cross-chain token transfers via the Across bridge infrastructure.
- [Relay Provider](/cross-chain/relay-provider): Configure and use the Relay Protocol provider for cross-chain transfers, including opt-in gasless execution via EIP-3009 signatures.
- [OIF Provider](/cross-chain/oif-provider): Direct integration with any OIF-compliant solver — submission modes, resource locks, and configuration for Open Intents Framework backends.
- [Bungee Provider](/cross-chain/bungee-provider): Cross-chain token transfers via Bungee — onchain transactions, gasless permit2 flow, and tier-based API access for sandbox or production.
- [LiFi Intents Provider](/cross-chain/lifi-intents-provider): Cross-chain transfers through the LI.FI intent solver marketplace, where competing solvers fulfill deposits at the best available rate.
- [Cross-Chain: Full Example](/cross-chain/example): End-to-end example of executing a cross-chain transfer — setup, quote, approval handling, transaction submission, and order tracking.
- [Cross-Chain: Frontend Integration](/cross-chain/frontend-integration): Wire the cross-chain SDK into a React/Next.js app with wagmi v2 — a useCrossChainSwap hook covering quotes, approvals, and submission.
- [Order Tracking](/cross-chain/order-tracking): Track cross-chain orders from initiation to completion via OIF OrderStatus events, with both onchain and offchain observation strategies.
- [Cross-Chain: Advanced Usage](/cross-chain/advanced-usage): Aggregator patterns for cross-chain transfers — multi-provider quote fetching, sorting strategies, timeouts, and built-in order tracking.
- [Cross-Chain: API Reference](/cross-chain/api): Function signatures and types for the interop-cross-chain package — providers, aggregator, approval service, and order tracking.
-->

# Supported Providers

This document lists all cross-chain providers supported by the Interop SDK.

## Available Providers

| Provider                                | Status | Description                                               |
| --------------------------------------- | ------ | --------------------------------------------------------- |
| [Across Protocol](/cross-chain/across-provider)    | Active | Cross-chain token transfers using Across bridge           |
| [Relay Protocol](/cross-chain/relay-provider)      | Active | Cross-chain token transfers using Relay bridge            |
| [OIF](/cross-chain/oif-provider)                   | Active | Direct integration with OIF-compliant solvers             |
| [Bungee Protocol](/cross-chain/bungee-provider)    | Active | Cross-chain transfers via onchain or gasless permit2 flow |
| [LiFi Intents](/cross-chain/lifi-intents-provider) | Active | Cross-chain via LiFi intent solver marketplace            |

## Provider Configuration

```ts twoslash
import { BungeeApiTier, createCrossChainProvider } from "@wonderland/interop-cross-chain";

// Across — no required config
createCrossChainProvider("across");
createCrossChainProvider("across", { isTestnet: true });

// Relay — no required config
createCrossChainProvider("relay");
createCrossChainProvider("relay", { apiKey: "...", isTestnet: true });

// OIF — solverId and url are required
createCrossChainProvider("oif", { solverId: "my-solver", url: "https://solver.example.com" });

// LiFi Intents — no required config (defaults to https://order.li.fi)
createCrossChainProvider("lifi-intents");
createCrossChainProvider("lifi-intents", { orderServerUrl: "https://..." });

// Bungee — no required config
createCrossChainProvider("bungee");
createCrossChainProvider("bungee", {
    tier: BungeeApiTier.Dedicated,
    apiKey: "...",
    affiliateId: "...",
});
```

| Provider       | Required Config   | Optional Config                                                                                                                                       |
| -------------- | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| `across`       | (none)            | `isTestnet`                                                                                                                                           |
| `relay`        | (none)            | `apiKey`, `isTestnet`                                                                                                                                 |
| `oif`          | `solverId`, `url` | —                                                                                                                                                     |
| `lifi-intents` | (none)            | `orderServerUrl`, `providerId`, `headers`                                                                                                             |
| `bungee`       | (none)            | `tier`, `apiKey`, `affiliateId`, `feeBps`, `feeTakerAddress`, `submissionModes`, `slippage`, `refuel`, `enableOtherProviders`, `enableMultipleRoutes` |

The optional-config protocols (`across`, `relay`, `bungee`, `lifi-intents`) can also be passed to `createAggregator` by name to get defaults — see [Compare quotes from multiple providers](/cross-chain/getting-started#compare-quotes-from-multiple-providers). Use `createCrossChainProvider` when you need custom config.

## `isTestnet` semantics

Only `across` and `relay` accept `isTestnet`. What it changes:

| Provider | API host                                      | Supported chains                                           | Tracking                                                                       | Asset discovery           |
| -------- | --------------------------------------------- | ---------------------------------------------------------- | ------------------------------------------------------------------------------ | ------------------------- |
| `across` | `app.across.to/api` → `testnet.across.to/api` | Mainnet routes → testnet routes (Sepolia, Base Sepolia, …) | Mainnet: API-based fill watcher. Testnet: event-based (needs destination RPC). | API → static testnet list |
| `relay`  | `api.relay.link` → `api.testnets.relay.link`  | Mainnet routes → testnet routes                            | API-based in both modes — no RPC URLs needed.                                  | API → static testnet list |

`oif`, `bungee`, and `lifi-intents` don't take an `isTestnet` flag. For those providers, switch networks by pointing `url` / `orderServerUrl` / `baseUrl` at a testnet endpoint.

## Order Tracking Requirements

Different providers use different tracking mechanisms. Some need RPC URLs, others are fully API-based:

| Provider         | Opened Intent Parser | Fill Watcher                   | RPC URLs Needed?                                   |
| ---------------- | -------------------- | ------------------------------ | -------------------------------------------------- |
| Across (mainnet) | OIF event-based      | API-based                      | Origin chain only                                  |
| Across (testnet) | OIF event-based      | Event-based                    | Origin + destination chains                        |
| Relay            | API-based            | API-based                      | None                                               |
| OIF              | OIF event-based      | API-based + Event-based (dual) | Origin always; destination when tracking by txHash |
| Bungee           | API-based            | API-based                      | None                                               |
| LiFi Intents     | Custom event-based   | API-based                      | Origin chain only                                  |

## Creating Custom Providers

You can create custom providers by extending the `CrossChainProvider` abstract class. Two methods are required (`getQuotes` and `getTrackingConfig`); the rest have default implementations that throw `ProviderExecuteNotImplemented`.

```typescript
import type {
    FillWatcherConfig,
    OpenedIntentParserConfig,
    PreTrackerConfig,
    Quote,
    QuoteRequest,
    SubmitOrderResponse,
} from "@wonderland/interop-cross-chain";
import type { Hex } from "viem";
import { CrossChainProvider } from "@wonderland/interop-cross-chain";

class MyCustomProvider extends CrossChainProvider {
    readonly protocolName = "my-protocol";
    readonly providerId = "my-protocol-1";

    // Required: fetch quotes from your protocol's API
    async getQuotes(params: QuoteRequest): Promise<Quote[]> {
        // Adapt params to your protocol's format, call your API,
        // and return an array of Quote objects
    }

    // Required: configure how the SDK tracks orders for your protocol
    getTrackingConfig(): {
        openedIntentParserConfig: OpenedIntentParserConfig;
        fillWatcherConfig: FillWatcherConfig;
        onChainFillWatcherConfig?: FillWatcherConfig; // optional, for on-chain fill detection
        preTrackerConfig?: PreTrackerConfig;
    } {
        // Return protocol-specific tracking configuration
        // fillWatcherConfig is used for orderId/API tracking
        // onChainFillWatcherConfig (if set) is used for txHash/on-chain tracking
        // See OIF provider for a dual-watcher example, Across for single-watcher
    }

    // Optional: override to support gasless (signature-based) order submission
    // Default throws ProviderExecuteNotImplemented
    async submitOrder(quote: Quote, signature: Hex): Promise<SubmitOrderResponse> {
        // Submit the signed order to your protocol's API
    }
}
```

See the [API Reference](/cross-chain/api) for the full `Quote`, `QuoteRequest`, and tracking config types.

## References

* [API Reference](/cross-chain/api)
* [Getting Started](/cross-chain/getting-started) — tutorial for your first cross-chain transfer
* [Concepts](/cross-chain/concepts) — how providers fit into the intent architecture
* [Advanced Usage](/cross-chain/advanced-usage) — aggregation, sorting, and error handling