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 faucet, no public source of AERE today. This step will
#    fail with "insufficient funds" on a new address.
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 GitHub:
npm i github:aerenetwork/aere-sdk 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 GitHub 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

Working Express server demonstrating the full neobank-on-AERE integration pattern: signup, KYC attestation, multi-asset portfolio, on-chain savings, deposit-watching webhook. Source is available on the AERE gitea at git.aere.network/aere-network.

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

• UI: /faucet.html, shows the current faucet state. Claiming is disabled while the balance is zero.
• Configured drip: 0.05 AERE per address per 24 hours. This is the contract setting, not an amount you can receive today.

JSON-RPC endpoints

Standard Ethereum JSON-RPC, plus the QBFT and ADMIN namespaces.

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

# Methods enabled:
ETH, NET, WEB3, QBFT, DEBUG, TRACE, TXPOOL

Rate-limit: ~100 req/s per IP. Open a ticket at git.aere.network for higher quota.

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,363):

• 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,606):

• 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: the L1 base runs Besu and executes sequentially; this parallelizes L2 rollup batches only. 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)

AereShutterMempoolV2 0x135100D523edA8D0AdC70e08af905dE5042A9310 is an application-level, opt-in threshold-encrypted anti-MEV mempool proof of concept. A Besu QBFT L1 has no protocol-level encrypted mempool, so this is not a base-layer feature and is not wired into consensus. AereStateRootAnchor 0x78b40a983E89c91Aefd8A62Be709bDF25ABB57cb anchors state/storage roots whose canonicity comes from the BLOCKHASH opcode; that reaches back only 256 blocks (~128s at 0.5s blocks); 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

All currently-deployed contracts on AERE L1 (chain ID 2800). Owner: Foundation 0x0243A4f47D44b40b65D33f20329dE20D00c6f3C3.

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, txs, contract code)
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

Federated 2-of-2 lock-and-release. Lock AERE on L1 → relayers gather signatures → mint wAERE on the foreign chain. Burn wAERE → release native AERE on L1.

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

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

Run a validator

Hyperledger Besu QBFT image, 32-byte private key file, peer with the existing bootnode. Step by step in the validator course. The chain-2800 genesis and bootnode list are issued to approved operators via contact.

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