# Overview
Bracle Network is a Decentralized Oracle Network and Data Market built for Bitcoin and the broader blockchain ecosystem that delivers frequently updated, reliable, and diverse data feeds for DApps and smart contracts on blockchains. At the same time, it will also bring considerable profit returns to data providers. Bracle price feeds are permissionless and do not require a subscription or API key -- developers can complete the whole process in a few minutes.
Bracle Network offers several services for users:
* **Price Feeds**: Bracle Price feeds continuously stream price updates to blockchains, with each feed stored within a smart contract. Application developers can easily pass these contracts on their own, then deserialize the data to read the current feed value.
* **Active Validation Service**: By leveraging the security and liquidity of Bitcoin for proactive verification of data services, it addresses trust issues that may exist with traditional centralized oracles.
* **Data Availability Services**: Enhancing the accessibility and reliability of data, ensuring that data consumers can still obtain the required data even in conditions of network instability or partial node failure.
* **The Restake service for Bitcoin LSD assets**: Provides returns for stakers by restaking Bitcoin LSD assets.
### Data Flow
The price feeds come from multiple sources such as off-chain CEX'ed (Binance, OKX, Coinbase & Kraken, etc.), on-chain DEX'es (Uniswap, Curve, etc.) and aggregators (CoinmarketCap, Coingecko). Currently, we've got more than 20+ sources integrated.
The data is aggregated in independent nodes operated by data providers using various methodologies (eg. median, TWAP, LWAP) and safety measures like outliers detection. The cleaned and processed data is then signed by node operators underwriting the quality.
The feeds are broadcast directly to Bracle Network Validator Node, which could be easily spun off on demand.
The data could be pushed on-chain either by a dedicated relayer operating under predefined conditions (ie. heartbeat or price deviation), by a bot (ie. performing liquidations), or even by end users interacting with the protocol.
Inside the on-chain protocol, the data is unpacked and verified cryptographically checking both the origin and timestamps.
### Price Feeds
Bracle Price feeds continuously stream price updates to blockchains, with each feed stored within a smart contract. Application developers can easily pass these contracts to their own, then deserialize the data to read the current feed value. For integration instructions, please see "How to Use."Bracle Price Feeds also offer a "pull" model for price updates, where users are responsible for posting updates to the chain as needed. For more information on this model and its implications for integrators, refer to "Pull Updates."In the pull model, developers should integrate Bracle into both their on-chain and off-chain code:
* On-chain programs should read prices from the Bracle program deployed on the same chain.
* Off-chain frontends and jobs should include Bracle price updates within or alongside their application-specific transactions.
Bracle provides ecosystem-specific SDKs to assist with the integration process, both on-chain and off-chain. The simplest way to utilize Bracle price feeds is to integrate the relevant SDKs into your application.Before starting with an SDK, it's recommended to read "Best Practices" to understand how Bracle price feeds are structured and to learn the best practices for using Bracle prices safely and correctly.
**Relative Link**：
* Website:
* Twitter:
* Discord:
* Telegram:
# Introduction
Bracle Price feeds continuously stream price updates to blockchains, with each feed stored within a smart contract. Application developers can easily pass these contracts on their own, then deserialize the data to read the current feed value. For integration instructions, please see "How to Use."Bracle Price Feeds also offer a "pull" model for price updates, where users are responsible for posting updates to the chain as needed. For more information on this model and its implications for integrators, refer to "Pull Updates."In the pull model, developers should integrate Bracle into both their on-chain and off-chain code:
* On-chain programs should read prices from the Bracle program deployed on the same chain.
* Off-chain frontends and jobs should include Bracle price updates within or alongside their application-specific transactions.
Bracle provides ecosystem-specific SDKs to assist with the integration process, both on-chain and off-chain. The simplest way to utilize Bracle price feeds is to integrate the relevant SDKs into your application.Before starting with an SDK, it's recommended to read "Best Practices" to understand how Bracle price feeds are structured and to learn the best practices for using Bracle prices safely and correctly.
# How it work?
The price feeds come from multiple sources such as off-chain CEX'ed (Binance, OKX, Coinbase & Kraken, etc.), on-chain DEX'es (Uniswap, Curve, etc.) and aggregators (CoinmarketCap, Coingecko). Currently, we've got more than 20+ sources integrated. The data is aggregated in independent nodes operated by data providers using various methodologies (eg. median, TWAP, LWAP) and safety measures like outliers detection. The cleaned and processed data is then signed by node operators underwriting the quality. The feeds are broadcast directly to Bracle Network Validator Node, which could be easily spun off on demand. The data could be pushed on-chain either by a dedicated relayer operating under predefined conditions (ie. heartbeat or price deviation), by a bot (ie. performing liquidations), or even by end users interacting with the protocol. Inside the on-chain protocol, the data is unpacked and verified cryptographically checking both the origin and timestamps.
### Data Format
At a top level, transferring data to a Blockchain VM environment requires packing an extra payload to a user's transaction and processing the message on-chain.
#### Data packing (off-chain data encoding)
1. Relevant data needs to be fetched from the decentralized cache layer, powered by Bracle Network light cache nodes
2. Data is packed into a message according to the following structure
3. The package is appended to the original transaction message, signed and submitted to the network
*All of the steps are executed automatically by ContractProxy and transparent to the end-user*
#### Data unpacking (on-chain data verification)
1. The appended data packages are extracted from the `msg.data`
2. For each data package we:
1. Verify if the signature was created by a trusted provider
2. Validate the timestamp, checking if the information is not obsolete
3. Then, for each requested data feed we:
1. Calculate the number of received unique signers
2. Extract value for each unique signer
3. Calculate the aggregated value (median by default)
*This logic is executed in the on-chain environment and we optimised the execution using a low-level assembly code to reduce gas consumption to the absolute minimum*
### On-chain aggregation
To increase the security of the Bracle oracle system, we've created the on-chain aggregation mechanism. This mechanism adds an additional requirement of passing at least X signatures from different authorised data providers for a given data feed. The values of different providers are then aggregated before returning to a consumer contract (by default, we use median value calculation for aggregation). This way, even if some small subset of providers corrupt (e.g. 2 of 10), it should not significantly affect the aggregated value.
# How to use?
# Use Data Feed On-chain
### Reading data feeds on-chain
To consume price data, your smart contract should reference `IAggregator.sol`, which defines the external functions implemented by Data Feeds.
`IAggregator.sol`
```solidity
// SPDX-License-Identifier: LGPL-3.0
pragma solidity 0.8.20;
interface IAggregator {
/**
* @notice median from the most recent report
*/
function latestAnswer() external view returns (int256);
/**
* @notice timestamp of block in which last report was transmitted
*/
function latestTimestamp() external view returns (uint256);
/**
* @notice Aggregator round (NOT OCR round) in which last report was transmitted
*/
function latestRound() external view returns (uint256);
/**
* @notice median of report from given aggregator round (NOT OCR round)
* @param _roundId the aggregator round of the target report
*/
function getAnswer(uint256 _roundId) external view returns (int256);
/**
* @notice timestamp of block in which report from given aggregator round was transmitted
* @param _roundId aggregator round (NOT OCR round) of target report
*/
function getTimestamp(uint256 _roundId) external view returns (uint256);
/**
* @return answers are stored in fixed-point format, with this many digits of precision
*/
function decimals() external view returns (uint8);
/**
* @notice human-readable description of observable this contract is reporting on
*/
function description() external view returns (string memory);
/**
* @notice aggregator contract version
*/
function version() external view returns (uint256);
/**
* @notice details for the given aggregator round
* @param _roundId target aggregator round (NOT OCR round). Must fit in uint32
* @return roundId _roundId
* @return answer median of report from given _roundId
* @return startedAt timestamp of block in which report from given _roundId was transmitted
* @return updatedAt timestamp of block in which report from given _roundId was transmitted
* @return answeredInRound _roundId
*/
function getRoundData(
uint80 _roundId
) external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
/**
* @notice aggregator details for the most recently transmitted report
* @return roundId aggregator round of latest report (NOT OCR round)
* @return answer median of latest report
* @return startedAt timestamp of block containing latest report
* @return updatedAt timestamp of block containing latest report
* @return answeredInRound aggregator round of latest report
*/
function latestRoundData()
external
view
returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}
```
### Example
```solidity
// SPDX-License-Identifier: LGPL-3.0
pragma solidity 0.8.20;
import {IAggregator} from "../interfaces/IAggregator.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 DataConsumer {
IAggregator internal dataFeed;
/**
* Network: ArbitrumSepolia
* Aggregator: ETH/USD
* Address: 0xbF13EE58Bf62500FE87e7389faB633ff95dec029
*/
constructor() {
dataFeed = IAggregator(
0xbF13EE58Bf62500FE87e7389faB633ff95dec029
);
}
/**
* Returns the latest answer.
*/
function getBracleDataFeedLatestAnswer() public view returns (int) {
// prettier-ignore
(
/* uint80 roundID */,
int answer,
/*uint startedAt*/,
/*uint timeStamp*/,
/*uint80 answeredInRound*/
) = dataFeed.latestRoundData();
return answer;
}
}
```
# Use Data Feed Off-chain
### Javascript
This example uses ethers.js to retrieve feed data from the ETH / USD feed on the ArbitrumSepolia testnet.
```javascript
/**
* THIS IS EXAMPLE CODE THAT USES HARDCODED VALUES FOR CLARITY.
* THIS IS EXAMPLE CODE THAT USES UN-AUDITED CODE.
* DO NOT USE THIS CODE IN PRODUCTION.
*/
const { ethers } = require("ethers") // for nodejs only
const provider = new ethers.providers.JsonRpcProvider("https://endpoints.omniatech.io/v1/arbitrum/sepolia/public")
const aggregatorABI = [
{
inputs: [],
name: "decimals",
outputs: [{ internalType: "uint8", name: "", type: "uint8" }],
stateMutability: "view",
type: "function",
},
{
inputs: [],
name: "description",
outputs: [{ internalType: "string", name: "", type: "string" }],
stateMutability: "view",
type: "function",
},
{
inputs: [{ internalType: "uint80", name: "_roundId", type: "uint80" }],
name: "getRoundData",
outputs: [
{ internalType: "uint80", name: "roundId", type: "uint80" },
{ internalType: "int256", name: "answer", type: "int256" },
{ internalType: "uint256", name: "startedAt", type: "uint256" },
{ internalType: "uint256", name: "updatedAt", type: "uint256" },
{ internalType: "uint80", name: "answeredInRound", type: "uint80" },
],
stateMutability: "view",
type: "function",
},
{
inputs: [],
name: "latestRoundData",
outputs: [
{ internalType: "uint80", name: "roundId", type: "uint80" },
{ internalType: "int256", name: "answer", type: "int256" },
{ internalType: "uint256", name: "startedAt", type: "uint256" },
{ internalType: "uint256", name: "updatedAt", type: "uint256" },
{ internalType: "uint80", name: "answeredInRound", type: "uint80" },
],
stateMutability: "view",
type: "function",
},
{
inputs: [],
name: "version",
outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
stateMutability: "view",
type: "function",
},
]
const addr = "0xbF13EE58Bf62500FE87e7389faB633ff95dec029"
const priceFeed = new ethers.Contract(addr, aggregatorABI, provider)
priceFeed.latestRoundData().then((roundData) => {
// Do something with roundData
console.log("Latest Round Data", roundData)
})
```
# Become a data provider
Data providers can get started publishing data to the Bracle Network by performing the following steps.
### Request access
First, contact the Bracle Data Association and request to become a data provider. You can reach out on Discord or Telegram. Only data providers with first-party data (exchanges, market makers, and trading firms) are allowed to participate in the network.
### Generate keypair
Every data provider is identified on the network by a public key, and their prices are signed by the corresponding private key. You will need a public/private key pair for this purpose. If you do not already have a keypair, you can create one using the instructions below:
```Bash
$ ssh-keygen -t rsa -C "your email
```
This command will create a public/private keypair in the `id_rsa` file. Please extract the public key from this file and share it with the Bracle Data Association so they can enable you to publish prices.
### Procure validators
Every data provider to the network will require connecting a Bracle Network Validator. The Bracle Data Association will assist you with this step.
### Bracle Data Publisher
Data providers can publish data to the network using the Bracle Data Publisher software package. This package abstracts away all of the communication with the underlying blockchain and exposes a simple JSON RPC interface for submitting price data. Please see the README of that package for instructions on using it. This software requires you to configure both the keypair and validators from the previous steps in order to run. Please also see the JSON RPC API documentation. Finally, the example publisher is a fully-worked example of how to integrate with the Bracle Data Publisher API.
# Pull Model
Bracle Network will offer a data Pull Model in the future to support more on-chain application scenarios. Unlike the traditional blockchain oracle data Push model, the data Pull model will have the following characteristics:
* **Gas efficiency** -- On-chain prices are only updated when they are needed. In the push model, the oracle can waste gas by submitting price updates that no one will use. Furthermore, the cost of updating the oracle is distributed amongst its users instead of borne entirely by Bracle Network. The cost of maintaining the on-chain prices can be substantial for a single entity, but is minimal when spread across all users. Many of the subsequent advantages follow from the fact that Bracle Network does not have to pay gas fees for every single update.
* **High update frequency** -- Bracle Network price feeds update once per second, which is faster than the blocktime of most blockchains. Such frequent updates would not be possible if every price had to be pushed on-chain. However, push oracles typically update even less frequently than the blocktime, because it is simply too expensive to update feeds more frequently.
* **Low latency** -- Every transaction can use a recent off-chain price, instead of relying on the last on-chain update pushed by the oracle itself.
* **More price feeds** -- Bracle Network can scale to thousands of price feeds due to its gas efficiency. The oracle incurs no added costs for each additional feed, and users pay gas costs for new feeds only when those feeds are used on-chain.
* **Reliable in volatile conditions** -- Push oracles can fail to land price updates in volatile market conditions. In these conditions, the oracle competes with other more valuable transactions (such as DEX trades or liquidations) for bandwidth, and often cannot pay enough to land price updates. This problem does not occur in the pull model, as Bracle price updates are incorporated into the valuable transactions themselves.
* **Common infrastructure** -- Every component of Bracle Network is *shared across blockchains* except for the contract deployed on the destination chain. These shared components can therefore be built with high reliability and accuracy targets, benefitting every chain the oracle is deployed on. This approach also allows Bracle Network to rapidly launch on new blockchains and ecosystems with all of the existing price feeds.
* **Sustainable** -- The Bracle Network protocol has been designed to allow for the optional enablement of data fees to update the state of an on-chain price feed. These fees will compensate data providers for their effort and motivates them to contribute additional data. Oracles without such a mechanism are inherently unsustainable and likely to fail if the operating organization runs out of money.
# Active Validation Service
The Active Validation Service (AVS) is a core feature within the Bracle Network, designed to ensure the accuracy and reliability of data across the network. It enhances data security and provides a more reliable data source for decentralized applications (DApps) and smart contracts by actively validating data services using the security and liquidity of Bitcoin.\
Bracle Network has partnered with **BabylonChain** to jointly develop a higher-quality Active Validation Service (AVS).\
AVS aims to address the trust issues associated with traditional centralized oracles and the challenges of validation efficiency and cost faced by other decentralized oracles. It seeks to improve the overall performance and reliability of the Bracle Network through:
* Enhancing the decentralization of data validation: Utilizing the collective verification of network participants to ensure the authenticity and accuracy of data sources.
* Increasing efficiency and reducing the cost of data processing: Optimizing the verification process through smart contracts and specific validation algorithms to reduce unnecessary computational and transaction costs.
* Boosting network security: Increasing potential attackers' cost of attacks and enhancing the network's overall security level by actively validating data services using Bitcoin's security and liquidity.
### **Operating Mechanism**
AVS operates through the following key steps:
1. **Data Submission:** Data providers must sign their data before submitting it to the Bracle Network, proving the authenticity of its source.
2. **Validation Request:** Upon data submission, AVS automatically triggers a validation request, inviting verification nodes in the network to participate in the data validation process.
3. **Random Selection of Verification Nodes:** To prevent potential collusion and ensure the fairness of the validation process, AVS uses an algorithm to randomly select a certain number of verification nodes for each verification.
4. **Execution of Verification:** The selected verification nodes validate the data according to predefined rules and algorithms, including cross-verifying data sources, checking the validity of data signatures, and comparing them with known, trusted data sources.
5. **Result Aggregation:** All participating nodes submit their verification results to a smart contract, which aggregates the results according to certain logic (e.g., majority voting) to decide whether the network accepts the data.
6. **Rewards and Penalties:** Nodes that successfully participate in the verification and whose votes are consistent with the final outcome receive token rewards. Nodes that submit incorrect data or validations may face penalties, including the loss of staked tokens.
### **Features of AVS**
* **Decentralization and Autonomy:** AVS's design allows the network to autonomously complete the data validation process in a decentralized manner, without relying on any centralized third party.
* **Flexibility and Scalability:** With smart contracts and a dynamically adjustable verification mechanism, AVS can flexibly meet various types of data validation needs and scale as the network grows.
* **Transparency and Fairness:** The validation process and results are recorded on the blockchain, available for review by all network participants, ensuring process transparency and result fairness.
\
By implementing AVS, the Bracle Network aims to build a more secure, reliable, and decentralized data validation and oracle service, providing robust data support for applications within the blockchain ecosystem.
# Data Availability Service
The Data Availability Services (DAS) is a key component of the Bracle Network, designed to ensure the high availability and transparency of network data. This is crucial for decentralized applications (DApps) and smart contracts, as they require real-time access to accurate and trustworthy data to function correctly. DAS aims to enhance the accessibility and reliability of data, ensuring that data consumers can still access the data they need, even in conditions of network instability or partial node failure. This not only improves the network's robustness but also guarantees the continuous operation of decentralized applications based on the Bracle Network and the integrity of their data.
### **Operating Mechanism**
DAS employs a series of technologies and strategies to ensure data availability, including:
* **Data Redundancy Storage:** To prevent data loss, DAS redundantly stores data across multiple nodes in the network. This way, even if some nodes encounter issues, other nodes can still provide the required data.
* **Data Sharding Technology:** By sharding data and storing it in different parts of the network, DAS can enhance the efficiency of data processing and quickly reassemble complete data information when needed.
* **Incentive Mechanisms:** DAS provides incentives for nodes that participate in data storage and offer data availability services, encouraging more nodes to join in the storage and maintenance of data, thereby improving the network's data availability.
* **Real-time Data Monitoring and Verification:** DAS has implemented a system for real-time data monitoring and verification to ensure that the data stored on the network is always up-to-date and has not been tampered with.
### **Features of DAS**
* **Decentralization:** By distributing data storage across the network, DAS ensures the decentralization of data storage, avoiding the risks and single points of failure associated with centralized storage.
* **Data Integrity and Security:** DAS focuses not only on data availability but also ensures data integrity and security through encryption and verification mechanisms, preventing data from being tampered with during transmission or storage.
* **Transparency:** All data storage and access records are conducted on the blockchain, ensuring the transparency and traceability of the process.
\
Through these features and mechanisms, DAS aims to build a more secure, efficient, and reliable data ecosystem, providing strong support for the operation of decentralized applications and the wider blockchain ecosystem.
# BTC LSD Restaking
BTC LSD Staking is a key mechanism aimed at introducing a new level of cryptographic economic security to the Bracle Network and establishing a secure token economy lending market. This is achieved through a security service layer built on token staking and a reward-penalty system, offering secure proactive verification services for a broad array of upper-layer decentralized applications.BTC LSD Staking offers a system for Bracle ecosystem participants to earn BOC Token rewards by staking BOC Tokens and LSD tokens. By leveraging the LSD Staking mechanism, it enables Bracle oracle services to fully utilize the token economic security capabilities already prevalent in the Bitcoin ecosystem. Moreover, it aims to establish a secure, healthy, and sustainable economic ecology for the Bracle Network.
This mechanism allows Restake Node operators to undertake security validation tasks, thereby providing decentralized verification services with a level of security comparable to the Bitcoin network. Through this staking mechanism, the goals are to:
* Enhance the network's decentralization and security by leveraging the vast and secure infrastructure of Bitcoin.
* Provide returns for stakers, encouraging more capital to participate in the Bracle Network.
* Create a healthy economic cycle to promote the network's stability and long-term development.
### **Operating Mechanism**
* **Staking and Rewards:** Participants can stake their Bitcoin LSD assets into a designated smart contract. The staked assets are used for the network's security guarantee and data verification process. Participants receive token rewards based on the duration and amount of their stake.
* **Security Verification:** The staked assets are managed by Restake Nodes (operators), which are responsible for data verification and network maintenance tasks. Collective staking of assets increases the cost of attacking the network, thus enhancing the overall security of the network.
* **Earnings Distribution:** Profits from the Restake service are distributed to participants based on the amount of assets staked and the duration of participation. This distribution mechanism is designed to incentivize long-term holding and participation in network maintenance, while ensuring fair distribution of earnings.
### **Rewards:**
$BOC rewards accrued daily based on formula below:\
For more information about the $BOC rewards mechanism, please refer to BOC Tokenomics
You can staking your BTC LSD Assets at ————————————
The Bitcoin LSD (Liquid Sidechain Derived) assets currently supported include:
* Babylon Chain BTC
* Bouncebit BTC
* etc
# Price Feed Contract Addresses
### BounceBit Testnet
