Glossary

ERC-7683 (Cross-Chain Intent Standard)

ERC-7683 is a standard for expressing cross-chain intents so solver networks can fulfill orders across blockchains.

Key Takeaways

  • ERC-7683 defines a common format for cross-chain orders: users sign an intent (such as "swap token A on chain X for token B on chain Y"), and any compliant solver can fill it.
  • The standard separates order expression from settlement logic: it specifies the order structs and settlement contract interfaces but leaves proof mechanisms, filler competition, and repayment to each implementation.
  • ERC-7683 is a foundation for chain abstraction: when combined with account-layer upgrades like EIP-7702, it enables a UX where users interact with any chain without managing bridges or gas tokens manually.

What Is ERC-7683?

ERC-7683 is an Ethereum standard that defines a universal format for cross-chain trade orders. Rather than building a bridge or a specific settlement protocol, it creates a shared language that any solver (also called a filler) can understand and compete to fulfill. A user signs a structured order describing what they want: for example, deposit 1,000 USDC on Arbitrum and receive 1,000 USDT on Optimism. Any solver monitoring the standard can pick up that order, execute the fill on the destination chain, and later claim reimbursement on the origin chain.

The standard was co-authored by contributors from Uniswap Labs and Across Protocol, first proposed in 2024. Its core insight is that cross-chain intent systems were already proliferating (UniswapX, Across, 1inch Fusion, and others), but each used its own proprietary order format. This fragmented the solver market: a filler built for UniswapX could not fill Across orders, and vice versa. ERC-7683 solves this by defining a common order envelope that any protocol can adopt, so solvers compete across all compliant platforms simultaneously.

How It Works

ERC-7683 defines two order types, two settlement contract interfaces, and a resolution mechanism that converts raw orders into actionable fill instructions.

Order Types

The standard specifies two structs for expressing cross-chain orders, each suited to a different submission model:

  • GaslessCrossChainOrder: the user signs the order off-chain (using EIP-712 typed data), and a solver submits it on-chain on the user's behalf. The user pays no origin-chain gas. This is the model used by systems like UniswapX, where solvers absorb gas costs and recoup them through fill margins.
  • OnchainCrossChainOrder: the user submits the order directly by calling a contract function on the origin chain. The user pays their own gas but retains full control over submission timing.

Both structs share common fields: the settlement contract address, the swapper's address, a nonce for replay protection, the origin chain ID, initiation and fill deadlines, and an opaque orderData field. The orderData bytes are implementation-specific: each protocol encodes its own parameters (token addresses, amounts, fee structures, exclusivity windows) inside this field.

struct GaslessCrossChainOrder {
    address settlementContract;
    address swapper;
    uint256 nonce;
    uint32  originChainId;
    uint32  openDeadline;
    uint32  fillDeadline;
    bytes32 orderDataType;
    bytes   orderData;
}

struct OnchainCrossChainOrder {
    uint32  fillDeadline;
    bytes32 orderDataType;
    bytes   orderData;
}

Settlement Interfaces

The standard defines two contract interfaces that settlement systems must implement:

  • IOriginSettler: deployed on the origin chain. Exposes open() for on-chain orders and openFor() for gasless orders submitted by a solver on behalf of a user. When called, it validates the order, escrows the user's input tokens, and emits an event that solvers monitor.
  • IDestinationSettler: deployed on the destination chain. Exposes a fill() function that solvers call to deliver the output tokens to the user. It verifies that the fill matches the original order parameters.

Order Resolution

Because orderData is opaque, the standard includes a resolution step. The origin settler's resolve() function takes a raw order and returns a ResolvedCrossChainOrder: a normalized struct containing the swapper's input tokens, the expected output tokens, and the filler's outputs (their reimbursement). This lets any solver decode any compliant order without knowing the protocol-specific encoding.

struct ResolvedCrossChainOrder {
    address   settlementContract;
    address   swapper;
    uint256   nonce;
    uint32    originChainId;
    uint32    fillDeadline;
    Input[]   swapperInputs;   // tokens the user deposits
    Output[]  swapperOutputs;  // tokens the user receives
    Output[]  fillerOutputs;   // filler reimbursement
}

struct Input {
    address token;
    uint256 amount;
}

struct Output {
    address token;
    uint256 amount;
    address recipient;
    uint32  chainId;
}

End-to-End Flow

A typical ERC-7683 cross-chain swap follows these steps:

  1. The user signs a GaslessCrossChainOrder (or submits an OnchainCrossChainOrder directly)
  2. A solver picks up the order, calls openFor() (or open()) on the origin settler, escrowing the user's input tokens
  3. The solver delivers the output tokens to the user on the destination chain by calling fill() on the destination settler
  4. The solver proves the fill occurred and claims reimbursement from the origin settler (the proof mechanism is protocol-specific)

The standard deliberately leaves the settlement proof layer unspecified. Across uses an optimistic oracle model, UniswapX uses off-chain attestations, and other implementations can use their own approach. This flexibility means any bridge or settlement system can adopt ERC-7683 without changing its core security model.

ERC-7683 and ERC-7702: Complementary Standards

While ERC-7683 handles the execution layer (what do I want to happen across chains?), EIP-7702 handles the account layer (how does my wallet authorize and pay for it?). Together, they form two halves of a chain-abstracted UX.

EIP-7702 (introduced in Ethereum's Pectra upgrade) allows externally owned accounts (EOAs) to temporarily delegate to smart contract code. This enables features like gas sponsorship, batch transactions, and session keys: a user can authorize a cross-chain intent without holding native gas tokens on the origin chain.

In practice, this means a user could sign an ERC-7683 intent from a wallet that has no ETH for gas. A solver picks up the gasless order, submits it, and pays the gas. The user's account-abstracted wallet handles the authorization via EIP-7702 delegation. The result: the user interacts with one interface and their tokens move across chains without manual bridging, gas management, or chain switching.

Use Cases

Cross-Chain Token Swaps

The primary use case is intent-based cross-chain swaps. A user on Ethereum mainnet wants tokens on Arbitrum: they sign an ERC-7683 order, a solver fills it, and the user receives tokens on Arbitrum within seconds. Because the standard is solver-agnostic, multiple fillers compete on price, driving down costs for users.

DEX Aggregator Integration

DEX aggregators and bridge aggregators can route through any ERC-7683-compliant settlement system. Instead of integrating each bridge separately, an aggregator submits standardized orders and lets the solver market determine the best execution path. This reduces integration overhead and increases competitive pricing across bridge aggregators.

Wallet-Native Cross-Chain UX

Wallets can embed ERC-7683 to offer seamless cross-chain transfers. A user clicks "send USDC to Base" inside their wallet, and the wallet constructs and signs an ERC-7683 order behind the scenes. The user never interacts with a bridge UI, selects a network, or worries about which liquidity source is cheapest.

Stablecoin Transfers Across Chains

For stablecoin cross-chain transfers, ERC-7683 provides a standardized way to express a simple intent: move value from chain A to chain B. Solvers can fill stablecoin orders using their own inventory across chains, often settling faster than traditional bridge mechanisms that require finality on the source chain.

Adoption

As of 2026, ERC-7683 has been adopted by dozens of protocols. Early adopters include Across Protocol (which uses it as the native order format for its optimistic bridge), UniswapX (for cross-chain swap orders), Eco (for its intent-based routing), and aggregators like LI.FI and Symbiosis. The standard's website lists over 70 protocol integrations.

Okto has built ERC-7683 support for Solana, extending the standard's reach beyond EVM chains. While the core structs use EVM-native types (Solidity structs, EIP-712 signatures), adapter layers can translate orders for non-EVM execution environments. For a deeper analysis of how the standard fits into Ethereum's multi-chain settlement landscape, see the ERC-7683 cross-chain intents research article.

Risks and Considerations

Solver Centralization

While ERC-7683 enables an open solver market, the capital requirements for filling cross-chain orders can concentrate activity among a few well-capitalized fillers. If only a handful of solvers operate across all chains, the theoretical benefit of competition diminishes, and users may face worse pricing during low-liquidity periods.

Settlement Proof Diversity

The standard intentionally leaves settlement proofs unspecified. This flexibility means each implementation carries its own security assumptions: optimistic proofs have challenge periods, attestation-based systems depend on trusted signers, and validity proofs require cryptographic verification. Users interacting through a wallet or aggregator may not know which proof model secures their particular fill.

Non-EVM Limitations

The order structs use Solidity types and EIP-712 signatures, making native EVM integration straightforward. Non-EVM chains (Solana, Bitcoin L2s, Cosmos) require adapter contracts or off-chain translation layers, which add complexity and potential failure points. The standard does not yet define a canonical approach for non-EVM settlement.

Opaque Order Data

The orderData field is an arbitrary bytes payload whose encoding varies by implementation. While the resolve() function normalizes this into a standard struct, bugs in protocol-specific encoding or decoding logic could cause orders to be misinterpreted. Solvers filling orders across multiple protocols must correctly handle each protocol's orderData format.

MEV and Front-Running

Cross-chain intents create MEV opportunities. Solvers can observe pending orders and front-run fills, or extract value by timing execution across chains. Some implementations mitigate this with exclusivity windows (giving a specific filler priority for a short period) or order flow auctions, but these mechanisms are outside the scope of ERC-7683 itself.

This glossary entry is for informational purposes only and does not constitute financial or investment advice. Always do your own research before using any protocol or technology.