Chainlink CCIP integration

Chainlink CCIP (Cross-Chain Interoperability Protocol) Integration

CCIP is a bridge and messaging protocol from Chainlink, built on their decentralized oracle network. Main positioning: enterprise-grade security with independent Risk Management Network on top of core DON.

Security Architecture

CCIP uses two independent validation layers:

• Primary DON — Chainlink oracle network, transmits and validates messages
• Risk Management Network (ARM) — independent network of nodes monitoring anomalies and can block suspicious messages

Dual protection: even if Primary DON compromised, ARM can stop fraudulent transaction. This design positions CCIP for financial institutions with high security requirements.

Sending Messages and Tokens

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import {IRouterClient} from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IRouterClient.sol";
import {Client} from "@chainlink/contracts-ccip/src/v0.8/ccip/libraries/Client.sol";
import {IERC20} from "@chainlink/contracts-ccip/src/v0.8/vendor/openzeppelin-solidity/v4.8.3/contracts/token/ERC20/IERC20.sol";
import {LinkTokenInterface} from "@chainlink/contracts/src/v0.8/shared/interfaces/LinkTokenInterface.sol";

contract CCIPSender {
    IRouterClient public router;
    LinkTokenInterface public linkToken;
    
    constructor(address _router, address _link) {
        router = IRouterClient(_router);
        linkToken = LinkTokenInterface(_link);
    }
    
    function sendMessage(
        uint64 destinationChainSelector,
        address receiver,
        bytes calldata data,
        address tokenAddress,
        uint256 tokenAmount
    ) external returns (bytes32 messageId) {
        
        Client.EVMTokenAmount[] memory tokenAmounts = new Client.EVMTokenAmount[](1);
        tokenAmounts[0] = Client.EVMTokenAmount({
            token: tokenAddress,
            amount: tokenAmount,
        });
        
        Client.EVM2AnyMessage memory message = Client.EVM2AnyMessage({
            receiver: abi.encode(receiver),
            data: data,
            tokenAmounts: tokenAmounts,
            extraArgs: Client._argsToBytes(
                Client.EVMExtraArgsV1({ gasLimit: 200_000 })
            ),
            feeToken: address(linkToken),
        });
        
        uint256 fee = router.getFee(destinationChainSelector, message);
        linkToken.approve(address(router), fee);
        
        IERC20(tokenAddress).approve(address(router), tokenAmount);
        
        messageId = router.ccipSend(destinationChainSelector, message);
        
        emit MessageSent(messageId, destinationChainSelector, receiver, fee);
    }
}

Receiving Messages

import {CCIPReceiver} from "@chainlink/contracts-ccip/src/v0.8/ccip/applications/CCIPReceiver.sol";

contract CCIPReceiver is CCIPReceiver {
    mapping(uint64 => address) public allowedSenders;
    
    constructor(address router) CCIPReceiver(router) {}
    
    function _ccipReceive(
        Client.Any2EVMMessage memory message
    ) internal override {
        address sender = abi.decode(message.sender, (address));
        
        require(
            allowedSenders[message.sourceChainSelector] == sender,
            "Unknown sender"
        );
        
        for (uint i = 0; i < message.destTokenAmounts.length; i++) {
            address token = message.destTokenAmounts[i].token;
            uint256 amount = message.destTokenAmounts[i].amount;
        }
        
        (address recipient, uint256 action) = abi.decode(
            message.data,
            (address, uint256)
        );
        
        _executeAction(recipient, action, message.destTokenAmounts);
    }
}

Chain Selectors

Pay with Native Token Instead of LINK

Client.EVM2AnyMessage memory message = Client.EVM2AnyMessage({
    receiver: abi.encode(receiver),
    data: data,
    tokenAmounts: tokenAmounts,
    extraArgs: Client._argsToBytes(Client.EVMExtraArgsV1({ gasLimit: 200_000 })),
    feeToken: address(0), // native token
});

uint256 fee = router.getFee(destinationChainSelector, message);
messageId = router.ccipSend{value: fee}(destinationChainSelector, message);

CCIP is good for: enterprise projects with security audit requirements; DeFi protocols with large TVL where Chainlink reputation matters; when already using Chainlink Price Feeds — CCIP integrates well.

CCIP integration — 2-3 weeks. Official documentation and examples high quality, Chainlink supports enterprise clients.