Chainlink Data Feeds are the quickest way to connect your smart contracts to the real-world market prices of assets. For example, one use for data feeds is to enable smart contracts to retrieve the latest pricing data of an asset in a single call.

This guide applies specifically to using data feeds on the Terra network. To get the full list of Chainlink Data Feeds running on the Terra Bombay testnet, see the Terra Feeds page.

Overview

This guide demonstrates the following tasks:

• Write and deploy programs to the Terra Bombay-12 testnet using the Rust language.
• Compile the smart contract using the CosmWasm platform.
• Deploy, instantiate, and execute the contract using a NodeJS script to a call the Wasm artifact and retrieve the latest price.

Requirements

This guide requires the following tools:

• Rust:
  • rustup with cargo 1.44.1+.
  • rustc and cargo 1.44.1+.
  • Install the wasm32-unknown-unknown target for Rust: rustup target add wasm32-unknown-unknown
• NodeJS 14 LTS or later.
• Terra.js
• A C compiler such as the one included in GCC.
• Docker

Confirm that the necessary requirements are installed:

rustc --version
cargo --version
rustup target list --installed
docker --version
node --version

Create and fund a Terra wallet

You need a Terra Station wallet with testnet LUNA to complete the steps in this guide. If you don't already have a Terra wallet, create one to use for this guide.

1. Go to the Terra Station interface.
2. In the Terra Station interface, click Connect and follow the steps to create a new wallet. You can use whatever wallet option you like, but the browser extension is the most simple option.
3. Take note of your seed phrase and your wallet address. You need these to execute your smart contract later.
4. Go to the Terra Testnet Faucet and follow the instructions to send testnet LUNA to your Terra wallet.

After you complete these steps, you can see the LUNA balance for your wallet on the testnet.

Clone the example code repository

Use git clone to clone the example code:

git clone https://github.com/smartcontractkit/chainlink-terra-feeds-demo.git && cd ./chainlink-terra-feeds-demo

Compile the consumer contract

The example data feed consumer contract is in .contracts/consumer.

1. From the base of the cloned repository, run cargo wasm to
   produce the ./target/wasm32-unknown-unknown/release/consumer.wasm build file:

   cargo wasm
   

2. From the base of the cloned repository, run the workspace-optimizer Rust optimizer to ensure the smallest output size and create a reproducible build process. The optimizer runs in a Docker container and creates an /artifacts directory with the compiled and optimized output of the contract:

   docker run --rm -v "$(pwd)":/code \
   --mount type=volume,source="$(basename "$(pwd)")_cache",target=/code/target \
   --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry \
   cosmwasm/workspace-optimizer:0.11.4
   

3. Install the Terra.js package.

   npm install @terra-money/terra.js
   

4. Export your wallet seed phrase to the TERRA_SEED environment variable. The script uses the seed phrase to determine the wallet key that you want to use to deploy and call the smart contract.

   export TERRA_SEED="YOUR SEED PHRASE"
   

5. From the base of the cloned repository, use NodeJS to run the readLatestPrice.mjs to deploy, instantiate, and execute the contract.

   node ./scripts/readLatestPrice.mjs
   

If the script is successful, it prints the current price from the of LUNA/USD feed.

{
  round_data_response: {
    round_id: 39516,
    answer: '3706000000',
    started_at: 1634497952,
    updated_at: 1634497952,
    answered_in_round: 39516
  }
}

If the script is not successful, check to make sure that you compiled the contracts correctly, that your wallet is funded, and that you entered the correct seed phrase. You can also check the Terra Bombay Testnet Status to make sure that the testnet is available.

Review the example code

You can view the Rust code and scripts for this example on GitHub. See the chainlink-terra-feeds-demo repository. The example code has a few main components:

• The contract.rs file that defines the functions for the smart contract and is eventually compiled into the ./artifacts/price_consumer.wasm bytecode file.
• The readLatestPrice.mjs script

The ./scripts/readLatestPrice.mjs script completes each of the steps to deploy, instantiate, and execute the price_consumer.wasm compiled smart contract. The run() function deploys and instantiates the price_consumer.wasm smart contract. Then, the script uses an LCDClient object from Terra.js to call the latest_round_data function on the aggregator contract and retrieve the price data.

async function run() {
  console.log("Deploying Price Consumer Contract");

  const consmCodeId = await upload(CONSUMER_PATH);
  await sleep(12000);
  console.log("instatiating contract");
  const consmAddress = await instantiate(consmCodeId, {"feed": "terra185esv8hg3ddn85fkwgznskf95k0th9ryvegeak"})
  await sleep(12000);
  console.log("reading contract");
  const result = await terra.wasm.contractQuery(consmAddress, { "latest_round_data": {} } )
  console.log(result);
}