CCIPProver
├── ROUTER (CCIP Router address)
├── MIN_GAS_LIMIT (minimum execution gas)
└── Whitelist (authorized provers)

constructor(
    address router,        // CCIP Router for this chain
    address portal,        // Portal contract address
    bytes32[] memory provers,  // Whitelisted prover addresses
    uint256 minGasLimit    // Minimum gas for execution (0 = 200k default)
)

struct UnpackedData {
    address sourceChainProver;  // Prover address on source chain
    uint256 gasLimit;           // Gas limit for execution
}

bytes memory data = abi.encode(sourceChainProver, gasLimit);

// Query fee before sending
uint256 fee = ccipProver.fetchFee(
    destinationChainSelector,
    encodedProofs,
    data
);

// Include 10% buffer for gas price fluctuations
uint256 feeWithBuffer = fee * 110 / 100;

// Send proof with payment
ccipProver.prove{value: feeWithBuffer}(
    intentHash,
    destinationChainSelector,
    encodedProofs,
    data
);

// Deploy CCIPProver on destination chain
address ccipRouter = 0x80226fc0Ee2b096224EeAc085Bb9a8cba1146f7D; // Ethereum Router
address portal = 0x...; // Portal on this chain

// Whitelist the source chain prover
bytes32[] memory provers = new bytes32[](1);
provers[0] = bytes32(uint256(uint160(0x...))); // Source chain CCIPProver

CCIPProver prover = new CCIPProver(
    ccipRouter,
    portal,
    provers,
    300000 // 300k minimum gas
);

// Deploy matching CCIPProver on source chain with reciprocal whitelist

contract MySolver {
    CCIPProver public ccipProver;
    Portal public portal;
    
    function fulfillAndProve(
        Intent memory intent,
        uint64 sourceChainSelector
    ) external payable {
        // 1. Fulfill intent on destination chain
        portal.fulfill(intent.hash, intent.route, intent.rewardHash, msg.sender);
        
        // 2. Prepare proof data
        bytes32[] memory intentHashes = new bytes32[](1);
        intentHashes[0] = intent.hash;
        
        bytes32[] memory claimants = new bytes32[](1);
        claimants[0] = bytes32(uint256(uint160(msg.sender)));
        
        bytes memory encodedProofs = abi.encode(intentHashes, claimants);
        
        // 3. Calculate CCIP fee
        address sourceProver = ccipProver.getWhitelistedProver(sourceChainSelector);
        bytes memory data = abi.encode(sourceProver, 500000); // 500k gas
        
        uint256 fee = ccipProver.fetchFee(sourceChainSelector, encodedProofs, data);
        uint256 feeWithBuffer = fee * 110 / 100; // 10% buffer
        
        // 4. Send proof via CCIP
        ccipProver.prove{value: feeWithBuffer}(
            intent.hash,
            sourceChainSelector,
            encodedProofs,
            data
        );
        
        // 5. Refund excess fee
        if (msg.value > feeWithBuffer) {
            payable(msg.sender).transfer(msg.value - feeWithBuffer);
        }
    }
}