Proving Intents

// From Inbox.sol
uint64 sourceChainDomainID = getSourceDomainId(sourceChainId);
bytes memory proverData = encodeProverData(bridgeFee);

bytes[] memory results = portal.fulfillAndProve{value: totalValue}(
    intentHash,
    route,
    rewardHash,
    claimant,
    proverAddress,        // Prover on destination chain
    sourceChainDomainID,  // Bridge domain ID for source
    proverData            // Bridge-specific parameters
);

// Step 1: Fulfill the intent
portal.fulfill(intentHash, route, rewardHash, claimant);

// Step 2: Batch prove multiple intents
bytes32[] memory intentHashes = new bytes32[](3);
intentHashes[0] = intentHash1;
intentHashes[1] = intentHash2;
intentHashes[2] = intentHash3;

portal.prove{value: bridgeFee}(
    proverAddress,
    sourceChainDomainID,
    intentHashes,
    proverData
);

pragma solidity ^0.8.26;

import {IInbox} from "./interfaces/IInbox.sol";
import {IIntentSource} from "./interfaces/IIntentSource.sol";
import {Route, Reward, TokenAmount} from "./types/Intent.sol";
import {IMailbox} from "@hyperlane-xyz/core/contracts/interfaces/IMailbox.sol";

contract HyperlaneSolver {
    IInbox public destinationPortal;
    IIntentSource public sourcePortal;
    IMailbox public mailbox;

    address public hyperProver;
    uint64 public sourceDomain;  // Hyperlane domain for source chain

    constructor(
        address _destinationPortal,
        address _sourcePortal,
        address _mailbox,
        address _hyperProver,
        uint64 _sourceDomain
    ) {
        destinationPortal = IInbox(_destinationPortal);
        sourcePortal = IIntentSource(_sourcePortal);
        mailbox = IMailbox(_mailbox);
        hyperProver = _hyperProver;
        sourceDomain = _sourceDomain;
    }

    /**
     * @notice Fulfill and prove an intent in one transaction
     */
    function fulfillAndProveIntent(
        bytes32 intentHash,
        Route calldata route,
        bytes32 rewardHash
    ) external payable {
        // 1. Approve tokens
        for (uint256 i = 0; i < route.tokens.length; i++) {
            IERC20(route.tokens[i].token).approve(
                address(destinationPortal),
                route.tokens[i].amount
            );
        }

        // 2. Estimate Hyperlane message fee
        bytes32 claimant = bytes32(uint256(uint160(address(this))));
        bytes memory proofData = encodeProofData(
            uint64(block.chainid),
            intentHash,
            claimant
        );

        uint256 messageFee = mailbox.quoteDispatch(
            sourceDomain,
            addressToBytes32(hyperProver),
            proofData
        );

        // 3. Calculate total value needed
        uint256 totalValue = route.nativeAmount + messageFee;
        require(msg.value >= totalValue, "Insufficient value");

        // 4. Fulfill and prove
        destinationPortal.fulfillAndProve{value: totalValue}(
            intentHash,
            route,
            rewardHash,
            claimant,
            hyperProver,
            sourceDomain,
            ""  // No extra data for Hyperlane
        );
    }

    /**
     * @notice Withdraw rewards after proof is delivered
     */
    function withdrawRewards(
        uint64 destination,
        Route calldata route,
        Reward calldata reward
    ) external {
        bytes32 routeHash = keccak256(abi.encode(route));

        // This will transfer rewards to address(this)
        sourcePortal.withdraw(destination, routeHash, reward);

        // Transfer to owner or keep in contract
    }

    /**
     * @notice Helper to encode proof data
     */
    function encodeProofData(
        uint64 chainId,
        bytes32 intentHash,
        bytes32 claimant
    ) internal pure returns (bytes memory) {
        bytes memory data = new bytes(8 + 64);

        // Pack chain ID (8 bytes) + intent hash (32 bytes) + claimant (32 bytes)
        assembly {
            mstore(add(data, 0x20), shl(192, chainId))
            mstore(add(data, 0x28), intentHash)
            mstore(add(data, 0x48), claimant)
        }

        return data;
    }

    /**
     * @notice Helper to convert address to bytes32
     */
    function addressToBytes32(address addr) internal pure returns (bytes32) {
        return bytes32(uint256(uint160(addr)));
    }

    receive() external payable {}
}

// Fulfill intents individually
for (uint256 i = 0; i < intents.length; i++) {
    portal.fulfill(
        intentHashes[i],
        routes[i],
        rewardHashes[i],
        claimant
    );
}

// Batch prove all at once
portal.prove{value: totalBridgeFee}(
    proverAddress,
    sourceChainDomainID,
    intentHashes,  // Array of all intent hashes
    proverData
);

uint64[] memory destinations = new uint64[](3);
bytes32[] memory routeHashes = new bytes32[](3);
Reward[] memory rewards = new Reward[](3);

// Populate arrays...
destinations[0] = 42161;  // Arbitrum
destinations[1] = 10;      // Optimism
destinations[2] = 8453;    // Base

// ... set routeHashes and rewards ...

// Withdraw all at once
intentSource.batchWithdraw(destinations, routeHashes, rewards);

import {IProver} from "./interfaces/IProver.sol";

// Check proof status
IProver.ProofData memory proof = IProver(proverAddress).provenIntents(intentHash);

if (proof.claimant != bytes32(0)) {
    // Proof exists
    console.log("Intent proven on chain:", proof.destination);
    console.log("Claimant:", proof.claimant);

    // Safe to withdraw
    withdraw(destination, routeHash, reward);
} else {
    // Proof not yet delivered
    console.log("Waiting for proof...");
}

// Check if proof was sent
emit IntentProven(intentHash, claimant);

// Check bridge status
// For Hyperlane: Check mailbox message status
// For LayerZero: Check endpoint message status

// Verify domain ID is correct
assert(sourceDomainID == expectedDomain);

// Common issues:

// 1. Proof doesn't exist yet
require(proof.claimant != bytes32(0), "No proof");

// 2. Wrong destination
require(proof.destination == destination, "Wrong chain");

// 3. Already withdrawn
require(status != Status.Withdrawn, "Already withdrawn");