Fetching Data

Read smart contract state on peaq using JavaScript or Remix. Covers EVM storage slots, public getters, mappings, and off-chain calls without gas fees.

Reading a peaq contract’s state costs no gas when you call it off chain. This guide covers how EVM storage is laid out, how to expose state variables, and how to read them from JavaScript or Remix.

Prerequisites

• Solidity basics.
• A contract deployed on peaq, or the means to deploy one.
• The contract ABI, which your Solidity compiler generates.
• A client library such as ethers.js or web3.js, or any other JSON-RPC client.

Instructions

1. EVM contract storage

Each contract on peaq has its own storage, split into slots of 256 bits:

• State variables occupy one or more slots.
• A mapping value lives at a slot derived from the hash of its key.
• Arrays follow their own packing rules.

Reads are cheaper than writes. An eth_call is not a transaction, so the caller pays nothing. A view function called from inside a transaction still costs gas.

2. Declare and store data

This contract keeps a number and a mapping of balances:

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

contract SimpleStorage {
    uint256 public storedValue;
    mapping(address => uint256) public balances;

    constructor(uint256 initialValue) {
        storedValue = initialValue;
        balances[msg.sender] = 100;
    }

    // A simple setter function
    function setValue(uint256 newValue) external {
        storedValue = newValue;
    }

    // A simple function that updates balances
    function updateBalance(address account, uint256 amount) external {
        balances[account] = amount;
    }
}

• storedValue is a public uint256. By making it public, Solidity automatically creates a getter function storedValue() that returns the value.
• balances is a public mapping from address to uint256. Likewise, balances(address) becomes a getter function to read the balance for any given address.

3. Read the data

With ethers.js

import { ethers } from 'ethers';

// 1. Connect to peaq
const provider = new ethers.JsonRpcProvider("https://quicknode1.peaq.xyz");

// 2. Define the contract ABI (simplified for this example)
const abi = [
  "function storedValue() view returns (uint256)",
  "function balances(address) view returns (uint256)"
];

// 3. The deployed contract address
const contractAddress = "0xYourContractAddressOnPeaq";

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

async function readData() {
  try {
    // 5. Call the view functions
    const value = await contract.storedValue();
    console.log("storedValue:", value.toString());

    const someAddress = "0x1234..."; // Replace with a valid address
    const balance = await contract.balances(someAddress);
    console.log(`Balance of ${someAddress}:`, balance.toString());
  } catch (error) {
    console.error("Error fetching data:", error);
  }
}

readData();

storedValue() and balances(address) are view functions, so reading them sends no transaction and costs no gas.

Using Remix

1. Load your contract in Remix and compile it.
2. In the “Deploy & run transactions” panel, connect to a peaq endpoint and deploy.
3. Click storedValue to read the current value, or pass an address to balances to read that entry of the mapping.

4. Fetch structs and nested mappings

Solidity generates getters for public structs and nested mappings, but the mapping below is private, so it needs a getter you write yourself. For example:

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

contract ComplexStorage {
    struct User {
        uint256 id;
        uint256 balance;
        address userAddress;
    }

    mapping(address => User) private users;

    // Insert or update user
    function setUser(address _address, uint256 _id, uint256 _balance) external {
        users[_address] = User(_id, _balance, _address);
    }

    // Public function to read user data
    function getUser(address _address) external view returns (uint256, uint256, address) {
        User memory user = users[_address];
        return (user.id, user.balance, user.userAddress);
    }
}

The User struct lives in a private mapping, and getUser returns its fields in a single call. Read it from JavaScript the same way:

const contractAbi = [
  "function getUser(address _address) view returns (uint256, uint256, address)"
];

const contract = new ethers.Contract(contractAddress, contractAbi, provider);

const someUserAddress = "0xYourUserAddress"; // Replace with the user address to query
const userData = await contract.getUser(someUserAddress);
console.log("User Data => ID:", userData[0].toString(), 
            "Balance:", userData[1].toString(), 
            "User Address:", userData[2]);

private keeps other contracts and the generated ABI out of users, but it hides nothing: all contract storage is readable straight from the chain with eth_getStorageAt. Never put a secret in a contract.