Exchanges and custodians

Deposits, withdrawals, finality and supply, for an integration that holds other people's funds.

Docs / Build / Exchanges and custodians

What an integration that holds other people's funds needs to know: deposits, withdrawals, when a block is final, and the two places where chain 2800 differs from the EVM chain you integrated last.

Everything here is measured on the public endpoints; where a value was measured, the date is given. Rehearse the whole integration on the testnet (chain 28001) first: it runs the same node software and its tokens are free.

In one table

Chain ID2800 (0xaf0); testnet 28001 (0x6d61)
CoinAERE, native, 18 decimals. There is no token contract to integrate
Addresses20 bytes, 0x and 40 hexadecimal characters, EIP-55 checksum. No memo or tag
Keyssecp256k1, as on Ethereum: an existing EVM wallet, HSM or MPC setup signs for chain 2800 with nothing but the chain ID changed
Transactions you sendtype 2 (EIP-1559); types 0 and 1 are accepted too
Transactions you will seethe standard Ethereum types and 0x50 (accounts with a post-quantum key, below)
Block timeabout 0.6 seconds (0.591 over the 2,000 blocks to 28,292,744, measured 2026-11-22)
Finalitydeterministic; read it with the finalized block tag (below)
FeesEIP-1559 with a base fee floor of 1 Gwei; a plain transfer costs 21,000 gas
Supply2,800,000,000 AERE at genesis, no minting

Run your own node

The public endpoints are for reading the chain now. For an integration that credits money they fall short in five ways, each measured:

  • State is kept for 512 blocks, about five minutes. A balance or a nonce at an older block is refused, not answered (Public endpoints).
  • No tracing. debug_traceBlockByNumber and trace_block answer "Method not found" (measured 2026-11-22). Value that moves inside a contract call is visible only in a trace.
  • eth_getLogs takes a bounded block range and refuses a wider one (-32005, Events and logs).
  • One of the three does not find an old transaction by hash. client2.aere.network answers null to eth_getTransactionByHash and eth_getTransactionReceipt for a transaction older than about 2,350,000 blocks, roughly sixteen days, although it serves the block that holds it (measured 2026-11-22, Public endpoints). A deposit or a withdrawal you look up a month later must be asked of your own node.
  • They are a small number of machines shared with everyone, and each limits requests per client. Over the limit a request is refused at the door with HTTP 429 or 503 (Public endpoints, rate limits). A deposit scanner that reads such a refusal as "no transaction" or "no block" misses deposits: treat it as no answer and retry.

The node package, the genesis and the exact options are published: Run a node. Check the genesis you run against Chain parameters (block 0 hash) before you trust anything the node says.

When a block is final: use finalized, not a confirmation count

This is the part that differs from most chains, in your favour and with one rule to follow.

Consensus is QBFT with ten validators: a block is decided once, by seven of ten, and a validator never replaces a decided block. There is no probabilistic settlement and no "wait N blocks".

A node that does not take part in consensus, which is what your node and the public endpoints are, follows the chain a little differently. Between two post-quantum checkpoints it accepts a new header on the seal of its proposer alone, so the last few blocks it shows could, in principle, be replaced by a branch built with the key of a single validator. The checkpoint closes that: every 32nd block carries a certificate of the validators under its hash, which one key cannot produce, and a node moves its finalized block only on such a certificate (Consensus).

So the rule for crediting a deposit, and for calling a withdrawal done, is:

Process blocks up to the block returned by eth_getBlockByNumber("finalized"), and no further.

Measured on 2026-11-22, finalized was 18 to 29 blocks behind the head on the mainnet and testnet endpoints read, that is 11 to 17 seconds. safe returns the same block. A fixed confirmation count is not a substitute: it does not know where the last checkpoint is.

Two things follow from deterministic finality that are worth knowing in operations. If more than three of the ten validators are unreachable the chain stops rather than forks, and resumes where it stopped; an integration should treat "no new finalized block for a minute" as an incident to wait out, not as a reorganisation to handle. The public status page is status.aere.network.

Deposits

Scan every block, in order, up to finalized. For each block read the transactions and their receipts, and credit a transaction only if its receipt has status 0x1:

// rpc(method, params) is a plain JSON-RPC call to your own node
const fin = Number(BigInt((await rpc('eth_getBlockByNumber', ['finalized', false])).number));
for (let n = lastProcessed + 1; n <= fin; n++) {
  const tag = '0x' + n.toString(16);
  const block = await rpc('eth_getBlockByNumber', [tag, true]);
  const receipts = await rpc('eth_getBlockReceipts', [tag]);
  block.transactions.forEach((tx, i) => {
    if (receipts[i].status !== '0x1') return;                // a failed transaction moves no value
    if (!tx.to || BigInt(tx.value) === 0n) return;
    if (isDepositAddress(tx.to)) credit(tx.to, BigInt(tx.value), tx.hash, n);
  });
  lastProcessed = n;
}

What this loop does not see, as on any EVM chain: AERE sent to a deposit address from inside a contract call (a multisig payout, a batch sender, a contract wallet). To credit those, trace each block on your own node (debug_traceBlockByNumber with the call tracer) and credit successful internal calls that carry value to a deposit address. Decide deliberately whether you accept them; many exchanges do, and their users expect it.

The same loop, with these rules and the tracing option, is published as a program you can run and read: deposit-scan.mjs (no dependency, read-only). Run against the testnet over blocks 11,774,000 to 11,774,199 for the two addresses of our own test payment, it prints two deposits: one of type 2 from the faucet and one of type 0x50:

node deposit-scan.mjs --rpc https://testnet-rpc.aere.network --from 11774000 --to 11774199 \
  --address 0xf626f4cf779d6102c27a8f561eea97410cf3ba3d --address 0xec63c8473f2694d7dc282cd377f2fe077810a75a

Three details that have cost other integrations time:

  • Blocks are shorter than a second and timestamps have one-second resolution, so consecutive blocks often share a timestamp. Order by block number and transaction index, never by timestamp.
  • Most blocks are empty. At about 146,000 blocks a day, fetch headers cheaply and skip blocks with no transactions.
  • The block hash is not keccak-256 of the raw header. If you verify hashes yourself, read Consensus first.

Transactions of type 0x50

Chain 2800 has accounts whose only key is post-quantum (AIP-20). Their transactions have type 0x50. Anyone can send one, to any address, including one of your deposit addresses, so your scanner will meet them even if you never create such an account.

For a deposit scanner they are ordinary: from, to, value, hash, nonce and the fee fields are where they always are, the receipt has the fields of a type-2 receipt with type 0x50, and the value moved is value. What differs is the authorization: instead of a secp256k1 signature the transaction carries algId, pqPublicKey and pqSignature, and from is derived from the public key by the node.

Check that your library reads them. As served on 2026-11-22 the JSON form of a type-0x50 transaction has no v, r and s fields, and one widely used library refuses a transaction object without them. Measured on block 11,774,076 of the testnet, which holds such a transaction:

LibraryBlock with transactions, and the transaction by hashReceipt
ethers 6.16.0fails (missing r): getBlock(n, true) throws for the whole blockreads
ethers 5.8.0reads, sender and value correctreads
viem 2.58.4reads, sender and value correctreads
web3.py 8.0.0reads, sender and value correct, once its ExtraDataToPOAMiddleware is in place (without it web3.py refuses every block of a QBFT chain, whatever its transactions: extraData is longer than 32 bytes)reads
web3.js 4.16.0reads, sender and value correctreads

This is not a future case on chain 2800: block 19,900,028 holds the first transaction of this type (hash 0x7cb5bdaceb475a6fee881c6a68aadf69734e78c1fd5648865c4fdde243d602e5, served on 2026-11-22 without the three fields by all three public endpoints), so a scanner that walks the chain through that block with a library from the first row stops there. Counted on 2026-11-22 in the explorer's index (at the chain head), it is the only transaction of type 0x50 on chain 2800 so far, out of about 265,300. Use it as a test: read block 19,900,028 with transactions before you go live.

Libraries that decode transactions into a closed set of types (the Go ethclient is the usual example) refuse an unknown type whatever its fields; they are not in the table because they were not measured here. Whatever you use, the safe pattern is the one in the loop above: plain JSON-RPC, and read only the fields you need. A change to the node that serves v, r, s and yParity as zero for this type, which makes ethers 6 read these blocks, is written and not yet deployed; this page will say when it is.

To test your scanner, send yourself a type-0x50 payment on the testnet with the Quantum Wallet or the reference tool pqtx.mjs, and make sure the deposit is credited.

Withdrawals

Send type-2 transactions signed with your existing secp256k1 infrastructure, with chain ID 2800 (EIP-155 replay protection is in force).

  • Gas limit: 21,000 for a transfer to an account. A recipient that is a contract can need more; estimate with eth_estimateGas, and decide whether you send to contracts at all.
  • Fee: the base fee has a floor of 1 Gwei and, with mostly empty blocks, sits on it (measured 2026-11-22: 1 Gwei on the last five blocks). Set maxFeePerGas from eth_feeHistory with headroom, as on Ethereum. A payment with a priority fee of 1 Gwei was included within seconds on the testnet (2026-11-22); lower values were not measured. See Fees.
  • Nonce: read it with eth_getTransactionCount(address, "pending") from your own node and keep your own counter; do not run two senders on one address.
  • Done means: the receipt has status 0x1 and its block number is at or below finalized.

If a transaction you sent is not in a block after a minute, do not assume either outcome: re-read the nonce and the pool on your own node before re-sending, and re-send with the same nonce, never a new one.

Supply

2,800,000,000 AERE were allocated at genesis to six accounts, which are in the published genesis file, and there is no minting: no rule of the chain creates AERE after block 0. The base fee is not burned by the protocol (Fees).

For a circulating-supply figure, subtract from the total what the allocation accounts and the accounts that received their funds still hold; each is an ordinary address whose balance anyone can read with eth_getBalance. The allocations and their purposes are described in The 2.8 Billion AERE Supply, Explained.

Checklist

  1. Your node is on chain 2800: block 0 hash matches Chain parameters.
  2. Deposits are credited from blocks at or below finalized only.
  3. Failed transactions (status 0x0) are not credited.
  4. A type-0x50 deposit is credited, and a block that contains one does not stop the scanner.
  5. Internal transfers: accepted and traced, or refused and documented.
  6. Withdrawals are final at finalized, and a stuck one is re-sent with the same nonce.
  7. Ordering is by block number and transaction index, not by timestamp.
  8. The whole flow has run on the testnet, including a period with no new blocks.
  9. An answer the scanner cannot read (no response, HTTP 429 or 5xx, a JSON-RPC error) stops the scan at that block and is retried; it is never read as an empty block or a missing transaction.