Build a production application on Zroarus

Three steps get you from zero to a deployed contract:

1. Add Zroarus Devnet to your wallet (below) or point your tooling at https://rpc.devnet.zroarus.com.
2. Get tZROAR from the faucet to pay for gas. tZROAR has no monetary value.
3. Deploy with Foundry or Hardhat, then verify the source so everyone can read and interact with it here.

import { createPublicClient, defineChain, http } from "viem";

export const zroarusDevnet = defineChain({
  id: 305583,
  name: "Zroarus Devnet",
  nativeCurrency: { name: "Zroarus Devnet Token", symbol: "tZROAR", decimals: 18 },
  rpcUrls: { default: { http: ["https://rpc.devnet.zroarus.com"], webSocket: ["wss://rpc.devnet.zroarus.com/ws"] } },
  blockExplorers: { default: { name: "Zroarus Explorer", url: "https://explorer-devnet.zroarus.com" } },
  testnet: true,
});

const client = createPublicClient({ chain: zroarusDevnet, transport: http() });
console.log(await client.getBlockNumber());

Phorcefield supports Zroarus Devnet natively. For any other EIP-1193 wallet the explorer sends a standard wallet_addEthereumChain request with chain ID 305583 (0x4a9af).

Keep deployer keys in an encrypted keystore or your environment. Never commit them to a repository or paste them into a web page.

# foundry.toml
[rpc_endpoints]
zroarus_devnet = "https://rpc.devnet.zroarus.com"

# Deploy (key from an encrypted keystore, never inline)
forge create src/MyToken.sol:MyToken \
  --rpc-url https://rpc.devnet.zroarus.com \
  --account deployer \
  --broadcast \
  --constructor-args "My Token" MTK

Balances, contract state and logs through standard JSON-RPC. eth_getLogs on the public endpoint spans at most 5,000 blocks per request; page through longer ranges.

import { createPublicClient, http, erc20Abi, formatUnits } from "viem";
import { zroarusDevnet } from "./chain";

const client = createPublicClient({ chain: zroarusDevnet, transport: http() });

const balance = await client.getBalance({ address: "0xYourAddress" });
console.log(formatUnits(balance, 18), "tZROAR");

const [symbol, supply] = await Promise.all([
  client.readContract({ address: "0xToken", abi: erc20Abi, functionName: "symbol" }),
  client.readContract({ address: "0xToken", abi: erc20Abi, functionName: "totalSupply" }),
]);

Zroarus Devnet uses EIP-1559 fees. Sign in the user's wallet in browser apps; server-side, load keys from a secret manager.

import { createWalletClient, custom, parseEther } from "viem";
import { zroarusDevnet } from "./chain";

// Sign in the user's wallet (Phorcefield, MetaMask…). Keys never leave the wallet.
const wallet = createWalletClient({ chain: zroarusDevnet, transport: custom(window.ethereum!) });
const [account] = await wallet.requestAddresses();
await wallet.switchChain({ id: zroarusDevnet.id }).catch(() => wallet.addChain({ chain: zroarusDevnet }));

const hash = await wallet.sendTransaction({ account, to: "0xRecipient", value: parseEther("1") });
console.log("https://explorer-devnet.zroarus.com/tx/" + hash);

The explorer implements the Etherscan verification API at https://explorer-devnet.zroarus.com/api/etherscan, so forge verify-contract and hardhat verify work without plugins. The API key value is not checked; tools just require one. Verification supports Standard JSON input (what Foundry and Hardhat submit) and single-file flattened Solidity, and checks the compiler version, optimizer settings, EVM version, libraries and constructor arguments.

forge verify-contract <ADDRESS> src/MyToken.sol:MyToken \
  --chain-id 305583 \
  --verifier etherscan \
  --verifier-url https://explorer-devnet.zroarus.com/api/etherscan \
  --etherscan-api-key zroarus \
  --constructor-args $(cast abi-encode "constructor(string,string)" "My Token" MTK) \
  --watch

Prefer a form? Open any contract and choose Verify & publish, or go straight to /verify/<address>.

ERC-20 tokens are indexed automatically from their Transfer events: holders, transfers and supply appear on the token page without any registration. Name, symbol and decimals are read from the contract. A symbol is not unique: always identify a token by its contract address.

# balanceOf(address) selector 0x70a08231, address left-padded to 32 bytes
curl -s https://rpc.devnet.zroarus.com -H 'content-type: application/json' -d '{
  "jsonrpc":"2.0","id":1,"method":"eth_call",
  "params":[{"to":"0xToken","data":"0x70a08231000000000000000000000000<address without 0x>"},"latest"]}'

ERC-721 and ERC-1155 collections are indexed from Transfer, TransferSingle and TransferBatch events. Metadata is fetched fromtokenURI/uri (https, ipfs:// and ar:// are supported) and refreshed on ERC-4906 MetadataUpdate events. The explorer treats metadata as untrusted: only known fields are kept as plain text, media is served through a locked-down proxy, and nothing in metadata is ever executed.

Tokens launched through a registered MemeHedge factory are shown with their provenance: creator, launch block, bonding-curve progress and graduation. Provenance is derived only from the factory's own LaunchCreated event, never from a token's name. Graduated tokens link to the ZolaSwap pool that received their liquidity. See the graduations page.

ZolaSwap is a constant-product exchange. Its PairCreated, Swap, Mint, Burn and Sync events share topic hashes with Uniswap V2, but swap(uint256,uint256,address) takes no callback data and each pool has its own fee. The router uses …SVP names for native-asset functions and exposes the wrapped native token as WSVP(). Pools created by the registered factory appear with reserves, trades and volume.

The ZolaSwap suite includes an agent registry (ZolaAgentRegistry) and a user vault (ZolaUserVault) that lets users authorize agents with budgets, trade limits and expiry. Their events (AgentRegistered, AgentAuthorized, AgentSwap…) are decoded when those contracts are in the verified label registry.

A transaction is only presented as agent activity when it comes through a registered agent contract. The explorer does not infer that a bot or contract is an AI agent.