Skip to main content

​
What are Intents?

Intents are the core primitive of the Eco Routes Protocol. An intent represents a complete specification for a cross-chain action, including:
  • What should be executed on the destination chain
  • Where the execution should happen (destination chain)
  • When it must be completed by (deadline)
  • Who gets rewarded for fulfilling it
Intents enable users to express their desired cross-chain outcome without needing to understand the underlying bridge infrastructure or execution mechanics.

​
Intent Structure

The protocol defines intents using a composite struct that combines routing information with reward parameters:
contracts/types/Intent.sol
struct Intent {
    uint64 destination;
    Route route;
    Reward reward;
}

​
Destination

The destination field specifies the target chain ID where the intent should be executed.

​
Route

The route contains all execution instructions for the destination chain:
contracts/types/Intent.sol
struct Route {
    bytes32 salt;
    uint64 deadline;
    address portal;
    uint256 nativeAmount;
    TokenAmount[] tokens;
    Call[] calls;
}
Fields:
  • salt - Unique identifier provided by the intent creator to prevent duplicates
  • deadline - Timestamp by which the route must be executed
  • portal - Address of the portal contract on the destination chain that receives messages
  • nativeAmount - Amount of native tokens to send with route execution
  • tokens - Array of ERC20 tokens required for executing calls on the destination chain
  • calls - Array of contract calls to execute on the destination chain in sequence

​
Reward

The reward defines who can execute the intent and what they receive:
contracts/types/Intent.sol
struct Reward {
    uint64 deadline;
    address creator;
    address prover;
    uint256 nativeAmount;
    TokenAmount[] tokens;
}
Fields:
  • deadline - Timestamp after which the intent can no longer be executed
  • creator - Address that created the intent and has authority to modify/cancel
  • prover - Address of the prover contract that must approve execution
  • nativeAmount - Amount of native tokens offered as reward
  • tokens - Array of ERC20 tokens and amounts offered as additional rewards

​
Supporting Structures

​
Call

Represents a single contract call to be executed:
contracts/types/Intent.sol
struct Call {
    address target;
    bytes data;
    uint256 value;
}
  • target - The contract address to call
  • data - ABI-encoded function call data
  • value - Amount of native tokens to send with the call

​
TokenAmount

Represents a token and amount pair:
contracts/types/Intent.sol
struct TokenAmount {
    address token;
    uint256 amount;
}
  • token - Address of the ERC20 token contract
  • amount - Amount of tokens in the token’s smallest unit

​
Intent Hash

Each intent is uniquely identified by its hash, which is computed from its components: 
intentHash = keccak256(abi.encodePacked(destination, routeHash, rewardHash))
Where:
  • routeHash = keccak256(abi.encode(route))
  • rewardHash = keccak256(abi.encode(reward))
This hash serves as the intent’s unique identifier throughout its lifecycle.
The intent hash is deterministic - the same intent parameters will always produce the same hash, enabling reliable cross-chain verification.

​
Intent Vault

Each intent has an associated vault contract deployed using CREATE2 for deterministic addressing:
contracts/IntentSource.sol
function intentVaultAddress(
    Intent calldata intent
) public view returns (address)
The vault:
  • Holds the reward tokens until the intent is fulfilled
  • Uses the intent hash as the CREATE2 salt for predictable addresses
  • Can be computed before deployment
  • Enables secure, permissionless reward distribution
Vaults are deployed on-demand when needed, but their addresses can be calculated in advance. This allows solvers to verify rewards are available before fulfilling an intent.

Build docs developers (and LLMs) love

Get started for freeTalk to us