mdm.icu Open in urlscan Pro
104.243.33.214  Public Scan

Form analysis
1 forms found in the DOM

Name: wf-form-wf-form-Chainlink-Newsletter-Primary — GET

<form id="wf-form-wf-form-Chainlink-Newsletter-Primary" name="wf-form-wf-form-Chainlink-Newsletter-Primary" data-name="wf-form-Chainlink-Newsletter-Primary" method="get" class="form-subscribe" data-wf-page-id="610b85aebc98ff0180b9877d"
  data-wf-element-id="0db08303-5efe-91bf-16a0-f63a015005d5" aria-label="wf-form-Chainlink-Newsletter-Primary" data-hs-cf-bound="true">
  <div class="form-subscribe-field-wrapper"><label for="Email" class="field-label-hidden">Email Address</label><input class="cta-subscribe-input w-input" maxlength="256" name="Email" data-name="Email" placeholder="Enter your email address"
      type="email" id="Email" required=""><input type="submit" data-wait="Please wait..." class="btn btn-secondary w-button" value="Subscribe now"></div><label id="checkbox" class="w-checkbox newsletter-consent-checkbox-wrapper">
    <div class="w-checkbox-input w-checkbox-input--inputType-custom newsletter-consent-checkbox"></div><input type="checkbox" data-name="Consent Checkbox" name="Consent-Checkbox" id="Consent-Checkbox" required=""
      style="opacity:0;position:absolute;z-index:-1"><span class="newsletter-consent-label w-form-label" for="Consent-Checkbox">Yes, I agree to receive email communications from Chainlink.</span>
  </label>
</form>

Text Content

Developers
Developers
Docs
Start building your universally connected smart contracts

Developer Hub
new
Tools, tutorials, and technical support

Developer Experts Program
Chainlink’s most active and supportive technical community members
Products
Products
Cross-chain
Cross-Chain Communication

new
Move data and value between existing systems and any public or private
blockchain.
Data
Data Streams
new
Leverage high-frequency market data to power the next-generation of DeFi
markets.
Market and Data Feeds
Integrate ultra-secure onchain data to trigger smart contracts in DeFi and
beyond.
Proof of Reserve
Verify cross-chain and offchain reserves backing tokenized and wrapped assets.
Compute
Functions
Connect a smart contract to any API and run custom Web3 computation in minutes.
Automation
Automate smart contracts in a decentralized way with time or event-based
triggers.
VRF
Use verifiably random numbers to ensure fair outcomes in games, NFTs, and more.
Use Cases
Use Cases
Overview
Decentralized services powering hybrid smart contract use cases across a
wide-variety of industries
Learn more
Financial Services


DeFi


Gaming

NFT Collectibles

Climate Markets

Enterprise

Insurance
Ecosystem
Ecosystem
Chainlink Ecosystem
Provide oracle computation directly to smart contracts and earn revenue by
running critical data infrastructure

Data Providers
Leverage the Chainlink Network to make your data accessible onchain directly
through your own Chainlink nodes
Community
Community
Chainlink Community
Gain access to resources and events for Chainlink’s global community
Learn more
Grant Program

Funding and supporting the creation of new smart contract applications built by
the community

Events
Upcoming Chainlink virtual and in-person events, hackathons, meetups, and more
Resources
Resources
Blog
Discover the latest product news, deep dives, developer tutorials, and more
Learn more
Whitepaper


Case Studies


Tech Talks

FAQs

Education Hub
Economics
Economics
Staking app
Stake your LINK to help secure the Chainlink Network and earn rewards
View the app
Economics 2.0


Staking

BUILD Program
Menu

Connect Wallet


$LINK Distribution has started.
Claim $LINK now.
CCIP



CHAINLINK AIRDROP







Claim Airdrop
Sign up for Mainnet Early Access





A SECURE INTEROPERABILITY PROTOCOL FOR

enabling token transfers across blockchains
sending cross-chain messages
building cross-chain applications
enabling cross-chain real-world assets
scaling cross-chain ecosystems
connecting private and public blockchains
enabling token transfers across blockchains


DEFENSE-IN-DEPTH SECURITY


Powered by Chainlink’s industry-standard oracle networks. Cross-Chain
Interoperability Protocol (CCIP) also features additional layers of protection
via the Risk Management Network and transfer rate limits.



SIMPLIFIED TOKEN TRANSFERS


Seamlessly scale your userbase and benefit from enhanced token composability by
securely transferring tokens across chains in a fraction of the time it would
take to build a custom solution.



PROGRAMMABLE TOKEN TRANSFERS


Send tokens and instructions for their use to a receiving smart contract on a
different blockchain—specify to swap or stake assets once they arrive at the
destination chain, for example.



RELIABLE TRANSACTION EXECUTION


A transaction price is quoted on the source chain via a gas-locked fee payment
mechanism that confirms execution regardless of destination chain gas spikes and
network congestion.



SEAMLESS INTEGRATION


A single, easy-to-integrate interface for a unified cross-chain developer
experience. Simply integrate CCIP onchain and start building secure cross-chain
applications.



EXTENDABLE AND FUTURE-PROOF


CCIP will continue to be updated over time to support new blockchains, enhanced
functionalities, and additional defense-in-depth approaches.






START BUILDING WITH CHAINLINK CCIP

Securely send messages, transfer tokens, and initiate actions across
blockchains.

A single, elegant interface


For all cross-chain use cases.


Token transfers


Transfer tokens cross-chain, along with additional instructions about their use.


Arbitrary messaging


Send arbitrary data to a receiving smart contract on a different blockchain.


Copy


// The message to send cross-chain with CCIP 
struct EVM2AnyMessage {
  bytes receiver;                  // Receiver at destination
  bytes data;                      // Arbitrary data payload
  EVMTokenAmount[] tokenAmounts;   // ERC20 tokens and amounts
  address feeToken;                // Token to pay fees with
  bytes extraArgs;                 // Optional parameters
}

// Sending a message to any destination chain with CCIP
function ccipSend(
  uint64 destinationChainSelector, 
  EVM2AnyMessage calldata message) 
external
payable 
returns (bytes32 messageId);


Copy


// Set the tokens and amounts to transfer
Client.EVMTokenAmount[] memory tokenAmounts = new Client.EVMTokenAmount[](1);
Client.EVMTokenAmount memory tokenAmount = Client.EVMTokenAmount({
  token: _addressToken,
  amount: _amount
});
tokenAmounts[0] = tokenAmount;

// Create an EVM2AnyMessage struct in memory to send via CCIP
Client.EVM2AnyMessage memory message = Client.EVM2AnyMessage({
  receiver: abi.encode(_receiver),  // Receiver (EOA) at destination
  data:  "",                        // No data to send
  tokenAmounts: tokenAmounts,       // ERC20 tokens and amounts
  extraArgs: Client._argsToBytes(   // Optional parameters
    Client.EVMExtraArgsV1({
      gasLimit: 0,                  // gasLimit = 0 because EOA
      strict: false})               // No strict sequencing
  ),
  feeToken:  address(_addressLink)  // Setting feeToken to LINK
});

// approve the Router to spend tokens on sender contract's behalf.
IERC20(addressToken).approve(address(router), _amount);

// Send the message through the router and store the returned message ID
bytes32 messageId = router.ccipSend(
  destinationChainSelector,
  message
);
 


Copy


// Create an EVM2AnyMessage struct in memory to send via CCIP
Client.EVM2AnyMessage memory message = Client.EVM2AnyMessage({
  receiver: abi.encode(_receiver),               // Receiver contract at destination
  data: abi.encode("Hello world!"),              // Send "Hello world!"
  tokenAmounts: new Client.EVMTokenAmount[](0),  // No tokens to be sent
  extraArgs: "",                                 // Use default values
  feeToken: address(_addressLink)                // Setting feeToken to LINK
});

// Send the message through the router and store the returned message ID
bytes32 messageId = router.ccipSend(
  destinationChainSelector,
  message
);
 





CCIP IS THE ONLY INTEROPERABILITY PROTOCOL WITH LEVEL-5 SECURITY







PURPOSE-BUILT FOR TOKEN TRANSFERS


EFFORTLESS INTEGRATION 

With CCIP token transfers, your protocol can start transferring tokens across
chains in a fraction of the time it would take for you to build a solution on
your own. CCIP provides audited token pool contracts that handle the complexity
of burning/minting or locking/minting of your token across chains. Importantly,
token sponsors maintain full control over their token pool contract while using
CCIP.


SECURE TOKEN TRANSFERS

In addition to providing fully audited token pool smart contracts, CCIP token
transfers have additional security features, such as rate limits that allow you
to cap the value transferred over a given time interval. CCIP rate limits are
configurable per-token-pool and per-lane and are set up in alignment with the
token issuer. This feature is part of the heavily-audited CCIP code base and is
only available for CCIP token transfers and not arbitrary messaging.



ENHANCED COMPOSABILITY

CCIP token transfers increase the utility of your token, helping you seamlessly
scale your userbase across many chains. Tokens transferred through CCIP are
highly composable, allowing your ecosystem partners to transfer and build new
capabilities with your token via a single CCIP interface.


INTRODUCING THE RISK MANAGEMENT NETWORK

An independent network of nodes that enhances CCIP security by acting as a
secondary validation service and detecting and halting anomalous activity.





UNLOCK A WIDE VARIETY OF CROSS-CHAIN USE CASES

Use Cases
Transfer tokens
Gaming
Web3 usernames
DeFi
Liquidation protection


TRANSFER TOKENS



CCIP enables users to programmatically transfer tokens from one blockchain to
another via lock-and-mint or burn-and-mint mechanisms, along with attaching
arbitrary data commands.

View example in docs
const tokenAmounts = [
  {
    token: tokenAddress,
    amount: amount,
  },
];

// Encoding the data
‍
const functionSelector = ethers.utils.id("CCIP EVMExtraArgsV1").slice(0, 10);
// "extraArgs" is a structure that can be represented as [ 'uint256', 'bool' ]
// extraArgs are { gasLimit: 0, strict: false }
// we set gasLimit specifically to 0 because we are not sending any data so we
are not expecting a receiving contract to handle data

const extraArgs = ethers.utils.defaultAbiCoder.encode(    
  ["uint256", "bool"],
  [0, false]
);

const encodedExtraArgs = functionSelector + extraArgs.slice(2);

const message = {
  receiver: ethers.utils.defaultAbiCoder.encode(
    ["address"],
    [destinationAccount]
  ),
  data: "0x", // no data
  tokenAmounts: tokenAmounts,
  feeToken: feeTokenAddress ? feeTokenAddress : ethers.constants.AddressZero, //
If fee token address is provided then fees must be paid in fee token.
  extraArgs: encodedExtraArgs,
};
 
‍




GAMING



CCIP allows interoperability between Web3 games across multiple different
blockchains, which enables players on one chain to play a game against players
on another chain.


View example in docs
bytes32 uniqueId = keccak256(abi.encodePacked(block.timestamp, msg.sender));
  sessionIds.push(uniqueId);
  gameSessions[uniqueId]= GameSession(
    uniqueId,
    msg.sender,
    address(0),
    address(0),
    msg.sender,
    initialCombination,
    initialCombination
    );

  sendMessage(destinationChainSelector, receiver, gameSessions[uniqueId]);




WEB3 USERNAMES



CCIP brings complete interoperability to Web3 naming protocols by enabling users
to register onchain names on one chain and propagate these names across other
blockchains.


View example in docs
interface ICrossChainNameServiceLookup {
  function register(string memory _name, address _address)   external;
}

function ccipReceive(
  Client.Any2EVMMessage calldata message
) external override onlyRouter onlyFromSourceChain(message.sourceChainSelector)
{
  (string memory _name, address _address) = abi.decode(
    message.data,
    (string, address)
  );

  i_lookup.register(_name, _address);
}




DEFI



CCIP enables DeFi applications to use tokens on one chain as collateral for DeFi
applications on another chain, unlocking native cross-chain lending markets.


View example in docs
bytes32 messageId = any2EvmMessage.messageId; // fetch the messageId
uint64 sourceChainSelector = any2EvmMessage.sourceChainSelector; // fetch the
source chain identifier (aka selector)
address sender = abi.decode(any2EvmMessage.sender, (address)); // abi-decoding
of the sender address

// Collect tokens transferred. This increases this contract's balance for that
Token.
Client.EVMTokenAmount[] memory tokenAmounts = any2EvmMessage
  .destTokenAmounts;
address token = tokenAmounts[0].token;
uint256 amount = tokenAmounts[0].amount;

address depositor = abi.decode(any2EvmMessage.data, (address)); // abi-decoding
of the depositor's address

receivedMessages.push(messageId);
MessageIn memory detail = MessageIn(
  sourceChainSelector,
  sender,
  depositor,
  token,
  amount
);
messageDetail[messageId] = detail;

// Store depositor data.
deposits[depositor][token] = amount;
 
‍




DEFI LIQUIDATION PROTECTION



CCIP can help protect positions held in DeFi protocols across multiple chains by
automatically sending assets from one chain to DeFi protocols on another chain
to prevent liquidations.


View example in docs
bytes32 messageId = receivedMessage.messageId;
  uint64 sourceChainSelector = receivedMessage.sourceChainSelector;    
  address sender = abi.decode(receivedMessage.sender, (address));    
  (address tokenAddress, uint256 amount) = abi.decode(
    receivedMessage.data,
    (address, uint256)
  );

  Client.EVMTokenAmount[] memory tokenAmounts;
  tokenAmounts[1] = (Client.EVMTokenAmount(tokenAddress, amount));

  Client.EVM2AnyMessage memory messageReply = Client.EVM2AnyMessage({
    receiver: abi.encode(sender),
    data: abi.encode(messageId),
    tokenAmounts: tokenAmounts,
    extraArgs: s_chains[sourceChainSelector],
    feeToken: tokenAddress
  });

  IRouterClient(i_router).ccipSend(sourceChainSelector, messageReply);
 
‍



CCIP supported networks




FUTURE-PROOF YOUR WEB3 STRATEGY

Start building today


READ DOCS



Review up-to-date documentation and guides.


JOIN THE MASTERCLASS



Watch tutorials and learn how to get started with Chainlink CCIP.


ASK TECHNICAL QUESTIONS



Ask experienced developers on the Community Discord.



All code examples on this site are illustrative and are provided on an “as is”
basis without any representations, warranties, covenants, or conditions of any
kind. Use of these code snippets is governed by our Terms of Service found at
chain.link/terms.



GET THE LATEST CHAINLINK CONTENT STRAIGHT TO YOUR INBOX.


Email Address

Yes, I agree to receive email communications from Chainlink.
Thank you for signing up! Please check your inbox to confirm your subscription.

Oops! Something went wrong while submitting the form. Please try again


DEVELOPERS

 * Docs
 * Faucets
 * Developer Hub
 * Developer Experts
   APPLY
 * Chainlink Hackathon
 * Bootcamp
 * Use Cross-Chain (CCIP)
 * Use Data Feeds
 * Use Randomness (VRF)
 * Use Automation
 * Use Functions
 * Node Operators


PRODUCTS

 * Cross-Chain
 * Data Streams
 * Market and Data Feeds
 * Functions
 * VRF
 * Automation
 * Proof of Reserve


USE CASES

 * Overview
 * Financial Services
 * DeFi
 * Gaming
 * NFT Collectibles
 * Climate Markets
 * Enterprise
 * Insurance


COMMUNITY

 * Community Overview
 * Grant Program
 * Events
 * Become an Advocate
 * Code of Conduct


RESOURCES

 * Whitepaper
 * Case Studies
 * Tech Talks
 * Blog
 * Economics 2.0
 * Staking
 * FAQs
 * Education Hub
 * What Is DeFi?
 * What Is an Oracle?
 * What Is a Smart Contract?
 * What Is an NFT?
 * What Is Web3?
 * What is Asset Tokenization?


CHAINLINK

 * Ecosystem
 * Data Providers
 * Press
 * Team
 * Circulating Supply
 * Careers
   WE ARE HIRING!
 * Brand Assets
 * Chainlink Badging


CONTACT

 * Talk to an Expert
 * Security
 * Support
 * Custom Chainlinks
 * Press Inquiries
 * Legal Support
 * Legal


SOCIAL

 * Twitter
 * YouTube
 * Discord
 * Telegram
 * WeChat
 * Reddit

Home
Chainlink®
© 20242024 Chainlink Foundation
en
ZH

Privacy PolicyTerms of Service

 * 

Interact

 *