HyperProver

Prover implementation using Hyperlane’s cross-chain messaging system

Overview

HyperProver processes proof messages from Hyperlane’s mailbox and records proven intents. It extends MessageBridgeProver to provide Hyperlane-specific messaging functionality.

Contract: contracts/prover/HyperProver.sol

Inheritance: IMessageRecipient, MessageBridgeProver, Semver

Proof Type: "Hyperlane"

Domain ID vs Chain ID: Hyperlane uses domain IDs that may differ from chain IDs. Always consult Hyperlane’s documentation to determine the correct domain ID for your target chain.

Constructor

constructor(
    address mailbox,
    address portal,
    bytes32[] memory provers
)

Initializes the HyperProver contract.

mailbox · address · required

Address of the local Hyperlane mailbox contract

portal · address · required

Address of the Portal contract

provers · bytes32[] · required

Array of trusted prover addresses (as bytes32 for cross-VM compatibility)

Errors:

• MessengerContractCannotBeZeroAddress(): Mailbox address is zero
• ZeroPortal(): Portal address is zero

Location: contracts/prover/HyperProver.sol:55

State Variables

MAILBOX

address public immutable MAILBOX

Address of the local Hyperlane mailbox contract.

PROOF_TYPE

string public constant PROOF_TYPE = "Hyperlane"

Constant indicating this contract uses Hyperlane for proving.

Core Functions

prove

function prove(
    address sender,
    uint64 domainID,
    bytes calldata encodedProofs,
    bytes calldata data
) external payable

Inherited from MessageBridgeProver. Initiates proving process by dispatching a message via Hyperlane.

sender · address · required

Address that initiated the proving request (receives refund if overpaid)

domainID · uint64 · required

Hyperlane domain ID of the source chain (where the intent was created). NOT the chain ID.

encodedProofs · bytes · required

Encoded (intentHash, claimant) pairs. Format: [intentHash1][claimant1][intentHash2][claimant2]...

data · bytes · required

ABI-encoded UnpackedData struct containing:

• sourceChainProver (bytes32): Address of prover on source chain
• metadata (bytes): Metadata for Hyperlane message
• hookAddr (address): Address of post-dispatch hook (zero for default)

Behavior:

1. Calculates required fee via fetchFee
2. Validates msg.value covers fee
3. Dispatches message via Hyperlane mailbox
4. Refunds excess payment to sender

Errors:

• InsufficientFee(uint256 required): msg.value is less than required fee
• DomainIdTooLarge(uint64 domainID): Domain ID exceeds uint32.max

Location: Inherited from MessageBridgeProver.sol:112

handle

function handle(
    uint32 origin,
    bytes32 sender,
    bytes calldata messageBody
) public payable

Handles incoming Hyperlane messages containing proof data. Called by the Hyperlane mailbox.

origin · uint32 · required

Origin domain ID from the source chain. Cannot be zero.

sender · bytes32 · required

Address that dispatched the message on source chain (as bytes32). Cannot be zero.

messageBody · bytes · required

Encoded message with format: [chainId (8 bytes)][intentHash1][claimant1][intentHash2][claimant2]...

Behavior:

1. Validates origin is not zero
2. Validates sender is whitelisted
3. Extracts chain ID from first 8 bytes of messageBody
4. Processes intent proofs using _processIntentProofs

Errors:

• MessageOriginChainDomainIDCannotBeZero(): Origin is zero
• MessageSenderCannotBeZeroAddress(): Sender is zero
• UnauthorizedIncomingProof(bytes32 sender): Sender not whitelisted

Access Control: Only callable by MAILBOX

Location: contracts/prover/HyperProver.sol:71

fetchFee

function fetchFee(
    uint64 domainID,
    bytes calldata encodedProofs,
    bytes calldata data
) public view override returns (uint256)

Calculates the fee required for Hyperlane message dispatch.

domainID · uint64 · required

Hyperlane domain ID of the source chain

encodedProofs · bytes · required

Encoded (intentHash, claimant) pairs

data · bytes · required

ABI-encoded UnpackedData struct

Returns: Fee amount in native tokens required for message dispatch

Location: contracts/prover/HyperProver.sol:130

getProofType

function getProofType() external pure override returns (string memory)

Returns: "Hyperlane"

Internal Functions

_dispatchMessage

function _dispatchMessage(
    uint64 domainID,
    bytes calldata encodedProofs,
    bytes calldata data,
    uint256 fee
) internal override

Implementation of message dispatch for Hyperlane. Called by base prove() function after validations.

Behavior:

1. Unpacks data into structured format
2. Formats Hyperlane message parameters
3. Calls IMailbox(MAILBOX).dispatch with fee

Location: contracts/prover/HyperProver.sol:93

_formatHyperlaneMessage

function _formatHyperlaneMessage(
    uint64 domainID,
    bytes calldata encodedProofs,
    UnpackedData memory unpacked
) internal view returns (DispatchParams memory params)

Formats data for Hyperlane message dispatch.

Returns: DispatchParams struct with:

• destinationDomain (uint32): Hyperlane domain ID
• recipientAddress (bytes32): Source chain prover address
• messageBody (bytes): Encoded proofs
• metadata (bytes): Message metadata
• hook (IPostDispatchHook): Post-dispatch hook (defaults to mailbox’s default hook)

Location: contracts/prover/HyperProver.sol:201

Data Structures

UnpackedData

struct UnpackedData {
    bytes32 sourceChainProver; // Address of prover on source chain
    bytes metadata;            // Metadata for Hyperlane message
    address hookAddr;          // Address of post-dispatch hook
}

Contains fields decoded from the data parameter in prove() and fetchFee().

DispatchParams

struct DispatchParams {
    uint32 destinationDomain;   // Hyperlane domain ID
    bytes32 recipientAddress;   // Recipient address as bytes32
    bytes messageBody;          // Encoded message body
    bytes metadata;             // Additional metadata
    IPostDispatchHook hook;     // Post-dispatch hook contract
}

Consolidates message dispatch parameters to reduce stack usage.

Domain ID Mapping

Hyperlane domain IDs are NOT chain IDs. You must use Hyperlane-specific domain IDs.

Examples:

• Ethereum Mainnet: Domain 1 (Chain ID 1)
• Optimism: Domain 10 (Chain ID 10)
• Arbitrum: Domain 42161 (Chain ID 42161)

Check Hyperlane’s domain registry for the complete mapping.

Usage Example

// On destination chain, prepare proof data
bytes memory data = abi.encode(
    UnpackedData({
        sourceChainProver: bytes32(uint256(uint160(sourceProverAddress))),
        metadata: "",
        hookAddr: address(0) // Use default hook
    })
);

// Calculate fee
uint256 fee = hyperProver.fetchFee(
    hyperlaneSourceDomainId,
    encodedProofs,
    data
);

// Send proof via portal
portal.prove{value: fee}(
    address(hyperProver),
    hyperlaneSourceDomainId,
    encodedProofs,
    data
);