# Arbitrum

This guide walks you through consuming Kaiko's Reference Rates on Arbitrum. Several asset pairs are publicly available, meaning you can access free hourly updates or update on-demand by covering the gas fee.

## Read and update manually

Visit [onchain.kaiko.com](http://onchain.kaiko.com/). Here, you can see the latest Kaiko price updates for all pairs.

**To update the price:** 

1. Click "connect wallet"
2. Once you've connected your wallet, click "Update"
3. Authorize the gas payment of 0.00000112 ETH 
4. Wait a few seconds for the prices to be updated

## Update and read on-chain

To read and update on-chain, you'll need to set up an off-chain listening event using a node provider of your choice to connect to the blockchain.

#### To update the price:

This example script uses Typescript, but you can produce similar results using other coding languages. Running the script requests a price update and listens until it's been updated on-chain. When the update is detected, it alerts your on-chain smart contract.

1. Install ethers `npm install ethers`
2. Send a gas fee with a value of 0.00000112 ETH to the `refreshPriceFeeds` contract address `0xff2743c44f820c64c94eccfc1b497a1019541097`

{% code overflow="wrap" %}

```typescript
import { ethers } from 'ethers';

// Set up your Ethereum provider
const provider = new ethers.providers.JsonRpcProvider("<YOUR_PROVIDER_URL>");

// Initialize wallet using private key and connect it to the provider
const wallet = new ethers.Wallet("<YOUR_PRIVATE_KEY>", provider);

// Smart contract address
const contractAddress = "0xff2743c44f820c64c94eccfc1b497a1019541097";

// ABI definition of the contract's refreshPriceFeeds method
const abi = [
    "function refreshPriceFeeds() payable external"
];

// Create an instance of the contract
const contract = new ethers.Contract(contractAddress, abi, wallet);

async function refreshPriceFeeds() {
    try {
        // Define the amount of ETH to send (0.00000112 ETH)
        const amountToSend = ethers.utils.parseEther("0.00000112");

        // Call the refreshPriceFeeds function, sending 0.00000112 ETH
        const tx = await contract.refreshPriceFeeds({
            value: amountToSend // Send 0.00000112 ETH
        });

        // Wait for the transaction to be mined
        console.log("Transaction sent. Waiting for confirmation...");
        const receipt = await tx.wait();

        console.log("Transaction confirmed, receipt:", receipt);
    } catch (error) {
        console.error("Error while calling refreshPriceFeeds:", error);
    }
}

// Call the function
refreshPriceFeeds();
```

{% endcode %}

3. Wait for at least one block for the price update to be reflected on-chain

#### **Read the price on-chain:**

This Solidity contract example is triggered by the `refreshPriceFeeds` function in the Typescript example above. When triggered, it ingests the updated prices on-chain.

{% code overflow="wrap" %}

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IExternalContract {
    function latestUpdate() external view returns (uint256 price, uint256 decimals, uint256 updatedAt);
}

contract CallLatestUpdate {
    address public externalContractAddress = <PRICE_CONTRACT_ADDRESS>;

    // Function to call the latestUpdate() function on the external contract
    function getLatestUpdate() public view returns (uint256 price, uint256 decimals, uint256 updatedAt) {
        // Create an instance of the external contract using the interface
        IExternalContract externalContract = IExternalContract(externalContractAddress);
        
        // Call the latestUpdate() function on the external contract
        return externalContract.latestUpdate();
    }
}
```

{% endcode %}

{% hint style="warning" %}
Although one price update refreshes all prices on-chain, you must read each price feed individually. See the price feeds and their corresponding addresses at [onchain.kaiko.com](https://onchain.kaiko.com/).\
\ <img src="/files/8wQeSrVRgVqvPC63XyUN" alt="" data-size="original">
{% endhint %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.kaiko.com/on-chain/kaiko-data/kaiko-reference-rates/data-on-ramp/arbitrum.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.