Explore docs & resources

Start your Chainlink journey

Explore Cross-Chain Interoperability with CCIP

Learn cross-chain concepts, workflows, and real-world use cases.

Build Cross-Chain Apps with CCIP Tutorials

Follow step-by-step guides with language switching (EVM, Rust, Move, etc.).

Monitor CCIP Transactions in Real Time

Track the progress and status of cross-chain transactions.

Understand How Data Feeds Power dApps

See how oracle data feeds deliver price feeds and reference data.

Integrate Data Feeds into Smart Contracts

Plug feeds into your apps with examples and addresses.

Stay Up to Date with Data Feeds

Rely on changelogs and schema updates for accuracy.

Learn How Data Streams Deliver Real-Time Data

Understand how low-latency streams support time-sensitive applications.

Implement Real-Time Use Cases with Data Streams

Use low-latency data in trading, gaming, and other live applications.

Deliver Reliable Low-Latency Data with Streams

Operate Data Streams at scale for critical, time-sensitive use cases.

Discover Off-Chain Compute with Functions

Learn how Functions connect smart contracts to APIs and custom logic.

Connect Contracts to APIs with Functions

Add external data and custom logic to your dApps.

Scale and Optimize Functions

Debug, manage workloads, and grow your applications.

Try it out

Use Chainlink CCIP to transfer tokens from a smart contract to an account on a different blockchain.

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

import {FunctionsClient} from "@chainlink/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol";

import {FunctionsRequest} from "@chainlink/contracts/src/v0.8/functions/v1_0_0/libraries/FunctionsRequest.sol";
import {ConfirmedOwner} from "@chainlink/contracts/src/v0.8/shared/access/ConfirmedOwner.sol";

/**
 * THIS IS AN EXAMPLE CONTRACT THAT USES HARDCODED VALUES FOR CLARITY.
 * THIS IS AN EXAMPLE CONTRACT THAT USES UN-AUDITED CODE.
 * DO NOT USE THIS CODE IN PRODUCTION.
 */
contract FunctionsConsumerDecoder is FunctionsClient, ConfirmedOwner {
  using FunctionsRequest for FunctionsRequest.Request;

  bytes32 public s_lastRequestId;
  bytes public s_lastResponse;
  bytes public s_lastError;

  uint256 public s_answer;
  uint256 public s_updatedAt;
  uint8 public s_decimals;
  string public s_description;

  error UnexpectedRequestID(bytes32 requestId);

  event Response(bytes32 indexed requestId, bytes response, bytes err);

  event DecodedResponse(
    bytes32 indexed requestId, uint256 answer, uint256 updatedAt, uint8 decimals, string description
  );

  constructor(
    address router
  ) FunctionsClient(router) ConfirmedOwner(msg.sender) {}

  /**
   * @notice Send a simple request
   * @param source JavaScript source code
   * @param encryptedSecretsUrls Encrypted URLs where to fetch user secrets
   * @param donHostedSecretsSlotID Don hosted secrets slotId
   * @param donHostedSecretsVersion Don hosted secrets version
   * @param args List of arguments accessible from within the source code
   * @param bytesArgs Array of bytes arguments, represented as hex strings
   * @param subscriptionId Billing ID
   */
  function sendRequest(
    string memory source,
    bytes memory encryptedSecretsUrls,
    uint8 donHostedSecretsSlotID,
    uint64 donHostedSecretsVersion,
    string[] memory args,
    bytes[] memory bytesArgs,
    uint64 subscriptionId,
    uint32 gasLimit,
    bytes32 donID
  ) external onlyOwner returns (bytes32 requestId) {
    FunctionsRequest.Request memory req;
    req.initializeRequestForInlineJavaScript(source);
    if (encryptedSecretsUrls.length > 0) {
      req.addSecretsReference(encryptedSecretsUrls);
    } else if (donHostedSecretsVersion > 0) {
      req.addDONHostedSecrets(donHostedSecretsSlotID, donHostedSecretsVersion);
    }
    if (args.length > 0) req.setArgs(args);
    if (bytesArgs.length > 0) req.setBytesArgs(bytesArgs);
    s_lastRequestId = _sendRequest(req.encodeCBOR(), subscriptionId, gasLimit, donID);
    return s_lastRequestId;
  }

  /**
   * @notice Send a pre-encoded CBOR request
   * @param request CBOR-encoded request data
   * @param subscriptionId Billing ID
   * @param gasLimit The maximum amount of gas the request can consume
   * @param donID ID of the job to be invoked
   * @return requestId The ID of the sent request
   */
  function sendRequestCBOR(
    bytes memory request,
    uint64 subscriptionId,
    uint32 gasLimit,
    bytes32 donID
  ) external onlyOwner returns (bytes32 requestId) {
    s_lastRequestId = _sendRequest(request, subscriptionId, gasLimit, donID);
    return s_lastRequestId;
  }

  /**
   * @dev Internal function to process the outcome of a data request. It stores the latest response or error and updates
   * the contract state accordingly. This function is designed to handle only one of `response` or `err` at a time, not
   * both. It decodes the response if present and emits events to log both raw and decoded data.
   *
   * @param requestId The unique identifier of the request, originally returned by `sendRequest`. Used to match
   * responses with requests.
   * @param response The raw aggregated response data from the external source. This data is ABI-encoded and is expected
   * to contain specific information (e.g., answer, updatedAt) if no error occurred. The function attempts to decode
   * this data if `response` is not empty.
   * @param err The raw aggregated error information, indicating an issue either from the user's code or within the
   * execution of the user Chainlink Function.
   *
   * Emits a `DecodedResponse` event if the `response` is successfully decoded, providing detailed information about the
   * data received.
   * Emits a `Response` event for every call to log the raw response and error data.
   *
   * Requirements:
   * - The `requestId` must match the last stored request ID to ensure the response corresponds to the latest request
   * sent.
   * - Only one of `response` or `err` should contain data for a given call; the other should be empty.
   */
  function fulfillRequest(
    bytes32 requestId,
    bytes memory response,
    bytes memory err
  ) internal override {
    if (s_lastRequestId != requestId) {
      revert UnexpectedRequestID(requestId);
    }

    s_lastError = err;
    s_lastResponse = response;

    if (response.length > 0) {
      (uint256 answer, uint256 updatedAt, uint8 decimals, string memory description) =
        abi.decode(response, (uint256, uint256, uint8, string));

      s_answer = answer;
      s_updatedAt = updatedAt;
      s_decimals = decimals;
      s_description = description;

      emit DecodedResponse(requestId, answer, updatedAt, decimals, description);
    }

    emit Response(requestId, response, err);
  }
}

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

import {FunctionsClient} from "@chainlink/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol";
import {ConfirmedOwner} from "@chainlink/contracts/src/v0.8/shared/access/ConfirmedOwner.sol";

/**
 * @title Functions contract used for Automation.
 * @notice This contract is a demonstration of using Functions and Automation.
 * @notice You may need to add a Forwarder for additional security.
 * @notice NOT FOR PRODUCTION USE
 */
contract AutomatedFunctionsConsumerExample is FunctionsClient, ConfirmedOwner {
  address public upkeepContract;
  bytes public request;
  uint64 public subscriptionId;
  uint32 public gasLimit;
  bytes32 public donID;
  bytes32 public s_lastRequestId;
  bytes public s_lastResponse;
  bytes public s_lastError;

  error NotAllowedCaller(address caller, address owner, address automationRegistry);
  error UnexpectedRequestID(bytes32 requestId);

  event Response(bytes32 indexed requestId, bytes response, bytes err);

  constructor(
    address router
  ) FunctionsClient(router) ConfirmedOwner(msg.sender) {}

  /**
   * @notice Reverts if called by anyone other than the contract owner or automation registry.
   */
  modifier onlyAllowed() {
    if (msg.sender != owner() && msg.sender != upkeepContract) {
      revert NotAllowedCaller(msg.sender, owner(), upkeepContract);
    }
    _;
  }

  function setAutomationCronContract(
    address _upkeepContract
  ) external onlyOwner {
    upkeepContract = _upkeepContract;
  }

  /// @notice Update the request settings
  /// @dev Only callable by the owner of the contract
  /// @param _request The new encoded CBOR request to be set. The request is encoded offchain
  /// @param _subscriptionId The new subscription ID to be set
  /// @param _gasLimit The new gas limit to be set
  /// @param _donID The new job ID to be set
  function updateRequest(
    bytes memory _request,
    uint64 _subscriptionId,
    uint32 _gasLimit,
    bytes32 _donID
  ) external onlyOwner {
    request = _request;
    subscriptionId = _subscriptionId;
    gasLimit = _gasLimit;
    donID = _donID;
  }

  /**
   * @notice Send a pre-encoded CBOR request
   * @return requestId The ID of the sent request
   */
  function sendRequestCBOR() external onlyAllowed returns (bytes32 requestId) {
    s_lastRequestId = _sendRequest(request, subscriptionId, gasLimit, donID);
    return s_lastRequestId;
  }

  /**
   * @notice Store latest result/error
   * @param requestId The request ID, returned by sendRequest()
   * @param response Aggregated response from the user code
   * @param err Aggregated error from the user code or from the execution pipeline
   * Either response or error parameter will be set, but never both
   */
  function fulfillRequest(
    bytes32 requestId,
    bytes memory response,
    bytes memory err
  ) internal override {
    if (s_lastRequestId != requestId) {
      revert UnexpectedRequestID(requestId);
    }
    s_lastResponse = response;
    s_lastError = err;
    emit Response(requestId, s_lastResponse, s_lastError);
  }
}

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

import {FunctionsClient} from "@chainlink/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol";

import {FunctionsRequest} from "@chainlink/contracts/src/v0.8/functions/v1_0_0/libraries/FunctionsRequest.sol";
import {ConfirmedOwner} from "@chainlink/contracts/src/v0.8/shared/access/ConfirmedOwner.sol";

/**
 * Request testnet LINK and ETH here: https://faucets.chain.link/
 * Find information on LINK Token Contracts and get the latest ETH and LINK faucets here:
 * https://docs.chain.link/resources/link-token-contracts/
 */

/**
 * @title GettingStartedFunctionsConsumer
 * @notice This is an example contract to show how to make HTTP requests using Chainlink
 * @dev This contract uses hardcoded values and should not be used in production.
 */
contract GettingStartedFunctionsConsumer is FunctionsClient, ConfirmedOwner {
  using FunctionsRequest for FunctionsRequest.Request;

  // State variables to store the last request ID, response, and error
  bytes32 public s_lastRequestId;
  bytes public s_lastResponse;
  bytes public s_lastError;

  // Custom error type
  error UnexpectedRequestID(bytes32 requestId);

  // Event to log responses
  event Response(bytes32 indexed requestId, string character, bytes response, bytes err);

  // Router address - Hardcoded for Sepolia
  // Check to get the router address for your supported network
  // https://docs.chain.link/chainlink-functions/supported-networks
  address router = 0xb83E47C2bC239B3bf370bc41e1459A34b41238D0;

  // JavaScript source code
  // Fetch character name from the Star Wars API.
  // Documentation: https://swapi.info/people
  string source = "const characterId = args[0];" "const apiResponse = await Functions.makeHttpRequest({"
    "url: `https://swapi.info/api/people/${characterId}/`" "});" "if (apiResponse.error) {"
    "throw Error('Request failed');" "}" "const { data } = apiResponse;" "return Functions.encodeString(data.name);";

  //Callback gas limit
  uint32 gasLimit = 300_000;

  // donID - Hardcoded for Sepolia
  // Check to get the donID for your supported network https://docs.chain.link/chainlink-functions/supported-networks
  bytes32 donID = 0x66756e2d657468657265756d2d7365706f6c69612d3100000000000000000000;

  // State variable to store the returned character information
  string public character;

  /**
   * @notice Initializes the contract with the Chainlink router address and sets the contract owner
   */
  constructor() FunctionsClient(router) ConfirmedOwner(msg.sender) {}

  /**
   * @notice Sends an HTTP request for character information
   * @param subscriptionId The ID for the Chainlink subscription
   * @param args The arguments to pass to the HTTP request
   * @return requestId The ID of the request
   */
  function sendRequest(
    uint64 subscriptionId,
    string[] calldata args
  ) external onlyOwner returns (bytes32 requestId) {
    FunctionsRequest.Request memory req;
    req.initializeRequestForInlineJavaScript(source); // Initialize the request with JS code
    if (args.length > 0) req.setArgs(args); // Set the arguments for the request

    // Send the request and store the request ID
    s_lastRequestId = _sendRequest(req.encodeCBOR(), subscriptionId, gasLimit, donID);

    return s_lastRequestId;
  }

  /**
   * @notice Callback function for fulfilling a request
   * @param requestId The ID of the request to fulfill
   * @param response The HTTP response data
   * @param err Any errors from the Functions request
   */
  function fulfillRequest(
    bytes32 requestId,
    bytes memory response,
    bytes memory err
  ) internal override {
    if (s_lastRequestId != requestId) {
      revert UnexpectedRequestID(requestId); // Check if request IDs match
    }
    // Update the contract's state variables with the response and any errors
    s_lastResponse = response;
    character = string(response);
    s_lastError = err;

    // Emit an event to log the response
    emit Response(requestId, character, s_lastResponse, s_lastError);
  }
}

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

import {FunctionsClient} from "@chainlink/contracts/src/v0.8/functions/v1_0_0/FunctionsClient.sol";
import {ConfirmedOwner} from "@chainlink/contracts/src/v0.8/shared/access/ConfirmedOwner.sol";

/**
 * @title Functions contract used for Automation.
 * @notice This contract is a demonstration of using Functions and Automation.
 * @notice You may need to add a Forwarder for additional security.
 * @notice NOT FOR PRODUCTION USE
 */
contract AutomatedFunctionsConsumerExample is FunctionsClient, ConfirmedOwner {
  address public upkeepContract;
  bytes public request;
  uint64 public subscriptionId;
  uint32 public gasLimit;
  bytes32 public donID;
  bytes32 public s_lastRequestId;
  bytes public s_lastResponse;
  bytes public s_lastError;

  error NotAllowedCaller(address caller, address owner, address automationRegistry);
  error UnexpectedRequestID(bytes32 requestId);

  event Response(bytes32 indexed requestId, bytes response, bytes err);

  constructor(
    address router
  ) FunctionsClient(router) ConfirmedOwner(msg.sender) {}

  /**
   * @notice Reverts if called by anyone other than the contract owner or automation registry.
   */
  modifier onlyAllowed() {
    if (msg.sender != owner() && msg.sender != upkeepContract) {
      revert NotAllowedCaller(msg.sender, owner(), upkeepContract);
    }
    _;
  }

  function setAutomationCronContract(
    address _upkeepContract
  ) external onlyOwner {
    upkeepContract = _upkeepContract;
  }

  /// @notice Update the request settings
  /// @dev Only callable by the owner of the contract
  /// @param _request The new encoded CBOR request to be set. The request is encoded offchain
  /// @param _subscriptionId The new subscription ID to be set
  /// @param _gasLimit The new gas limit to be set
  /// @param _donID The new job ID to be set
  function updateRequest(
    bytes memory _request,
    uint64 _subscriptionId,
    uint32 _gasLimit,
    bytes32 _donID
  ) external onlyOwner {
    request = _request;
    subscriptionId = _subscriptionId;
    gasLimit = _gasLimit;
    donID = _donID;
  }

  /**
   * @notice Send a pre-encoded CBOR request
   * @return requestId The ID of the sent request
   */
  function sendRequestCBOR() external onlyAllowed returns (bytes32 requestId) {
    s_lastRequestId = _sendRequest(request, subscriptionId, gasLimit, donID);
    return s_lastRequestId;
  }

  /**
   * @notice Store latest result/error
   * @param requestId The request ID, returned by sendRequest()
   * @param response Aggregated response from the user code
   * @param err Aggregated error from the user code or from the execution pipeline
   * Either response or error parameter will be set, but never both
   */
  function fulfillRequest(
    bytes32 requestId,
    bytes memory response,
    bytes memory err
  ) internal override {
    if (s_lastRequestId != requestId) {
      revert UnexpectedRequestID(requestId);
    }
    s_lastResponse = response;
    s_lastError = err;
    emit Response(requestId, s_lastResponse, s_lastError);
  }
}

Demos

Custom Data Feed

See how you can bring your financial data onchain in a variety of different ways by creating a Net Asset Value feed, Proof of Reserve feed, or other custom data feed.