| Arbitrum | |
| 
| Avalanche | |
| 
| Base | |
| 
| Bob | |
| 
| BNB Chain (BSC) | |
| 
| Celo | |
| 
| Ethereum | |
| 
| Gnosis Chain (xDai) | |
| 
| Ink | |
| 
| Linea | |
| 
| Mantle | |
| 
| Monad | |
| 
| Optimism | |
| 
| Polygon | |
| 
| Scroll | |
| 
| Soneium | |
| 
| Sonic | |
| 
| UniChain | |
| 
| zkSync | |
---
# Data Sources
Source: https://docs.chain.link/data-feeds/data-sources
Chainlink Data Feeds and Data Streams source data across multiple independent aggregators, vendors, and authoritative entities. The table below summarizes sourcing models for each asset type.
For more information about evaluating data quality, assessing liquidity and distribution risks, understanding single-source providers, and implementing risk mitigation strategies, see [Evaluating Data Sources and Risks](/data-feeds/selecting-data-feeds#evaluating-data-sources-and-risks).
| Asset Type | Data Sourcing Info |
| --------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Crypto Price | 3+ crypto price data aggregators and/or market data vendors using CEX and/or DEX data |
| Crypto State Price | 3+ crypto price data aggregators and/or market data vendors using DEX pool state data |
| Forex | 3+ market data vendors |
| Precious Metals | 3+ market data vendors |
| US Oil | 3+ market data vendors |
| US Equities | 3+ market data vendors |
| UK & Euro ETFs | 2+ market data vendors using 15 minute delayed data |
| SmartData PoR (offchain) | Sourced directly from custodian, fund administrator, auditor, security auditor, asset manager, regulated appraiser of assets, or regulator approved source |
| SmartData PoR (cross chain) | On-chain data |
| SmartData NAV (offchain) | Sourced directly from Fund Administrator or Asset Manager of the fund |
| Exchange Rate Feeds | On-chain data |
| Crypto MarketCap | 3+ crypto price data aggregators and/or market data vendors |
| Composite Index Feeds | DON calculated index values from 3+ crypto price data aggregators and/or market data vendors |
| Central Bank Rates Feeds | Direct from Central Bank's API |
| Crypto LWBA | 3+ crypto price data aggregators and/or market data vendors using CEX orderbook data to produce Liquidity Weight Bid/Ask and Mid values |
| Crypto State Price | 3+ crypto price data aggregators and/or market data vendors using DEX pool state data |
| Data Link Long Tail Crypto | Single source from 1 crypto price data aggregator |
| Forex | 3+ market data vendors |
| Precious Metals | 3+ market data vendors |
| US Equities | 3+ market data vendors |
---
# Deprecation of Chainlink Data Feeds
Source: https://docs.chain.link/data-feeds/deprecating-feeds
Arbitrum
Arbitrum Mainnet: [0xFdB631F5EE196F0ed6FAa767959853A9F217697D](https://arbiscan.io/address/0xFdB631F5EE196F0ed6FAa767959853A9F217697D)
### BASE
BASE Mainnet: [0xBCF85224fc0756B9Fa45aA7892530B47e10b6433](https://basescan.org/address/0xBCF85224fc0756B9Fa45aA7892530B47e10b6433)
### Celo
Celo Mainnet: [0x4CD491Dc27C8B0BbD10D516A502856B786939d18](https://celoscan.io/address/0x4CD491Dc27C8B0BbD10D516A502856B786939d18)
### Mantle
Mantle Mainnet: [0xaDE1b9AbB98c6A542E4B49db2588a3Ec4bF7Cdf0](https://mantlescan.xyz/address/0xaDE1b9AbB98c6A542E4B49db2588a3Ec4bF7Cdf0)
### 
MegaETH
MegaETH Mainnet: [0x78B2195A21B8BBe82acaB43F90F9180E9513FD0C](https://mega.etherscan.io/address/0x78B2195A21B8BBe82acaB43F90F9180E9513FD0C)
### 
Metis
Andromeda Mainnet: [0x58218ea7422255EBE94e56b504035a784b7AA204](https://andromeda-explorer.metis.io/address/0x58218ea7422255EBE94e56b504035a784b7AA204)
### OP
OP Mainnet: [0x371EAD81c9102C9BF4874A9075FFFf170F2Ee389](https://optimistic.etherscan.io/address/0x371EAD81c9102C9BF4874A9075FFFf170F2Ee389)
### Scroll
Scroll Mainnet: [0x45c2b8C204568A03Dc7A2E32B71D67Fe97F908A9](https://scrollscan.com/address/0x45c2b8C204568A03Dc7A2E32B71D67Fe97F908A9)
### Soneium
Soneium Mainnet: [0xaDE1b9AbB98c6A542E4B49db2588a3Ec4bF7Cdf0](https://soneium.blockscout.com/address/0xaDE1b9AbB98c6A542E4B49db2588a3Ec4bF7Cdf0)
### 
X Layer
X Layer Mainnet: [0x45c2b8C204568A03Dc7A2E32B71D67Fe97F908A9](https://www.okx.com/web3/explorer/xlayer/address/0x45c2b8C204568A03Dc7A2E32B71D67Fe97F908A9)
### ZKsync
zkSync Mainnet: [0x0E6AC8B967393dcD3D36677c126976157F993940](https://explorer.zksync.io/address/0x0E6AC8B967393dcD3D36677c126976157F993940)
## Real-time Monitoring Process
### Arbitrum
The diagram below shows how these feeds update and how a consumer retrieves the status of the Arbitrum sequencer.
1. Chainlink nodes trigger an OCR round every 30s and update the sequencer status by calling the `validate` function in the [`ArbitrumValidator` contract](https://github.com/smartcontractkit/chainlink/blob/contracts-v1.3.0/contracts/src/v0.8/l2ep/dev/arbitrum/ArbitrumValidator.sol) by calling it through the [`ValidatorProxy` contract](https://github.com/smartcontractkit/chainlink/blob/contracts-v1.0.0/contracts/src/v0.8/ValidatorProxy.sol).
2. The `ArbitrumValidator` checks to see if the latest update is different from the previous update. If it detects a difference, it places a message in the [Arbitrum inbox contract](https://docs.arbitrum.io/how-arbitrum-works/inside-arbitrum-nitro).
3. The inbox contract sends the message to the [`ArbitrumSequencerUptimeFeed` contract](https://github.com/smartcontractkit/chainlink/blob/contracts-v1.3.0/contracts/src/v0.8/l2ep/dev/arbitrum/ArbitrumSequencerUptimeFeed.sol). The message calls the `updateStatus` function in the `ArbitrumSequencerUptimeFeed` contract and updates the latest sequencer status to 0 if the sequencer is up and 1 if it is down. It also records the block timestamp to indicate when the message was sent from the L1 network.
4. A consumer contract on the L2 network can read these values from the [`ArbitrumUptimeFeedProxy` contract](https://github.com/smartcontractkit/chainlink/blob/contracts-v1.0.0/contracts/src/v0.6/EACAggregatorProxy.sol), which reads values from the `ArbitrumSequencerUptimeFeed` contract.
#### Handling Arbitrum Outages
If the Arbitrum network becomes unavailable, the `ArbitrumValidator` contract continues to send messages to the L2 network through the delayed inbox on L1. This message stays there until the sequencer is back up again. When the sequencer comes back online after downtime, it processes all transactions from the delayed inbox before it accepts new transactions. The message that signals when the sequencer is down will be processed before any new messages with transactions that require the sequencer to be operational.
### Other Supported Networks
On BASE, Celo, Mantle, Metis, OP, Scroll, Soneium and zkSync, the sequencer's status is relayed from L1 to L2 where the consumer can retrieve it.
**On the L1 network:**
1. A network of node operators runs the external adapter to post the latest sequencer status to the `AggregatorProxy` contract and relays the status to the `Aggregator` contract. The `Aggregator` contract calls the `validate` function in the `OptimismValidator` contract.
2. The `OptimismValidator` contract calls the `sendMessage` function in the `L1CrossDomainMessenger` contract. This message contains instructions to call the `updateStatus(bool status, uint64 timestamp)` function in the sequencer uptime feed deployed on the L2 network.
3. The `L1CrossDomainMessenger` contract calls the `enqueue` function to enqueue a new message to the `CanonicalTransactionChain`.
4. The `Sequencer` processes the transaction enqueued in the `CanonicalTransactionChain` contract to send it to the L2 contract.
**On the L2 network:**
1. The `Sequencer` posts the message to the `L2CrossDomainMessenger` contract.
2. The `L2CrossDomainMessenger` contract relays the message to the `OptimismSequencerUptimeFeed` contract.
3. The message relayed by the `L2CrossDomainMessenger` contains instructions to call `updateStatus` in the `OptimismSequencerUptimeFeed` contract.
4. Consumers can then read from the `AggregatorProxy` contract, which fetches the latest round data from the `OptimismSequencerUptimeFeed` contract.
#### Handling Other Supported Network Outages
If the sequencer is down, messages cannot be transmitted from L1 to L2 and **no L2 transactions are executed**. Instead, messages are enqueued in the `CanonicalTransactionChain` on L1 and only processed in the order they arrived later when the sequencer comes back up. As long as the message from the validator on L1 is already enqueued in the `CTC`, the flag on the sequencer uptime feed on L2 will be guaranteed to be flipped prior to any subsequent transactions. The transaction that flips the flag on the uptime feed will be executed before transactions that were enqueued after it. This is further explained in the diagrams below.
When the Sequencer is down, all L2 transactions sent from the L1 network wait in the pending queue.
1. **Transaction 3** contains Chainlink's transaction to set the status of the sequencer as being down on L2.
2. **Transaction 4** is a transaction made by a consumer that is dependent on the sequencer status.
After the sequencer comes back up, it moves all transactions in the pending queue to the processed queue.
1. Transactions are processed in the order they arrived so **Transaction 3** is processed before **Transaction 4**.
2. Because **Transaction 3** happens before **Transaction 4**, **Transaction 4** will read the status of the Sequencer as being down and responds accordingly.
## Example Consumer Contract
This example code works on any network that supports Solidity. Create the consumer contract for sequencer uptime feeds similarly to the contracts that you use for other [Chainlink Data Feeds](/data-feeds/using-data-feeds). Configure the constructor using the following variables:
- Configure the `sequencerUptimeFeed` object with the [sequencer uptime feed proxy address](#supported-networks) for your L2 network.
- Configure the `dataFeed` object with one of the [Data Feed proxy addresses](/data-feeds/price-feeds/addresses) that are available for your network.
```sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import {AggregatorV2V3Interface} from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV2V3Interface.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 DataConsumerWithSequencerCheck {
AggregatorV2V3Interface internal dataFeed;
AggregatorV2V3Interface internal sequencerUptimeFeed;
uint256 private constant GRACE_PERIOD_TIME = 3600;
error SequencerDown();
error GracePeriodNotOver();
/**
* Network: OP Mainnet
* Data Feed: BTC/USD
* Data Feed address: 0xD702DD976Fb76Fffc2D3963D037dfDae5b04E593
* Uptime Feed address: 0x371EAD81c9102C9BF4874A9075FFFf170F2Ee389
* For a list of available Sequencer Uptime Feed proxy addresses, see:
* https://docs.chain.link/docs/data-feeds/l2-sequencer-feeds
*/
constructor() {
dataFeed = AggregatorV2V3Interface(0xD702DD976Fb76Fffc2D3963D037dfDae5b04E593);
sequencerUptimeFeed = AggregatorV2V3Interface(0x371EAD81c9102C9BF4874A9075FFFf170F2Ee389);
}
// Check the sequencer status and return the latest data
function getChainlinkDataFeedLatestAnswer() public view returns (int256) {
// prettier-ignore
(
/*uint80 roundID*/
,
int256 answer,
uint256 startedAt,
/*uint256 updatedAt*/
,
/*uint80 answeredInRound*/
) = sequencerUptimeFeed.latestRoundData();
// Answer == 0: Sequencer is up
// Answer == 1: Sequencer is down
bool isSequencerUp = answer == 0;
if (!isSequencerUp) {
revert SequencerDown();
}
// Make sure the grace period has passed after the
// sequencer is back up.
uint256 timeSinceUp = block.timestamp - startedAt;
if (timeSinceUp <= GRACE_PERIOD_TIME) {
revert GracePeriodNotOver();
}
// prettier-ignore
(
/*uint80 roundID*/
,
int256 data,
/*uint startedAt*/
,
/*uint timeStamp*/
,
/*uint80 answeredInRound*/
) = dataFeed.latestRoundData();
return data;
}
}
```
The `sequencerUptimeFeed` object returns the following values:
- `answer`: A variable with a value of either `0` or `1`
- 0: The sequencer is up
- 1: The sequencer is down
- `startedAt`: This timestamp indicates when the sequencer feed changed status. When the sequencer comes back up after an outage, wait for the `GRACE_PERIOD_TIME` to pass before accepting answers from the data feed. Subtract `startedAt` from `block.timestamp` and revert the request if the result is less than the `GRACE_PERIOD_TIME`.
- The `startedAt` variable returns `0` only on Arbitrum when the Sequencer Uptime contract is not yet initialized. For L2 chains other than Arbitrum, `startedAt` is set to `block.timestamp` on construction and `startedAt` is never `0`. After the feed begins rounds, the `startedAt` timestamp will always indicate when the sequencer feed last changed status.
If the sequencer is up and the `GRACE_PERIOD_TIME` has passed, the function retrieves the latest answer from the data feed using the `dataFeed` object.
---
# MVR Feeds API Reference
Source: https://docs.chain.link/data-feeds/mvr-feeds/api-reference
When you use MVR Feeds, you typically retrieve the data through the `IBundleAggregatorProxy` interface and the proxy contract address. This interface combines functions from both `IBundleBaseAggregator` and `ICommonAggregator`. If the aggregator behind the proxy changes, your consumer contract remains compatible as long as you interact through the proxy interface.
To see detailed examples of how to integrate these functions, refer to the [Using MVR Feeds on EVM Chains (Solidity)](/data-feeds/mvr-feeds/guides/evm-solidity) guide.
## IBundleAggregatorProxy
`IBundleAggregatorProxy` extends both `IBundleBaseAggregator` and `ICommonAggregator`. In addition, it provides functions to manage or view the underlying aggregator reference.
A minimal example showing how to set the proxy address and call these functions in your consumer contract:
```solidity
import { IBundleAggregatorProxy } from "./interfaces/IBundleAggregatorProxy.sol";
contract MyMVRConsumer {
IBundleAggregatorProxy public proxy;
constructor(address _proxyAddress) {
proxy = IBundleAggregatorProxy(_proxyAddress);
}
function readLatestData() external view returns (bytes memory, uint256) {
// Retrieve the latest bundle as raw bytes
bytes memory bundle = proxy.latestBundle();
// Get the timestamp of the latest update
uint256 timestamp = proxy.latestBundleTimestamp();
return (bundle, timestamp);
}
}
```
### Functions in IBundleAggregatorProxy
| Name | Description |
| ----------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| [proposedAggregator](#proposedaggregator) | Returns the address of the aggregator that is proposed to replace the current aggregator, but not yet confirmed. |
| [confirmAggregator](#confirmaggregator) | Confirms a new aggregator address. Typically, only the owner or an authorized entity can call this. |
| [aggregator](#aggregator) | Returns the address of the currently confirmed aggregator behind the proxy. |
| [latestBundle](#latestbundle) | Returns the most recent data bundle as a bytes array. |
| [bundleDecimals](#bundledecimals) | Returns an array of decimals that match each numeric field in the bundle. Non-numeric fields typically have 0. |
| [latestBundleTimestamp](#latestbundletimestamp) | Returns the timestamp of the most recent data bundle. |
| [description](#description) | A short description of the underlying aggregator or feed. |
| [version](#version) | Returns a version number for the aggregator. |
#### proposedAggregator
```solidity
function proposedAggregator() external view returns (address);
```
Returns the address of the aggregator that is proposed to replace the current aggregator. This aggregator is not active until it is confirmed.
#### confirmAggregator
```solidity
function confirmAggregator(address aggregatorAddress) external;
```
Confirms a new aggregator contract address. Only authorized addresses can typically call this function.
- Parameters:
- aggregatorAddress: The address of the new aggregator to confirm.
#### aggregator
```solidity
function aggregator() external view returns (address);
```
Returns the address of the currently confirmed aggregator behind the proxy.
#### latestBundle
```solidity
function latestBundle() external view returns (bytes memory bundle);
```
Returns the most recent data bundle as a bytes array. You can decode this bundle according to the known structure for your specific MVR feed.
#### bundleDecimals
```solidity
function bundleDecimals() external view returns (uint8[] memory);
```
Returns an array of decimals for the numeric fields of the data bundle. Fields of other types, such as bool, typically have a corresponding decimal value of 0.
#### latestBundleTimestamp
```solidity
function latestBundleTimestamp() external view returns (uint256);
```
Returns the timestamp (block time) of the most recent update to the data bundle.
#### description
```solidity
function description() external view returns (string memory);
```
Returns a short description of the underlying aggregator or feed.
#### version
```solidity
function version() external view returns (uint256);
```
Returns the version number of the aggregator behind the proxy.
***
## IBundleBaseAggregator
`IBundleBaseAggregator` defines the core functions for reading multiple-variable data from an onchain aggregator. These functions are inherited by `IBundleAggregatorProxy`.
### Functions in IBundleBaseAggregator
| Name | Description |
| --------------------- | ------------------------------------------------------------------ |
| latestBundle | Returns the most recent data bundle as a bytes array. |
| bundleDecimals | Returns the array of decimals corresponding to each numeric field. |
| latestBundleTimestamp | Returns the timestamp of the most recent data bundle. |
#### latestBundle
```solidity
function latestBundle() external view returns (bytes memory bundle);
```
Returns the latest encoded bundle data as a bytes array.
#### bundleDecimals
```solidity
function bundleDecimals() external view returns (uint8[] memory);
```
Returns an array of decimals where each entry corresponds to a numeric field in the bundle. Non-numeric fields might have a value of 0.
#### latestBundleTimestamp
```solidity
function latestBundleTimestamp() external view returns (uint256);
```
Returns the block timestamp of the most recent data bundle.
***
## ICommonAggregator
`ICommonAggregator` provides common metadata functions for aggregator contracts, such as a human-readable description and a version number.
### Functions in ICommonAggregator
| Name | Description |
| ----------- | -------------------------------------------------------- |
| description | A string describing the underlying aggregator. |
| version | Returns a numeric version identifier for the aggregator. |
#### description
```solidity
function description() external view returns (string memory);
```
Returns a description string for the feed or aggregator.
#### version
```solidity
function version() external view returns (uint256);
```
Returns a numeric value representing the aggregator version.
---
# Using MVR Feeds with ethers.js (JS)
Source: https://docs.chain.link/data-feeds/mvr-feeds/guides/ethersjs
This guide explains how to use [Multiple-Variable Response (MVR) feeds](/data-feeds/mvr-feeds) data in your JavaScript applications using the [ethers.js v5 library](https://docs.ethers.org/v5/).
MVR feeds store multiple data points in a single byte array onchain. To consume this data in your JavaScript application:
1. **Obtain the proxy address and data structure**:
- Find the `BundleAggregatorProxy` address for the specific MVR feed you want to read on the [SmartData Addresses](/data-feeds/smartdata/addresses?page=1#networks) page
- Expand the "MVR Bundle Info" section to see the exact data structure, field types, and decimals
- Note these details as you'll need to match this structure exactly in your code
2. **Set up ethers.js**: Create a provider and contract instance to interact with the feed.
3. **Check data staleness**: Compare the feed's latest timestamp against current time to verify it hasn't exceeded your maximum acceptable staleness threshold.
4. **Fetch and decode the data**: Retrieve the feed's latest bundle and decode the bytes array.
5. **Apply decimals**: Scale numeric values to their true decimal representation for accurate calculations and display.
6. **Use in your application**: Process or display the decoded values.
## Prerequisites
- [Node.js](https://nodejs.org/en/download/) environment (Node.js >=12.x recommended)
- [npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) or [yarn](https://yarnpkg.com/getting-started) installed
- [ethers.js](https://docs.ethers.org/v5/) library v5.x installed:
```shell
npm install ethers@^5.0.0
```
or
```shell
yarn add ethers@^5.0.0
```
**Note:** For [ethers.js v6](https://docs.ethers.org/v6/), some API calls differ significantly.
- An RPC URL for the network where the MVR feed is deployed. You can sign up for a personal endpoint from [Alchemy](https://www.alchemy.com/) or [Infura](https://infura.io/).
- Set up environment variables:
```shell
npm install dotenv
```
or
```shell
yarn add dotenv
```
## Step-by-Step Implementation
### 1. Define the BundleAggregatorProxy Interface
First, define the minimal ABI or interface for the `BundleAggregatorProxy` contract:
```javascript
const bundleAggregatorProxyABI = [
"function latestBundle() external view returns (bytes)",
"function bundleDecimals() external view returns (uint8[])",
"function latestBundleTimestamp() external view returns (uint256)",
]
```
### 2. Set Up the Provider and Contract Instance
Connect to a blockchain provider and create the contract instance, using environment variables for sensitive information:
```javascript
// Load environment variables (in Node.js)
require("dotenv").config()
const { ethers } = require("ethers")
// Get RPC URL from environment variables
const rpcUrl = process.env.RPC_URL
if (!rpcUrl) {
throw new Error("RPC_URL not found in environment variables")
}
// Connect to a provider securely
const provider = new ethers.providers.JsonRpcProvider(rpcUrl)
// MVR Feed proxy address - replace with the actual address for your feed
// This can also be stored in environment variables for production
const proxyAddress = process.env.MVR_FEED_ADDRESS || "0x..."
// Create contract instance
const mvrFeed = new ethers.Contract(proxyAddress, bundleAggregatorProxyABI, provider)
```
Create a `.env` file in your project root (and add it to `.gitignore`):
```
# .env
RPC_URL=