StandaloneIntentExecutor

Executor contract for standalone multi-chain intent execution without external protocols

Overview

The StandaloneIntentExecutor enables self-contained intent execution without dependencies on external protocols like Compact or Permit2.

Source: /src/executor/StandaloneIntent/StandaloneIntent.sol:50

Key Features

• Chain-Agnostic Signatures: Multi-chain operations with signatures valid across networks
• Direct Nonce Management: Account-level replay protection without external protocols
• Gas Refund Support: Optional ERC20 or native ETH relayer compensation
• Session Key Support: Integration with emissary-based validation for delegation
• Single and Multi-Chain: Optimized execution paths for both use cases

Execution Modes

Multi-Chain Operations:

• Chain-agnostic signatures work across different networks
• Coordinated execution with operation hashes from other chains

Single-Chain Operations:

• Chain-specific signatures (more gas efficient)
• Simplified execution for operations on one chain

Gas Refund Variants:

• No refund: Simple execution without relayer compensation
• ERC20 refund: Pay relayer in any ERC20 token with configurable exchange rate
• ETH refund: Optimized native ETH compensation (1:1 rate)

Structs

MultiChainOps

Multi-chain operations structure for standalone intent execution.

struct MultiChainOps {
    address account;
    uint256 chainIndex;
    bytes32[] otherChains;
    uint256 nonce;
    Types.Operation ops;
    bytes signature;
}

account · address

The account address that owns and signed these operations

chainIndex · uint256

Index position of current chain in the otherChains array

otherChains · bytes32[]

Array of operation hashes from other chains in the multi-chain intent

nonce · uint256

Nonce for replay protection

ops · Types.Operation

Operations to execute on the current chain

signature · bytes

EIP-712 signature from the account authorizing all operations

SingleChainOps

Single-chain operations structure for standalone intent execution.

struct SingleChainOps {
    address account;
    uint256 nonce;
    Types.Operation ops;
    bytes signature;
}

account · address

The account address that owns and signed these operations

nonce · uint256

Nonce for replay protection

ops · Types.Operation

Operations to execute on the current chain

signature · bytes

EIP-712 signature from the account authorizing the operations

SingleChainOps is ~850 gas cheaper than MultiChainOps due to simpler structure and standard EIP-712 hashing with chain ID.

GasRefund

Gas refund parameters for ERC20 token relayer compensation.

struct GasRefund {
    address token;
    uint256 exchangeRate;
    uint256 overhead;
}

token · address

ERC20 token address for gas refund (must not be Constants.NATIVE_TOKEN)

exchangeRate · uint256

Exchange rate: how many token units equal 1 ETH (scaled to 1e18)

overhead · uint256

Fixed gas overhead to add to the gas calculation (gas units)

For ERC20 refunds, the token address must NOT be Constants.NATIVE_TOKEN. Use the ETH refund functions for native token compensation.

Functions

executeMultichainOps

function executeMultichainOps(MultiChainOps calldata signedOps) external

Executes a batch of multi-chain operations after verifying signature and nonce, without gas refund.

signedOps · MultiChainOps · required

The MultiChainOps struct containing account, operations, nonce, and signature

Uses chain-agnostic EIP-712 signature validation (excludes chain ID from digest), allowing the same signature to be valid across different chains.

executeMultichainOpsWithGasRefund_ERC20

function executeMultichainOpsWithGasRefund_ERC20(
    MultiChainOps calldata signedOps,
    GasRefund calldata gasRefund,
    address gasRefundRecipient
) external returns (address account, uint256 nonce)

Executes multi-chain operations with ERC20 token gas refund for relayer compensation.

signedOps · MultiChainOps · required

The complete multi-chain operations structure with signature

gasRefund · GasRefund · required

The gas refund terms (ERC20 token, exchange rate, and overhead)

gasRefundRecipient · address · required

Address that will receive the gas refund payment (typically relayer)

Returns:

• account (address): The account address that executed the operations
• nonce (uint256): The nonce that was consumed during execution

Session key modes (EMISSARY_EXECUTION) require the account to call Paymaster.callbackAllowMaxAmount during execution to cap the refund amount and prevent exchange rate manipulation.

executeMultichainOpsWithGasRefund_ETH

function executeMultichainOpsWithGasRefund_ETH(
    MultiChainOps calldata signedOps,
    uint256 overhead,
    address gasRefundRecipient
) external returns (address account, uint256 nonce)

Executes multi-chain operations with native ETH gas refund for relayer compensation.

signedOps · MultiChainOps · required

The complete multi-chain operations structure with signature

overhead · uint256 · required

The fixed gas overhead to add to the refund calculation (gas units)

gasRefundRecipient · address · required

Address that will receive the gas refund payment (typically relayer)

Returns:

• account (address): The account address that executed the operations
• nonce (uint256): The nonce that was consumed during execution

Owner signature modes save ~17-22k gas vs ERC20 variant by skipping the Paymaster intermediary and using direct ETH transfer. Exchange rate is hardcoded to 1:1.

executeSinglechainOps

function executeSinglechainOps(SingleChainOps calldata signedOps) external

Executes a single-chain intent after signature validation without gas refund.

signedOps · SingleChainOps · required

The complete single-chain operations structure with signature

Uses standard chain-specific EIP-712 signature validation (includes chain ID), making signatures NOT valid across different chains but ~850 gas cheaper than multi-chain variant.

executeSinglechainOpsWithGasRefund_ERC20

function executeSinglechainOpsWithGasRefund_ERC20(
    SingleChainOps calldata signedOps,
    GasRefund calldata gasRefund,
    address gasRefundRecipient
) external returns (address account, uint256 nonce)

Executes single-chain operations with ERC20 token gas refund for relayer compensation.

signedOps · SingleChainOps · required

The complete single-chain operations structure with signature

gasRefund · GasRefund · required

The gas refund terms (ERC20 token, exchange rate, and overhead)

gasRefundRecipient · address · required

Address that will receive the gas refund payment (typically relayer)

Returns:

• account (address): The account address that executed the operations
• nonce (uint256): The nonce that was consumed during execution

executeSinglechainOpsWithGasRefund_ETH

function executeSinglechainOpsWithGasRefund_ETH(
    SingleChainOps calldata signedOps,
    uint256 overhead,
    address gasRefundRecipient
) external returns (address account, uint256 nonce)

Executes single-chain operations with native ETH gas refund for relayer compensation.

signedOps · SingleChainOps · required

The complete single-chain operations structure with signature

overhead · uint256 · required

The fixed gas overhead to add to the refund calculation (gas units)

gasRefundRecipient · address · required

Address that will receive the gas refund payment (typically relayer)

Returns:

• account (address): The account address that executed the operations
• nonce (uint256): The nonce that was consumed during execution

isStandaloneIntentNonceConsumed

function isStandaloneIntentNonceConsumed(
    uint256 nonce,
    address account
) external view returns (bool used)

Checks if a nonce has been used for a specific account.

nonce · uint256 · required

The nonce value to check

account · address · required

The account address that owns the nonce

Returns: bool - True if the nonce has been consumed, false otherwise

getCostInToken

function getCostInToken(
    uint256 _actualGasCost,
    uint256 _actualOpFeePerGas,
    uint256 _exchangeRate,
    uint256 _overhead
) public pure returns (uint256)

Converts gas costs from wei to token amount using an exchange rate.

_actualGasCost · uint256 · required

The total wei spent on execution (gasUsed × tx.gasprice)

_actualOpFeePerGas · uint256 · required

The current gas price in wei (tx.gasprice)

_exchangeRate · uint256 · required

How many token units (in token decimals) equal 1 ETH (1e18 wei)

_overhead · uint256 · required

The fixed gas overhead to add (gas units not captured by gasleft measurement)

Returns: uint256 - The gas cost denominated in tokens

Formula: ((actualGasCost + (overhead × gasPrice)) × exchangeRate) / 1e18

Gas Refund Mechanism

Settlement Methods

The contract uses different settlement methods based on signature mode:

Owner Signature Modes (EMISSARY, ERC1271, EMISSARY_ERC1271, ERC1271_EMISSARY):

• ERC20: Via Paymaster.settleGasRefund
• ETH: Direct transfer via executeSingleETHTransfer (~17-22k gas savings)
• Trusted exchange rate from account owner

Session Key Modes (EMISSARY_EXECUTION, EMISSARYEXECUTION_ERC1271, ERC1271_EMISSARYEXECUTION):

• ERC20: Via Paymaster.settleGasRefund_requireCallback
• ETH: Via Paymaster.settleGasRefund_requireCallback
• Requires callback protection to prevent exchange rate/overhead manipulation

Session Key Security

Session key modes require the account to call Paymaster.callbackAllowMaxAmount during execution to authorize the maximum refund amount. This prevents session keys from draining funds through inflated exchange rates or overhead values.

Gas Overhead

The contract accounts for ~55,000 gas overhead not captured by gasleft() measurement:

• Function dispatch and calldata decoding
• EIP-712 hashing for gas refund commitment
• Reentrancy guard operations (TSTORE/TLOAD)
• Settlement call overhead

Example Usage

// Execute multi-chain ops without gas refund
intentExecutor.executeMultichainOps(
    MultiChainOps({
        account: accountAddress,
        chainIndex: 0,
        otherChains: [chain1Hash, chain2Hash],
        nonce: 1,
        ops: operations,
        signature: userSignature
    })
);

// Execute with ERC20 gas refund
(address account, uint256 nonce) = intentExecutor.executeMultichainOpsWithGasRefund_ERC20(
    signedOps,
    GasRefund({
        token: usdcAddress,
        exchangeRate: 2000e6, // 1 ETH = 2000 USDC
        overhead: 100000 // additional 100k gas
    }),
    relayerAddress
);

// Execute single-chain with ETH refund (gas optimized)
(address account, uint256 nonce) = intentExecutor.executeSinglechainOpsWithGasRefund_ETH(
    signedOps,
    50000, // 50k gas overhead
    relayerAddress
);

Events

IntentExecuted · event

event IntentExecuted(address account, uint256 nonce)

Emitted when an intent is successfully executed.

Error Handling

InvalidSignature · error

Thrown when signature validation fails

InvalidGasToken · error

Thrown when Constants.NATIVE_TOKEN is used with ERC20 refund functions

EIP-712 Domain

The contract uses the following EIP-712 domain:

• Name: “IntentExecutor”
• Version: “v0.0.1”

Comparison: Multi-Chain vs Single-Chain

Feature	Multi-Chain	Single-Chain
Chain ID in signature	No (chain-agnostic)	Yes (chain-specific)
Cross-chain validity	Yes	No
Gas cost	Higher (~850 gas more)	Lower (optimized)
Use case	Coordinated multi-chain	Single chain only
Struct complexity	More complex	Simpler

Security Considerations

Chain-Agnostic Signatures: Multi-chain operations use signatures without chain ID in the digest, allowing the same signature across chains. Ensure operations are designed for this cross-chain validity.

Nonce Consumption: Nonces are consumed before signature validation (CEI pattern) to prevent partial state changes on validation failure.

Gas Refund Commitment: Gas refund parameters are included in the EIP-712 signature to prevent relayers from modifying refund terms after signing.

For single-chain operations, prefer executeSinglechainOps variants for better gas efficiency (~3.4% cheaper).

Related

• IntentExecutor - Main executor contract
• CompactIntentExecutor - Compact protocol execution
• Permit2IntentExecutor - Permit2-based execution