# Using Data Feeds Onchain (Stellar) Source: https://docs.chain.link/data-feeds/stellar/using-data-feeds-on-chain > For the complete documentation index, see [llms.txt](/llms.txt). Chainlink Data Feeds are the quickest way to connect your smart contracts to the real-world market prices of assets. This guide demonstrates how to deploy a [Soroban](https://soroban.stellar.org/) contract in Rust to the Stellar Testnet and read a price onchain by calling the Chainlink Data Feeds cache contract. To learn how to read price feed data using offchain applications, see the [Using Data Feeds Offchain](/data-feeds/stellar/using-data-feeds-off-chain) guide. To get the full list of available Chainlink Data Feeds on Stellar, see the [Price Feed Contract Addresses](/data-feeds/price-feeds/addresses?network=stellar) page with Stellar selected. ## Available data feeds on Stellar The following table shows all available data feeds on Stellar. Each feed is identified by its `data_id` (the Feed ID), which you pass to the cache contract to read that feed's data. > **DANGER: Select quality data feeds** > > Be aware of the quality of the data that you use. [Learn more about making responsible data quality decisions](/data-feeds/selecting-data-feeds). ## Requirements Make sure you have the [Stellar CLI](https://soroban.stellar.org/docs/reference/cli) installed. You can run stellar --version in your terminal to verify if the CLI is correctly installed. You also need a [Rust toolchain](https://www.rust-lang.org/tools/install) to build the Soroban contract. ## Set up your Stellar testnet account 1. Create a new directory for your project and navigate to it in your terminal: ```bash mkdir stellar-data-feeds && cd stellar-data-feeds ``` 2. Generate a keypair for your testnet account: ```bash stellar keys generate --network testnet my-account ``` Expect an output similar to the following: ```bash Secret key already exists for key my-account ``` 3. Fund your account with testnet XLM using the friendbot faucet: ```bash stellar keys fund my-account --network testnet ``` Expect an output similar to the following: ```bash Funded account with 10000.0000000 XLM ``` ## Create the Soroban contract 1. Initialize a Soroban contract project: ```bash stellar contract init consumer --name consumer ``` This creates a `consumer` directory with a default Soroban contract scaffold. 2. Open the `consumer/contracts/consumer/src/lib.rs` file and replace its contents with the following contract. This contract calls the Chainlink Data Feeds cache contract to read the latest price for a given `data_id` and returns the answer. The cache interface is defined in the [chainlink-stellar](https://github.com/smartcontractkit/chainlink-stellar/tree/main/contracts/common/interfaces/src/data_feeds_cache.rs) repository: ```rust #![no_std] use soroban_sdk::{contract, contractimpl, contractclient, contracterror, contracttype, vec, Address, BytesN, Env, I256, Vec}; #[contractclient(name = "DataFeedsCacheClient")] pub trait DataFeedsCache { fn latest_round(env: Env, data_ids: Vec>) -> Result>, CacheError>; } #[contracttype] #[derive(Clone, Debug)] pub struct RoundData { pub round_id: u64, pub answer: I256, pub timestamp: u64, pub ledger_seq: u32, pub primary: bool, } #[contracterror] #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)] #[repr(u32)] pub enum CacheError { MalformedReport = 100, UnauthorizedCaller = 101, FeedNotConfigured = 102, EmptyConfig = 103, InvalidAddress = 104, InvalidWorkflowName = 105, DuplicatePermission = 106, InvalidDataId = 107, DuplicateFeedConfig = 108, FeedFrozen = 109, NoFeedState = 110, } #[contract] pub struct Consumer; #[contractimpl] impl Consumer { /// Read the latest round for a feed and return its answer. pub fn read_latest_price(env: Env, cache: Address, data_id: BytesN<32>) -> I256 { let client = DataFeedsCacheClient::new(&env, &cache); let rounds = client.latest_round(&vec![&env, data_id]); let round = rounds.get_unchecked(0).unwrap(); round.answer } } ``` This contract calls the cache's `latest_round` function with a vector containing a single `data_id`. The returned `RoundData` contains the `round_id`, `answer`, `timestamp`, `ledger_seq`, and `primary` fields for the feed. The answer is stored at `18` decimal places. ## Build and deploy the contract 1. Build the contract: ```bash stellar contract build ``` Expect an output similar to the following: ```bash Compiling consumer... Finished `release` profile [optimized] target(s) in 5.00s ``` 2. Deploy the contract to the Stellar Testnet: ```bash stellar contract deploy \ --wasm target/wasm32v1-none/release/consumer.wasm \ --source my-account \ --network testnet ``` Expect an output similar to the following: ```bash ``` Note the contract address that is printed. You use it to invoke the contract in the next step. ## Invoke the contract 1. Invoke the `read_latest_price` function on your deployed contract, passing the cache contract address and the `data_id` for the feed you want to read. The cache contract on Stellar Testnet is `CAVLZXJDRGOS6UZ7BHYTYW7STQMZIOCUJIVRMT7JE7T5F6JIA3LPAOVW`, and the BTC/USD `data_id` is `01a0b4d920000332000000000000000000000000000000000000000000000000`. You can find the `data_id` for other assets on the [Price Feed Contract Addresses](/data-feeds/price-feeds/addresses?network=stellar) page with Stellar selected. Because `read_latest_price` is a read-only function, use the `--send=no` flag to simulate the call without submitting a transaction: ```bash stellar contract invoke \ --id \ --source my-account \ --network testnet \ --send=no \ -- read_latest_price \ --cache CAVLZXJDRGOS6UZ7BHYTYW7STQMZIOCUJIVRMT7JE7T5F6JIA3LPAOVW \ --data_id 01a0b4d920000332000000000000000000000000000000000000000000000000 ``` Expect an output similar to the following: ```bash [] ``` Where `` is the latest BTC/USD price for the feed, stored at 18 decimal places. For example, `85965450000000000000000` represents a price of `85965.45`.