AERE Network, Developer Documentation

Quickstart

Connect to AERE and read the chain in five minutes. Sending a transaction needs a funded address, and there is no public way to get one today. Read the notice below before you start.

# 1. Add the network to MetaMask
Network name:    AERE Network
RPC URL:         https://rpc.aere.network
Chain ID:        2800
Currency symbol: AERE
Block explorer:  https://explorer.aere.network

# 2. Read the chain, works with an unfunded address (ethers v6)
const provider = new ethers.JsonRpcProvider('https://rpc.aere.network');
console.log(await provider.getBlockNumber());
console.log(await provider.getBalance('0xYour…'));

# 3. Send a tx, REQUIRES a funded address
#    No public source of mainnet AERE before listing. This step will
#    fail with "insufficient funds" on a new address; test it on 28001.
const wallet = new ethers.Wallet(privateKey, provider);
await wallet.sendTransaction({ to: recipient, value: ethers.parseEther('0.01') });

SDK · @aere/sdk

Official TypeScript SDK wrapping ethers v6 with typed contract clients for every deployed AERE L1 contract. Designed for consumer neobank backends.

# @aere/sdk is not yet on public npm, install from the public source:
npm i git+https://git.aere.network/aere-network/sdk-js.git ethers

import { AereClient } from '@aere/sdk';
import { ethers } from 'ethers';

const aere = new AereClient({ privateKey: process.env.OPS_PRIVATE_KEY });

// Multi-asset balance for any user
const p = await aere.getPortfolio('0xUser…');
console.log(ethers.formatEther(p.aere), 'AERE');
console.log(ethers.formatEther(p.waere), 'WAERE');

// Lock 100 AERE for 90 days. The tier-1 rate is 15% APY on-chain,
// but the AereLockedStaking reward pool is UNFUNDED (balance 0),
// so no yield can be paid on maturity today. See #contracts.
await aere.staking.lockTier90(ethers.parseEther('100'));

// Write KYC attestation on-chain
const oneYear = Math.floor(Date.now() / 1000) + 365 * 86400;
await aere.identity.addClaim(userAddr, 'kyc-tier-1', reportHash, oneYear);

// Watch for incoming AERE deposits, for a neobank webhook
const stop = await aere.watchTransfersTo(userAddr, tx => {
  console.log(\`+\${ethers.formatEther(tx.value)} AERE in \${tx.hash}\`);
});

Source + types on git.aere.network at git.aere.network/aere-network/sdk-js (gitea mirror: git.aere.network/aere-network/sdk-js). Wraps: staking, locked staking, governance, identity, bridge, swap, faucet, NFT marketplace, mining subscription. Full address book bundled, no manual constants.

Neobank reference backend

The integration pattern for a neobank backend on AERE: signup, KYC attestation, multi-asset portfolio, on-chain savings, deposit-watching webhook. No reference server is published for it today (the public repositories are listed at the foot of this page); the routes below describe the pattern, built with the SDK above.

OPS_PRIVATE_KEY=0x… npm run dev
# Server on :4400 with routes:
#   POST /signup
#   POST /webhooks/baas/kyc-cleared       → writes AereIdentity claim on-chain
#   GET  /users/:id/portfolio              → AERE + WAERE balances
#   POST /users/:id/earn                   → returns tx instructions for client to sign
#   POST /webhooks/onramp/deposit          → MoonPay/Transak callback
#   Live block watcher                     → fires on user deposits

KYC attestation pattern

Two layers of KYC, independent:

• Fiat KYC, performed by your BaaS provider (Striga / Dipocket / Modulr / etc) on signup. Returns a verified status + report hash via webhook.
• On-chain attestation, the neobank backend writes the cleared status to AereIdentity against the user's AERE wallet. Smart contracts gate features (lending, higher limits, fiat off-ramp) by checking hasValidClaim(user, 'kyc-tier-1', kycOpsAddress).

// In the kyc-cleared webhook handler
await aere.identity.addClaim(
  userAereAddress,
  'kyc-tier-1',
  reportHash,                                     // keccak256 of BaaS report
  Math.floor(Date.now()/1000) + 365 * 86400,      // expires in 1 year
);

Wallet provisioning

AERE is non-custodial. Don't ask consumers to manage seed phrases, use one of:

• Privy, email/social login, MPC + email recovery, ~1 day to integrate. Recommended.
• Magic.link, similar pattern, slightly different recovery model.
• Web3Auth, open-source, more configuration knobs.

Each provisions an EVM wallet keyed to the user's identity. Pass that signer into AereClient on the client side; the wallet works on chain 2800 immediately.

Network parameters

Add to MetaMask

One-click form: /addnetwork.html. Or programmatically:

await window.ethereum.request({
  method: 'wallet_addEthereumChain',
  params: [{
    chainId: '0xAF0',
    chainName: 'AERE Network',
    rpcUrls: ['https://rpc.aere.network'],
    nativeCurrency: { name: 'AERE', symbol: 'AERE', decimals: 18 },
    blockExplorerUrls: ['https://explorer.aere.network'],
  }]
});

Faucet

• Mainnet: /faucet.html says it is closed.
• Testnet: /testnet.html, test tokens with no value.

JSON-RPC endpoints

Standard Ethereum JSON-RPC, plus the QBFT namespace.

curl -s -X POST https://rpc.aere.network \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","id":1}'

# Namespaces served on the public endpoints:
ETH, NET, WEB3, QBFT          # both endpoints
TXPOOL                        # rpc.aere.network only

# DEBUG, TRACE: not on rpc.aere.network; on rpc2.aere.network a read-only
#   subset (16 methods, by exact name) inside the 512-block state window.
# ADMIN, MINER: not exposed. A -32601 "Method not found" for a closed
# method means the method is not offered, not that the data is missing.

Rate limits are per IP; on rpc2.aere.network the limit is 30 requests per second with a burst of 60. For a higher, dedicated quota, Aere Cloud offers managed RPC, priced in USD.

State window. Both public endpoints are pruning full nodes. Blocks, transactions, receipts and logs go back to block 0, but account and contract state is retained for only about the most recent 512 blocks, about 5 minutes 17 seconds at the measured 0.62 s block interval. Read state at latest. Outside the window both endpoints now refuse every state read with -32000 World state unavailable (re-measured 2026-10-16); until 2026-09-10 eth_getTransactionCount answered a false 0x0 there, and other providers still can, so never test a nonce for zero at a historical block (corrected 2026-10-27: this sentence said until October 2026). Full explanation, a reproducible example and the SDK guard: the state window section of the developer docs. Also note eth_getLogs accepts at most 5,000 blocks between fromBlock and toBlock.

Tracing: off on rpc, a read-only subset on rpc2. On rpc.aere.network the debug_ and trace_ namespaces are switched off, because one traced block can allocate hundreds of megabytes on an endpoint that also carries wallets, the explorer and every integration on the network; they answer -32601 Method not found, which reads like a method that never existed, so be clear that this is policy and not a statement about the chain. On rpc2.aere.network, since 2026-09-02, sixteen read-only tracing methods are served by exact name, inside the 512-block state window (the list is in the developer docs). eth_simulateV1, eth_createAccessList, eth_getBlockReceipts and decoded revert reasons from eth_call are all available and cover most of the ground. An archive node with full history and tracing exists and is fully synced; it is not yet publicly reachable. What that costs you, and what replaces it.

EVM ruleset

AERE Network runs the Pectra + Fusaka EVM ruleset, both hardforks activated on 2026-05-31. Full functional parity with Ethereum mainnet post-Fusaka. Includes:

Pectra (activated at block 2,075,341):

• EIP-7702, EOA delegation to smart-contract code (native account abstraction; works alongside ERC-4337)
• EIP-2537, BLS12-381 curve precompiles at addresses 0x0b, 0x11 (G1ADD, G1MSM, G2ADD, G2MSM, PAIRING_CHECK, MAP_FP_TO_G1, MAP_FP2_TO_G2), cheap on-chain BLS signature verification, used for trustless cross-chain proofs
• EIP-2935, Historical block hashes (up to 8,192 blocks back) available via system contract
• Cancun pack, EIP-1153 (TSTORE/TLOAD transient storage), EIP-5656 (MCOPY), EIP-6780 (SELFDESTRUCT change), EIP-7516 (BLOBBASEFEE)

Cancun opcode set proven live on-chain: a canary contract AereCancunCanary (0x8DbFC002bB23124cBeCd7B4916c179D2AFd65498) demonstrates TSTORE/TLOAD (including the cross-transaction auto-reset), MCOPY, PUSH0, and BLOBHASH / BLOBBASEFEE returning correct values on chain 2800, inspectable via eth_call and eth_getCode.

Fusaka (activated at block 2,106,597):

• RIP-7951, secp256r1 / P-256 signature precompile at address 0x0000000000000000000000000000000000000100. Fixed cost ~3,450 gas. Verifies signatures from Apple Face ID / Touch ID, Windows Hello, Android biometric APIs, YubiKey, TPM 2.0, EMV cards, and the EU Digital Identity Wallet. ~70× cheaper than Solidity-based verification.

Note: AERE has no consensus-layer beacon chain, so EIP-4788 (parent beacon block root) is set to zero each block, and EIP-4844 blob fields exist in headers but no actual blobs are produced. Fusaka EIPs that are consensus-layer-only or rollup-only (PeerDAS, FOCIL, EOF) are no-ops on QBFT.

Advanced cryptography & AI infrastructure

All of the following are deployed on chain 2800 and callable. Each carries an explicit honest-scope note. Read recording vs view-only carefully.

Post-quantum verifier suite

A broad set of NIST post-quantum signature verifiers (not key generation or signing) run on-chain. We are not aware of any other public chain that verifies all of these signature schemes on-chain (stated as a hedge, not an unqualified "world first"). Recording means a state-changing verifyAndRecord transaction fits the L1 per-transaction gas cap (EIP-7825, 2²⁴); view-only means verification is correct and demonstrable via eth_call (validated bit-for-bit against official NIST vectors) but a recording transaction would exceed that per-tx cap.

Confidential compute (threshold MPC)

AereConfidentialCompute 0x2120350c124e4Cae2C9FfBB6E4942DB1d380c287. A 5-node committee (MPC reconstruction threshold 3, on-chain signature quorum 4) computes an agreed arithmetic circuit over parties' private inputs using real Shamir secret sharing (BN254 scalar field) and a real BGW multiplication gate. The MPC runs off-chain; the contract verifies a quorum of committee ECDSA signatures over the EIP-712 result and records it. Honest threat model: semi-honest (secure against a colluding minority below the threshold, not malicious-secure, no cheater detection). No owner backdoor can forge a result. TEE is not built: the host has no usable SEV-SNP/TDX/SGX attestation, so the pure-software secret-sharing path is used.

Parallel L2 execution & rollup validity

A real from-scratch Rust Block-STM parallel executor (~8.6-9.3x on 16 cores, parallel proven equal to sequential) is wired into the rollup sequencer. Honest scope: this Rust executor parallelizes L2 rollup batches. The L1 base layer runs a separate Block-STM-style block processor of our own inside the Besu fork, switched on on all nine Besu validators since 2026-09-05 (the tenth validator runs the second client, Nethermind) and proven on real blocks with a recorded negative control; with blocks carrying at most one transaction today it delivers no measurable speed-up, and none is claimed. AereBlockSTMRegistry 0x98E2C3e615841919d173D8FF642514c5902E8A28 is a deployed opt-in read/write slot-hint registry (advisory). AereRollupValidity 0x38772063572DF94E90351e44ccbBEefD5F497fbd anchors a real SP1 Groth16 validity proof of the executor (epoch 0); it is a proof of concept over a bounded-VM executor (Transfer/Sweep/Increment/AmmSwap), not a full-EVM validity rollup.

Agentic + AI infrastructure

Contract source is published and verified Sourcify-style (34 contracts), browsable at /verified-contracts.html.

Multi-prover ZK verifiers

Beyond SP1 (Groth16 + Plonk) and RISC Zero, the substrate now includes a KZG opening verifier and a real Halo2 verifier, and recursion has been demonstrated at scale.

Modular ERC-7579 accounts (session keys + social recovery)

An ERC-7579-style modular account factory with pluggable validator modules. Proven live: a userOp signed only by a scoped session key executed through the live AereEntryPointV2.

Interoperability (Hyperlane v3)

A live Hyperlane v3 deployment on the AERE side with a working quoteDispatch. The USDC.e Warp Route rides this v3 mailbox: the AERE side is live and proven, while the Ethereum L1 leg still needs an L1 deployment and real ETH gas (pending).

Application-level building blocks (honest scope)

AereShutterMempoolV3 0x0C0b0560fcaa534fc30D29ae1D248CC1675281df is an application-level, opt-in threshold-encrypted anti-MEV mempool proof of concept (it superseded V2, 0x1351…9310, with a fix for the reveal timeout). A Besu QBFT L1 has no protocol-level encrypted mempool, so this is not a base-layer feature and is not wired into consensus. AereStateRootAnchorV2 0x0b959402283c0D2B9db4FfD7823f99782462e488 anchors state/storage roots whose canonicity comes from the BLOCKHASH opcode; that reaches back only 256 blocks (~160 s at 0.62 s per block); with the AerePQC fork (activationTime 1783820272, first block at or after it is 9,189,161) EIP-2935 is now live on chain 2800, extending the trustless block-hash lookback to an 8,191-block window.

Contract registry

Contracts deployed on AERE L1 (chain ID 2800). Owners, read on chain with owner() on 2026-10-16: 28 of the contracts below answer the Foundation account 0x0243A4f47D44b40b65D33f20329dE20D00c6f3C3; the SP1 gateway, the RISC Zero router and the proof registry answer 0xE04587e0c6da6a30a24EFe7d59701A2BfFb706d9; the other 14 have no owner function. Read owner() yourself before you rely on any of them.

Each contract is inspectable on the explorer at explorer.aere.network.

Indexer API (api.aere.network)

# Latest blocks
GET https://api.aere.network/api/blocks?limit=20

# Block by number
GET https://api.aere.network/api/block/12345

# Transaction by hash
GET https://api.aere.network/api/tx/0xabc...

# Address (balance, nonce, contract code; no transaction history)
GET https://api.aere.network/api/address/0xdeadbeef...

# Network stats
GET https://api.aere.network/api/stats

# WebSocket: live block stream
wss://api.aere.network/ws

Cross-chain bridge

AereBridge (0x7eDa66cd93baAE19530839Bbb28ee36aC8aFAd68) is a federated lock-and-release design: lock AERE on L1, relayers gather signatures, wAERE is minted on the foreign chain; burn wAERE to release native AERE on L1. Today its signer set is a single Foundation key and no relayer runs, so nothing can be bridged through it. The calls below show its interface.

# Lock
await bridge.lockAndBridge(toChainId, recipient, { value: amount });

# Foreign side
await counterparty.releaseFromL1(srcChainId, nonce, recipient, amount, signatures);

Run a validator

The AERE build of the Besu-derived client from the public aere-node package (stock Hyperledger Besu stops following chain 2800 at block 9,189,161), a 32-byte private key file, peer with the existing bootnode. Step by step in the validator course. The chain-2800 genesis file and the bootnode list ship in that public package, so anyone can run a node that follows the chain. Joining the validator set takes a vote of the current validators; to ask, use contact.

Public repositories at git.aere.network/aere-network (aere-contracts, aere-research, aere-docs, sdk-js). Docs pull requests and issues welcome there.