Cctp Bridging

library CCTPDomains {
    uint32 internal constant ETHEREUM = 0;
    uint32 internal constant AVALANCHE = 1;
    uint32 internal constant OPTIMISM = 2;
    uint32 internal constant ARBITRUM = 3;
    uint32 internal constant NOBLE = 4;
    uint32 internal constant SOLANA = 5;
    uint32 internal constant BASE = 6;
    uint32 internal constant POLYGON = 7;
    uint32 internal constant SUI = 8;
    uint32 internal constant UNICHAIN = 10;
}

interface ITokenMessenger {
    /// @notice Deposits and burns tokens for a cross-chain transfer
    /// @param amount Amount of tokens to burn (6 decimals for USDC)
    /// @param destinationDomain CCTP domain ID of the destination chain
    /// @param mintRecipient Address on destination chain (left-padded bytes32)
    /// @param burnToken Address of the token to burn on the source chain
    /// @return nonce Unique nonce for this message
    function depositForBurn(
        uint256 amount,
        uint32 destinationDomain,
        bytes32 mintRecipient,
        address burnToken
    ) external returns (uint64 nonce);

    /// @notice Deposits and burns tokens with a caller restriction on the destination
    /// @dev Only `destinationCaller` can call receiveMessage for this transfer
    /// @param amount Amount of tokens to burn
    /// @param destinationDomain CCTP domain ID of the destination chain
    /// @param mintRecipient Address on destination chain (left-padded bytes32)
    /// @param burnToken Address of the token to burn
    /// @param destinationCaller Address permitted to relay on destination (bytes32)
    /// @return nonce Unique nonce for this message
    function depositForBurnWithCaller(
        uint256 amount,
        uint32 destinationDomain,
        bytes32 mintRecipient,
        address burnToken,
        bytes32 destinationCaller
    ) external returns (uint64 nonce);
}

interface IMessageTransmitter {
    /// @notice Receives a message and triggers mint on the destination chain
    /// @param message Raw message bytes from the source chain burn event
    /// @param attestation Circle attestation service signature over the message
    /// @return success Whether the message was successfully received
    function receiveMessage(
        bytes calldata message,
        bytes calldata attestation
    ) external returns (bool success);

    /// @notice Receives a message that can only be relayed by a specific caller
    /// @dev Used with depositForBurnWithCaller for restricted relay
    function receiveMessageWithCaller(
        bytes calldata message,
        bytes calldata attestation
    ) external returns (bool success);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

interface ITokenMessenger {
    function depositForBurn(
        uint256 amount,
        uint32 destinationDomain,
        bytes32 mintRecipient,
        address burnToken
    ) external returns (uint64 nonce);

    function depositForBurnWithCaller(
        uint256 amount,
        uint32 destinationDomain,
        bytes32 mintRecipient,
        address burnToken,
        bytes32 destinationCaller
    ) external returns (uint64 nonce);
}

/// @title CCTPSender
/// @notice Sends USDC cross-chain via Circle's CCTP V2
/// @dev Wraps TokenMessenger with SafeERC20 and address encoding
contract CCTPSender {
    using SafeERC20 for IERC20;

    ITokenMessenger public immutable TOKEN_MESSENGER;
    IERC20 public immutable USDC;

    error ZeroAmount();
    error ZeroAddress();

    event CCTPBurnInitiated(
        uint64 indexed nonce,
        uint32 indexed destinationDomain,
        address indexed recipient,
        uint256 amount
    );

    constructor(address tokenMessenger_, address usdc_) {
        if (tokenMessenger_ == address(0) || usdc_ == address(0)) revert ZeroAddress();
        TOKEN_MESSENGER = ITokenMessenger(tokenMessenger_);
        USDC = IERC20(usdc_);
    }

    /// @notice Burns USDC on this chain and triggers a mint on the destination chain
    /// @param amount Amount of USDC to send (6 decimals)
    /// @param destinationDomain CCTP domain ID of the target chain
    /// @param recipient EVM address that will receive USDC on the destination chain
    /// @return nonce The message nonce for tracking attestation status
    function sendUSDC(
        uint256 amount,
        uint32 destinationDomain,
        address recipient
    ) external returns (uint64 nonce) {
        if (amount == 0) revert ZeroAmount();
        if (recipient == address(0)) revert ZeroAddress();

        USDC.safeTransferFrom(msg.sender, address(this), amount);
        USDC.forceApprove(address(TOKEN_MESSENGER), amount);

        bytes32 mintRecipient = _addressToBytes32(recipient);

        nonce = TOKEN_MESSENGER.depositForBurn(
            amount,
            destinationDomain,
            mintRecipient,
            address(USDC)
        );

        emit CCTPBurnInitiated(nonce, destinationDomain, recipient, amount);
    }

    /// @notice Burns USDC with a restricted relayer on the destination chain
    /// @dev Only `destinationCaller` can complete the transfer on the other side
    /// @param amount Amount of USDC to send (6 decimals)
    /// @param destinationDomain CCTP domain ID of the target chain
    /// @param recipient EVM address that will receive USDC on the destination chain
    /// @param destinationCaller Address allowed to call receiveMessage on destination
    /// @return nonce The message nonce for tracking attestation status
    function sendUSDCWithCaller(
        uint256 amount,
        uint32 destinationDomain,
        address recipient,
        address destinationCaller
    ) external returns (uint64 nonce) {
        if (amount == 0) revert ZeroAmount();
        if (recipient == address(0) || destinationCaller == address(0)) revert ZeroAddress();

        USDC.safeTransferFrom(msg.sender, address(this), amount);
        USDC.forceApprove(address(TOKEN_MESSENGER), amount);

        nonce = TOKEN_MESSENGER.depositForBurnWithCaller(
            amount,
            destinationDomain,
            _addressToBytes32(recipient),
            address(USDC),
            _addressToBytes32(destinationCaller)
        );

        emit CCTPBurnInitiated(nonce, destinationDomain, recipient, amount);
    }

    /// @dev Converts an EVM address to a left-padded bytes32 for CCTP
    function _addressToBytes32(address addr) internal pure returns (bytes32) {
        return bytes32(uint256(uint160(addr)));
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

interface IMessageTransmitter {
    function receiveMessage(
        bytes calldata message,
        bytes calldata attestation
    ) external returns (bool success);
}

/// @title CCTPReceiver
/// @notice Relays attested CCTP messages to complete cross-chain USDC transfers
contract CCTPReceiver {
    IMessageTransmitter public immutable MESSAGE_TRANSMITTER;

    error ReceiveFailed();

    event CCTPMessageRelayed(bytes32 indexed messageHash);

    constructor(address messageTransmitter_) {
        MESSAGE_TRANSMITTER = IMessageTransmitter(messageTransmitter_);
    }

    /// @notice Relays an attested CCTP message to mint USDC to the original recipient
    /// @param message Raw message bytes emitted during the source chain burn
    /// @param attestation Signed attestation from Circle's attestation service
    function relay(bytes calldata message, bytes calldata attestation) external {
        bool success = MESSAGE_TRANSMITTER.receiveMessage(message, attestation);
        if (!success) revert ReceiveFailed();

        emit CCTPMessageRelayed(keccak256(message));
    }
}

Mainnet:  https://iris-api-v2.circle.com/v2/attestations/{messageHash}
Testnet:  https://iris-api-v2-sandbox.circle.com/v2/attestations/{messageHash}

event MessageSent(bytes message);

// To compute the hash offchain:
// messageHash = keccak256(message)

async function waitForAttestation(messageHash: string): Promise<string> {
  const endpoint = `https://iris-api-v2.circle.com/v2/attestations/${messageHash}`;

  while (true) {
    const res = await fetch(endpoint);
    const data = await res.json();

    if (data.status === "complete") {
      return data.attestation;
    }

    // Poll every 5 seconds; fast finality transfers resolve in ~10-20s
    await new Promise((r) => setTimeout(r, 5_000));
  }
}

{
  "attestation": "0x...",
  "status": "complete"
}

┌──────────────┐     ┌───────────────┐     ┌─────────────────┐
│ 1. Deposit   │────▶│ 2. Burn       │────▶│ 3. Mint         │
│ USDC to      │     │ Intent        │     │ on destination   │
│ Gateway      │     │ (EIP-712 sig) │     │ via Gateway API  │
│ Wallet       │     │               │     │                  │
└──────────────┘     └───────────────┘     └─────────────────┘

/// @notice Deposits USDC into the Gateway Wallet to fund the unified balance
/// @dev Simply transfers USDC to the well-known Gateway Wallet address
/// @param amount Amount of USDC to deposit (6 decimals)
function depositToGateway(uint256 amount) external {
    USDC.safeTransferFrom(msg.sender, GATEWAY_WALLET, amount);
    emit GatewayDeposit(msg.sender, amount);
}

bytes32 constant BURN_INTENT_TYPEHASH = keccak256(
    "BurnIntent(uint32 sourceDomain,uint32 destinationDomain,address recipient,uint256 amount,uint256 nonce,uint256 deadline)"
);

struct BurnIntent {
    uint32 sourceDomain;
    uint32 destinationDomain;
    address recipient;
    uint256 amount;
    uint256 nonce;
    uint256 deadline;
}

interface ITokenMessengerV2 {
    /// @notice Burns tokens and sends a message with a hook to execute on destination
    /// @param amount Amount to burn
    /// @param destinationDomain Destination CCTP domain
    /// @param mintRecipient Recipient on destination
    /// @param burnToken Token to burn
    /// @param destinationCaller Restricted relayer (bytes32(0) for any)
    /// @param maxFee Maximum fee for fast transfer (set 0 for standard)
    /// @param hookData Calldata to execute on the destination after mint
    /// @return nonce Message nonce
    function depositForBurnWithHook(
        uint256 amount,
        uint32 destinationDomain,
        bytes32 mintRecipient,
        address burnToken,
        bytes32 destinationCaller,
        uint256 maxFee,
        bytes calldata hookData
    ) external returns (uint64 nonce);
}

// Encode a vault deposit call as hook data
bytes memory hookData = abi.encodeWithSelector(
    IVault.deposit.selector,
    amount,
    recipient
);

// USDC is minted to mintRecipient, then hookData is executed
// mintRecipient should be a contract that approves the vault and calls deposit
tokenMessenger.depositForBurnWithHook(
    amount,
    CCTPDomains.BASE,
    _addressToBytes32(hookReceiver),
    address(usdc),
    bytes32(0),
    0,
    hookData
);

import { BridgeKit } from "@circle-fin/bridge-kit";

const kit = new BridgeKit({ apiKey: process.env.CIRCLE_API_KEY });

const transfer = await kit.bridge({
  sourceChain: "ethereum",
  destinationChain: "base",
  amount: "1000000", // 1 USDC (6 decimals)
  recipient: "0x...",
});

// kit.bridge() handles: approve → burn → poll attestation → receiveMessage
console.log(`Transfer complete: ${transfer.destinationTxHash}`);

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface ITokenMessenger {
    function depositForBurn(
        uint256 amount,
        uint32 destinationDomain,
        bytes32 mintRecipient,
        address burnToken
    ) external returns (uint64 nonce);
}

contract CCTPForkTest is Test {
    ITokenMessenger constant MESSENGER =
        ITokenMessenger(0xBd3fa81B58Ba92a82136038B25aDec7066af3155);
    IERC20 constant USDC =
        IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);

    address sender = makeAddr("sender");

    function setUp() public {
        vm.createSelectFork("mainnet");
        deal(address(USDC), sender, 1000e6);
    }

    function test_depositForBurn_toBase() public {
        vm.startPrank(sender);

        USDC.approve(address(MESSENGER), 100e6);
        bytes32 recipient = bytes32(uint256(uint160(sender)));

        uint64 nonce = MESSENGER.depositForBurn(
            100e6,
            6, // Base domain
            recipient,
            address(USDC)
        );

        assertGt(nonce, 0, "nonce should be non-zero");
        assertEq(USDC.balanceOf(sender), 900e6, "100 USDC should be burned");

        vm.stopPrank();
    }

    function test_depositForBurn_revertsOnZeroAmount() public {
        vm.startPrank(sender);
        USDC.approve(address(MESSENGER), 0);

        vm.expectRevert();
        MESSENGER.depositForBurn(
            0,
            6,
            bytes32(uint256(uint160(sender))),
            address(USDC)
        );
        vm.stopPrank();
    }

    function test_depositForBurn_revertsWithoutApproval() public {
        vm.prank(sender);
        vm.expectRevert();
        MESSENGER.depositForBurn(
            100e6,
            6,
            bytes32(uint256(uint160(sender))),
            address(USDC)
        );
    }
}

contract CCTPSenderTest is Test {
    CCTPSender sender;
    address mockMessenger;
    address mockUSDC;

    function setUp() public {
        mockMessenger = makeAddr("messenger");
        mockUSDC = makeAddr("usdc");
        sender = new CCTPSender(mockMessenger, mockUSDC);
    }

    function test_constructor_setsImmutables() public view {
        assertEq(address(sender.TOKEN_MESSENGER()), mockMessenger);
        assertEq(address(sender.USDC()), mockUSDC);
    }

    function test_sendUSDC_revertsOnZeroAmount() public {
        vm.expectRevert(CCTPSender.ZeroAmount.selector);
        sender.sendUSDC(0, 6, makeAddr("recipient"));
    }

    function test_sendUSDC_revertsOnZeroRecipient() public {
        vm.expectRevert(CCTPSender.ZeroAddress.selector);
        sender.sendUSDC(100e6, 6, address(0));
    }
}