Bitroot Developer Guide

Bitroot is a 100% EVM-compatible chain, which means the Ethereum tooling you already use — wallets, SDKs, contract frameworks — works largely as-is. You just point it at Bitroot's network parameters. This guide covers connecting to the network, deploying and debugging contracts, and using the developer-facing pieces of the three-engine architecture.

1. Overview

A few entry points you'll come back to throughout this guide:

• Block explorer (BRTSCAN): https://devnet.bitroot.co/overview — inspect blocks, transactions, and contract state. It's also the authoritative source for the current RPC URL and Chain ID, since these can change as the network evolves — treat any other copy of these values, including an older version of this page, as potentially stale.
• Testnet faucet: https://devnet.bitroot.co/faucet — claim free testnet BRT for deploying and debugging contracts.
• Bridge: https://bridge.bitroot.co/ — move assets in and out.
• Protocol repository: https://github.com/brt-chain/bitroot — node setup, protocol implementation details, and the exact ABI for AI Agent call interfaces live here.

2. Connecting to the Bitroot network

Bitroot speaks standard JSON-RPC, so any wallet that supports custom EVM networks (MetaMask, Rabby, OKX Wallet, and similar) can add it directly. Using MetaMask as an example:

1. Open MetaMask, click the network selector → "Add network" → "Add a network manually".
2. Open BRTSCAN (https://devnet.bitroot.co/overview); the page header or network info panel lists the current network name, RPC URL, Chain ID, currency symbol, and block explorer URL — copy those values into the MetaMask form as shown.
3. Save and switch to the Bitroot network. Your account balance should show up (0 BRT is expected until you claim testnet tokens from the faucet).

We deliberately don't hardcode an RPC URL or Chain ID on this page — testnet parameters can change between upgrades, and a stale hardcoded value would be more likely to connect you to the wrong network than help you. Always use whatever BRTSCAN currently displays.

3. Getting testnet tokens

Visit the faucet (https://devnet.bitroot.co/faucet) and submit your wallet address to receive testnet BRT for deploying contracts and paying gas. With average gas fees around $0.00007, a small faucet claim typically covers a large number of deployments and calls during development.

4. Smart contract development: reuse the tools you already know

Because Bitroot is 100% EVM compatible, none of the following need an adapter layer — just point the network configuration at Bitroot.

Hardhat (hardhat.config.js):

module.exports = {
  solidity: "0.8.24",
  networks: {
    bitrootTestnet: {
      url: process.env.BITROOT_RPC_URL, // get the current RPC URL from BRTSCAN
      chainId: Number(process.env.BITROOT_CHAIN_ID), // get the current Chain ID from BRTSCAN
      accounts: [process.env.DEPLOYER_PRIVATE_KEY],
    },
  },
};

Foundry (foundry.toml plus an environment variable):

[rpc_endpoints]
bitroot_testnet = "${BITROOT_RPC_URL}"

Deployment works the same as on any other EVM chain:

forge create src/MyContract.sol:MyContract \
  --rpc-url $BITROOT_RPC_URL \
  --private-key $DEPLOYER_PRIVATE_KEY

Remix: in the "Deploy & Run" panel, choose "Injected Provider - MetaMask". As long as MetaMask is connected to Bitroot, compiling, deploying, and calling contracts works exactly as it does against Ethereum mainnet.

5. Interacting with the network from ethers.js / viem

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider(process.env.BITROOT_RPC_URL);
const wallet = new ethers.Wallet(process.env.DEPLOYER_PRIVATE_KEY!, provider);

const balance = await provider.getBalance(wallet.address);
console.log(`Balance: ${ethers.formatEther(balance)} BRT`);

Because the parallelized intelligent execution engine concurrently executes transactions that don't conflict with each other, you can safely fire off a batch of independent transactions (an airdrop, bulk minting) without manually serializing them one confirmation at a time — the network identifies which ones can run in parallel on its own.

6. Block explorer and contract verification

Once a contract is deployed, verify its source on BRTSCAN so you and other users can inspect its behavior and call read-only methods directly from the explorer during debugging. Follow the verification flow and required fields as shown on the BRTSCAN page itself.

7. Using the AI-native EVM

The biggest difference between Bitroot and a plain EVM chain is the built-in AI Agent call interface: a smart contract can invoke AI model inference directly, without a separate oracle or off-chain relay. This surface is still evolving quickly, so the exact contract interface, precompile addresses, and ABI live in the protocol repository (https://github.com/brt-chain/bitroot) — we won't duplicate a signature here that could go stale. Conceptually, think of it as an "AI inference precompile" you can call directly from Solidity; the input and output are recorded through the zero-knowledge verifiable auditing layer, so the inference result can be verified by an on-chain or off-chain third party without exposing the underlying model weights.

8. Security and best practices

• Key management: a plaintext .env file is fine for testnet debugging, but production deployments should use a hardware wallet or an MPC-based custody setup — never hardcode a private key into a repository.
• Contract audits: the zero-knowledge verifiable auditing layer doesn't replace an audit of your own contract logic. It verifies that a computation and its result are trustworthy — it can't tell you whether your business logic has a bug.
• Gas estimation: gas fees are far lower than Ethereum mainnet, but batch operations in production still deserve a gas estimate pass so a too-low per-transaction gas limit doesn't cause partial failures.
• Network parameter checks: validate the Chain ID at runtime (compare against provider.getNetwork()) so a typo in a config file doesn't silently point your deployment at the wrong chain.

9. FAQ

Can an existing Ethereum contract be deployed to Bitroot as-is? In most cases, yes — as long as the contract doesn't assume Ethereum-specific precompile addresses, standard Solidity contracts compile and deploy without code changes.

Do testnet and mainnet share the same network parameters? No. Always confirm on BRTSCAN which environment you're targeting — RPC URL and Chain ID differ between testnet and any future mainnet.

Is there an extra fee for calling the AI-native EVM module? The exact fee model is defined in the protocol repository and official announcements; this page doesn't make a commitment either way.

10. Resources

If you run into something this guide doesn't cover, reach out via the Media Contact page or our community channels.