ARVEXCHAIN
RH

Docs

ArvexChain documentation

Execution infrastructure across EVM networks: RPC access, inspection, simulation, policy and intent validation, transaction preparation and wallet execution.

Positioning

What ArvexChain is

ArvexChain turns raw blockchain activity into structured, verifiable actions. It is not a Layer 1 and runs no consensus network of its own; it reads from and prepares transactions for existing EVM networks. Robinhood Chain (chain id 4663, native ETH) is the primary network.

Supported networks: Robinhood Chain, Ethereum, Base, Arbitrum One, OP Mainnet, Polygon. Adding a network is a single entry in src/lib/chains.ts plus an RPC environment variable. Robinhood Chain is read through the /api/rpc/4663 relay so browsers on networks that block robinhood.com still reach the chain; the relay only forwards read methods.

Non-custodial

Security model

  • · Never asks for seed phrases or private keys, and never stores them.
  • · Every signature is produced inside the connected wallet (injected / EIP-6963 / WalletConnect).
  • · No automatic signing, approvals or broadcasts. The wallet prompt is only reachable after READ, SIMULATE and POLICY succeed.
  • · Server API keys (Tenderly, Etherscan) stay in server routes; only booleans reach the browser.
  • · All addresses are validated with viem and checksummed before use.

How it works

Simulation

/api/simulate runs eth_call for the outcome and eth_estimateGas for gas, both against the latest block. Revert data is decoded as Error(string), Panic(uint256) or a custom error when an ABI is supplied.

Warnings are generated only from real checks: revert, gas above 3,000,000, zero-address recipient, calldata sent to an address without bytecode, sender balance below value, undecodable selector, and missing sender.

When TENDERLY_* variables are set the route uses the Tenderly Simulation API and falls back to RPC if Tenderly fails.

Deterministic

Policy engine

Every enabled policy is evaluated against the prepared transaction. Any violation returns BLOCKED with the rule, the requested value and the allowed value. Expired policies fail closed.

Recipient rules apply to the transaction target for native transfers and to the beneficiary of ERC-20 transfers and approvals. Contract rules apply when the target holds bytecode. Daily limits use a rolling 24-hour window computed from the local activity log.

Storage is a localStorage repository behind a small Repository interface so PostgreSQL can replace it without touching the engine.

Routes

Modules

  • Console /console

    Build a transaction, run READ → SIMULATE → POLICY, then approve in the wallet. Broadcast is gated on every prior stage succeeding.

  • Explorer /explorer

    Universal search over addresses, transaction hashes and block numbers. Reads come from RPC; recent transactions and verified status from the explorer API.

  • Contract inspector /contracts

    Bytecode, balance, nonce, verified ABI. Read functions execute via eth_call; write functions run the full verification pipeline before the wallet prompt.

  • Simulator /simulate

    eth_call + eth_estimateGas against the chain head (Tenderly when configured). Decodes Error(string), Panic and custom errors from a supplied ABI.

  • Token inspector /tokens

    name / symbol / decimals / totalSupply from the ERC-20 contract, optional balanceOf, and DexScreener market data only when indexed.

  • Pool analyzer /pools

    DexScreener pairs for a token or pair address on the selected network. No placeholder financial data.

  • Wallet activity /wallet

    Balance and nonce from RPC; recent transactions classified as incoming, outgoing, contract interaction, token transfer or failed.

  • Policy engine /policies

    Deterministic rules: value caps, allowed/blocked contracts and recipients, allowed tokens, gas limits, rolling 24h count/value limits, expiration.

  • Agent intents /agents

    Structured JSON intents are validated with zod, resolved against chain state, encoded, simulated and policy-checked. Signing stays with the user.

  • Activity /activity

    Local log of reads, simulations, policy checks and transaction lifecycle events. Stored in localStorage only.

  • Status /status

    Real eth_blockNumber probes from the browser to each RPC endpoint with measured latency, plus server integration configuration.

Environment

Configuration

# RPC overrides (public endpoints are used when empty)
NEXT_PUBLIC_ROBINHOOD_RPC_URL=
NEXT_PUBLIC_ETHEREUM_RPC_URL=
NEXT_PUBLIC_BASE_RPC_URL=
NEXT_PUBLIC_ARBITRUM_RPC_URL=
NEXT_PUBLIC_OPTIMISM_RPC_URL=
NEXT_PUBLIC_POLYGON_RPC_URL=

# Wallet
NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID=

# Server-side integrations (optional)
TENDERLY_ACCESS_KEY= TENDERLY_ACCOUNT= TENDERLY_PROJECT=
ETHERSCAN_API_KEY=            # Etherscan V2 key (Ethereum, Base, Arbitrum, Optimism, Polygon)
BASESCAN_API_KEY= ARBISCAN_API_KEY= OPTIMISTIC_ETHERSCAN_API_KEY= POLYGONSCAN_API_KEY=
DEXSCREENER_API_URL=https://api.dexscreener.com

Without explorer keys, public Blockscout instances and Sourcify are used for recent transactions and verified ABIs. Without any of the optional keys the app still runs; each integration reports its configuration state honestly.