Republished from a clean root: the compiled artifact is gone from history, and the local line of work joins the sanitized public line

The public history carried kat/__pycache__/mlkem768_reference.cpython-314.pyc,
a compiled Python artifact embedding the operator's absolute local path. Text
secret scanners do not read compiled binaries, which is exactly how it slipped
through, and removing it from the tip would have left it reachable through the
old root commits. So this repository is republished from a single clean root.

This root also carries, from the previously unpublished line of work:
- corrected LICENSE year, LICENSING.md, VERIFY-POLICY.md, and
  CITATIONS-UNRESOLVED.md remeasured 2026-08-11 (101 paths, README aligned)
- O-018: run_consensus_verification.py ran 19 of 29 models and reported PASS;
  it now runs all 29, and computemarket_smt.py gains resolveByTimeout /
  reclaimUnsettled cases plus a negative control
- O-006: the word 'audited' removed from next to Bouncy Castle, twice, after a
  concurrent edit resurrected it
- O-014: prior art named and dated - Algorand's native falcon_verify shipped
  about ten months before AERE's precompiles; the primacy claim is withdrawn
  where it was implied
- bench/ scripts parametrized so they actually run for an outsider (the
  earlier textual sanitization left $STAGING unexpanded inside Python strings)
- AIP-2/AIP-3 errata with measured figures, spec remeasurements at 2026-08-01,
  and the spec-zk-stack retractions (owner is an operational key, not the
  Foundation; 'maximally sound' withdrawn; aggregator V1 deprecated)
The redacted bench-host environment files from the sanitized line are kept
exactly as published; the unredacted local variants are not carried.
This commit is contained in:
Aere Network committed 2026-08-15 13:52:14 +03:00
commit 6cb0140fae
177 files changed
+33777

No files matched your search

+162
View File
@@ -0,0 +1,162 @@
# AIP-1: AIP Purpose and Process
## Preamble
| Field | Value |
| --- | --- |
| AIP | 1 |
| Title | AIP Purpose and Process |
| Author | AERE Foundation |
| Type | Meta |
| Category | (none) |
| Status | Living |
| Created | 2026-07-11 |
| Requires | None |
| Ratification | Foundation-ratified (pre-decentralization) |
## Abstract
This AIP defines the AERE Improvement Proposal process: what an AIP is, the
statuses it moves through, the categories it can carry, the required sections,
and who ratifies it. It is a Living document because the process will change as
the network decentralizes.
## Motivation
AERE ships changes to a live chain (chain ID 2800) and to a growing set of
contracts. Without a single canonical record of why each change was made, that
history lives only in commit messages, in the SDK address registry, and in the
memory of the people who shipped it. An AIP process fixes that. It gives every
change a stable, plain-text home that states the motivation, the exact mechanism,
the on-chain proof, and the honest limitations. It lets an outside auditor,
integrator, or automated agent reconstruct the design of the chain without asking
anyone.
It also forces discipline. Writing the Specification and Security Considerations
sections before (or, for retro-filed AIPs, immediately after) shipping surfaces
weak assumptions early.
## Specification
### Roles
- **Author.** Anyone may author an AIP. The author writes the document, drives it
through the statuses, and answers review questions.
- **Editor.** The editor checks that an AIP is well-formed, correctly numbered,
correctly categorized, and technically coherent, and that every cited address,
transaction, and number is real. The editor does not judge whether a proposal
is a good idea; that is the ratifier's job. Until decentralization the editor
role is held by the AERE Foundation.
- **Ratifier.** The party whose approval moves an AIP to Final. Until
decentralization this is the Foundation account
`0x0243A4f47D44b40b65D33f20329dE20D00c6f3C3` (a single-key,
Foundation-controlled account, not a deployed multisig). See the governance note
below.
### Statuses
The normative lifecycle is `Draft -> Review -> Last Call -> Final`. `Living`
replaces `Final` for standards that keep evolving. `Withdrawn` and `Stagnant` are
the off-ramps.
- **Draft.** Well-formed, has an author, may change substantially.
- **Review.** Author has requested wider scrutiny; open questions are tracked in
the AIP.
- **Last Call.** A stated final-review window (default 14 days). If no blocking
issue is raised, it advances to Final or Living.
- **Final.** Accepted. For shipped work, live on chain 2800. Breaking changes
after Final require a new AIP that supersedes this one.
- **Living.** Accepted and expected to keep being updated.
- **Withdrawn.** Abandoned. Terminal, but the number is retired, not reused.
- **Stagnant.** Inactive in Draft or Review beyond 6 months. Revivable by any
author.
Retro-filed AIPs enter at Final or Living and state in their Abstract that they
document a change that already shipped.
### Categories and types
Types are Standards Track, Meta, and Informational. A Standards Track AIP MUST
name exactly one category:
- **Core**: consensus, block production, fee and burn accounting, precompiles,
genesis and client configuration.
- **Networking**: peer-to-peer protocol and sync.
- **Interface**: contract interfaces, ABIs, RPC conventions, verification
surfaces.
- **ARC** (AERE Request for Comment): application and token standards (for
example ERC-20, ERC-4626, ERC-4337, ERC-6551 conventions as adopted on AERE).
- **Meta** and **Informational** carry no category.
### Numbering and format
- AIPs are numbered by monotonically increasing integer. AIP-1 is this document.
- Each AIP is a single Markdown file named `AIP-N.md`.
- Each AIP MUST contain the sections in `aip-template.md`: Preamble, Abstract,
Motivation, Specification, Rationale, Backwards Compatibility, Security
Considerations, Reference Implementation and On-Chain Deployment, Copyright. A
section that does not apply is kept with the body "None".
### Sourcing rules (binding on all AIPs)
- Every on-chain address MUST be copied verbatim from `sdk-js/src/addresses.ts`,
the canonical registry. No address may be guessed. If unsure, omit it.
- Every gas figure, transaction hash, and block number MUST be reproducible from
the chain or from a repo fixture. Unmeasured quantities MUST be written as "to
be measured", never invented.
- Design ceilings (for example a theoretical maximum throughput) MUST NOT be
presented as measured throughput.
### Ratification and the decentralization path
Today, ratification is editorial: the Foundation approves an AIP and, for a
Standards Track change, ships it. This is honest and is labeled as such on every
pre-decentralization AIP. It is not stakeholder governance and does not pretend to
be.
The intended migration, each step of which will be its own Meta AIP:
1. Open the validator set beyond the current seven Foundation-operated
validators, and run a second client implementation.
2. Introduce a public review period with standing that the Foundation cannot
unilaterally shorten.
3. Move ratification to stake-weighted or validator-weighted approval once an
independent staker and validator base exists.
Until step 3, all Standards Track AIPs carry
**"Foundation-ratified (pre-decentralization)"**.
## Rationale
The process is deliberately close to Ethereum's EIP/ERC model because AERE is
EVM-equivalent (Pectra plus Fusaka) and builders already know that model.
Copying its status names and section structure lowers the cost of contributing.
The one deviation worth calling out is the explicit, up-front honesty about
governance. Rather than dress editorial ratification up as decentralized
governance, AIP-1 names the current reality and the path off it. Credibility with
technical readers comes from stating limitations plainly, not from hiding them.
## Backwards Compatibility
None. This is the first process document.
## Security Considerations
The chief risk in a pre-decentralization process is that a single party can both
author and ratify, so an AIP can be waved through without genuine review. This is
mitigated only partially today, by the editor's sourcing rules (every address and
number must be real and reproducible) and by keeping the honesty label on every
proposal. It is not fully mitigated until independent ratifiers exist. This
weakness is stated rather than hidden, which is itself part of the mitigation.
## Reference Implementation and On-Chain Deployment
Not applicable. This AIP is the process. The scaffold lives at `aerenew/aips/`
and consists of this file, `README.md`, `aip-template.md`, and the retro-filed
AIPs AIP-2 through AIP-7.
## Copyright
Released to the public domain (CC0). No rights reserved.
</content>
+143
View File
@@ -0,0 +1,143 @@
# AIP-2: Coinbase Fee-Burn Routing (37.5%)
## Preamble
| Field | Value |
| --- | --- |
| AIP | 2 |
| Title | Coinbase Fee-Burn Routing (37.5%) |
| Author | AERE Foundation |
| Type | Standards Track |
| Category | Core |
| Status | Final |
| Created | 2026-07-11 |
| Requires | None |
| Ratification | Foundation-ratified (pre-decentralization) |
## Abstract
This AIP documents the on-chain mechanism that makes AERE's burn real and
auditable: an atomic splitter that routes a validator's accumulated coinbase
rewards so that a fixed fraction, 37.5% by default, is sent to a permanent burn
vault and the remainder is returned to the validator. It is a retro-filed record
of a change that is already live on chain 2800.
**Realized burn to date, MEASURED.** The mechanism is live and the vault is
immutable, and it has burned essentially nothing. `eth_getBalance` on the burn
vault `0x696afDF4f814e6Fd6aa45CE14C498ed9375fB2c6` returned
`0x1e7f974e119aaa7` at block 10,571,949 on 2026-07-20, which is
137,352,594,046,167,719 wei, or 0.1373525940461677 AERE, against a fixed supply
of 2,800,000,000 AERE. The reason is arithmetic: the burn is a percentage of
validator coinbase revenue, that revenue is currently zero, and a percentage of
zero is zero. The 37.5% in this document is a conditional rate on future
revenue. AERE is not deflationary today. Verify with one RPC call.
## Motivation
The AERE whitepaper (Section 3.3) states that up to 37.5% of transaction fees are
permanently removed from circulation. That wording predates the implemented
mechanism and is superseded: what this AIP specifies, and what is live, is a cut
of the VALIDATOR COINBASE REWARD, not of transaction fees. The
validator-reward-cut description governs everywhere the two conflict. On a
Hyperledger Besu QBFT chain there is no
protocol-level base-fee burn of the EIP-1559 kind: QBFT credits fees to the block
proposer's coinbase rather than burning any part of them at the consensus layer.
So the whitepaper claim needed an explicit, on-chain mechanism, or it would be
just a claim.
The goal was to make the burn (1) measurable in a single on-chain read, (2)
impossible for the routing contract to steal or divert, and (3) verifiable by any
third-party explorer or analyst against the whitepaper.
## Specification
### Contracts
- **AereFeeBurnVault** at `0x696afDF4f814e6Fd6aa45CE14C498ed9375fB2c6`. A
stateless sink. It accepts native AERE via `receive()` or `burn()`, and any
ERC-20 via `burnToken()`. It has no withdraw function and no admin. Value that
enters is removed from circulation. It exposes `sweepToZero()`, callable by
anyone, which forwards its native balance to `address(0)` (QBFT Besu permits a
send to the zero address, after which the value is unreachable). Counters
`totalBurnedAERE` and `totalSentToZero` make the burn queryable in O(1).
Source: `contracts/contracts/AereFeeBurnVault.sol`.
- **AereCoinbaseSplitter** at `0xb4b0eCe9011613A5b84248a9B42a0f309E6F01Ec`. The
routing contract. A validator or its forwarder daemon calls
`splitAndDistribute(validator)` or `splitToSelf()` with the accumulated
coinbase as `msg.value`. The contract computes `burnAmount = msg.value *
burnBps / 10000`, forwards `burnAmount` to AereFeeBurnVault via its `burn()`
entrypoint, and returns the remainder to the validator address. It maintains
lifetime counters `totalBurned` and `totalDistributed` and per-caller
attributions. Source: `contracts/contracts/AereCoinbaseSplitter.sol`.
- **AereCoinbaseSplitterV2** at `0x8C1A48eFA57b66fEE743A00E3899c29ad3Fd27b4`. The
current canonical splitter. Source:
`contracts/contracts/AereCoinbaseSplitterV2.sol`.
### Parameters
- `burnBps` default is `3750`, which is 37.5%, matching whitepaper Section 3.3.
- `setBurnBps(uint256)` is owner-only and MUST revert above `5000` (a hard cap of
50%). The whitepaper says "up to 37.5%", so the cap gives headroom while
bounding abuse. Owner is the Foundation
`0x0243A4f47D44b40b65D33f20329dE20D00c6f3C3`.
- The splitter holds no custody across calls: every call fully dispatches
`msg.value` into the burn portion and the validator rebate.
### Extra burn on top
Beyond the coinbase split, the immutable revenue router **AereSink** at
`0x69581B86A48161b067Ff4E01544780625B231676` directs an additional bucket to
AereFeeBurnVault (see AIP-5). The 37.5% figure in this AIP refers specifically to
the coinbase split, not to the total of all burn paths.
## Rationale
The split is done in application code called by the validator rather than at the
consensus layer because QBFT does not offer a base-fee-burn hook, and forking the
client to add one would break EVM-equivalence with Ethereum tooling and add a
consensus-critical code path to maintain. Routing the coinbase through an
immutable, non-custodial splitter achieves the economic outcome (a fixed fraction
provably burned, with public counters) without touching consensus.
The burn vault is deliberately separate from the splitter and has no admin, so
even the splitter owner cannot pull burned funds back. The 50% hard cap on
`burnBps` bounds the worst case if the owner key is misused.
## Backwards Compatibility
None. This mechanism adds a routing path; it does not change transaction
semantics, gas accounting, or the EVM ruleset.
## Security Considerations
The honest limitation of this design is that the burn is **cooperative, not
protocol-enforced**. Nothing at the consensus layer compels a validator to route
its coinbase through the splitter. A validator that keeps its full coinbase simply
does not burn. Today the network runs seven validators under a single operator
(the Foundation), so in practice the burn depends on Foundation-operated
infrastructure calling the splitter, not on a trustless rule. As the validator
set decentralizes, making the burn a credible network-wide property will require
either social/economic commitment from validators or a future Core AIP that moves
the split into block production itself.
Within the contracts, the risks are limited: the splitter is non-custodial and
reentrancy-guarded, and the burn vault has no withdraw path or admin. The
`burnBps` setter is owner-gated and capped at 50%.
## Reference Implementation and On-Chain Deployment
- `contracts/contracts/AereCoinbaseSplitter.sol` -> `0xb4b0eCe9011613A5b84248a9B42a0f309E6F01Ec`
- `contracts/contracts/AereCoinbaseSplitterV2.sol` -> `0x8C1A48eFA57b66fEE743A00E3899c29ad3Fd27b4`
- `contracts/contracts/AereFeeBurnVault.sol` -> `0x696afDF4f814e6Fd6aa45CE14C498ed9375fB2c6`
- Related extra-burn bucket: AereSink `0x69581B86A48161b067Ff4E01544780625B231676` (AIP-5)
All addresses copied verbatim from `sdk-js/src/addresses.ts`. Live cumulative
burn statistics are readable via `AereCoinbaseSplitter.burnStats()` and
`AereFeeBurnVault.totalBurnedAERE()`.
## Copyright
Released to the public domain (CC0). No rights reserved.
</content>
+220
View File
@@ -0,0 +1,220 @@
# AIP-3: Sub-Second Block Period (500 ms QBFT)
## Preamble
| Field | Value |
| --- | --- |
| AIP | 3 |
| Title | Sub-Second Block Period (500 ms QBFT) |
| Author | AERE Foundation |
| Type | Standards Track |
| Category | Core |
| Status | Final |
| Created | 2026-07-11 |
| Requires | None |
| Supersedes | None |
| Superseded-By | None |
| Ratification | Foundation-ratified (pre-decentralization) |
## Abstract
This AIP documents the mid-chain transition of AERE's block period from one
second to 500 milliseconds, performed as a QBFT configuration transition rather
than a chain restart, so that all history, state, and validator keys were
preserved. It is a retro-filed record of a change that is already live on chain
2800.
## Motivation
AERE targets settlement-grade latency. A one-second block period puts a hard
floor of about one second on inclusion latency and worst-case finality. Halving
the block period to 500 ms roughly halves both, which materially improves the
feel of interactive flows (swaps, payments, wallet confirmations) without any
change to the EVM or to application code.
The change had to be done without re-genesising the chain. AERE had already been
forced through one full re-genesis (genesis-v2 on 2026-05-07), and losing history
again was not acceptable. QBFT supports timed configuration transitions, so the
block period could be reduced at a scheduled block with continuity of state and
validator identity.
## Specification
### Mechanism
Hyperledger Besu QBFT reads the initial block period from `config.qbft` and reads
scheduled overrides from a **separate** `transitions` object at the config root.
The transition key is `xblockperiodmilliseconds` (note: milliseconds, and note the
`x` prefix, which marks the option experimental in Besu). The correct, and easily
mis-typed, form is:
<!-- QBFT-TRANSITION-CANONICAL path=config.transitions.qbft key=xblockperiodmilliseconds block=2137652 value=500 -->
```json
{
"config": {
"qbft": {
"blockperiodseconds": 1,
"epochlength": 30000,
"requesttimeoutseconds": 4
},
"transitions": {
"qbft": [
{ "block": 2137652, "xblockperiodmilliseconds": 500 }
]
}
}
}
```
`transitions` is a sibling of `qbft`, not a child of it. Besu reads `transitions`
from the config root (`JsonGenesisConfigOptions.java:47`) and then the sub key
`qbft` (`TransitionsConfigOptions.getQbftForks()`). A `transitions` object nested
inside `config.qbft` is never read, parses without any error or warning, and is
silently inert.
### Activation
The 500 ms period is in force from block 2,137,652 on chain 2800. Before that
block the network produced one-second blocks; from that block onward it produces
500 ms blocks, with the cadence settling into a steady alternating pattern by
block 2,137,662. State, account balances, contract code, and the validator set
were unchanged across the transition.
Block 2,137,652 is the boundary because it is the first block on chain 2800 whose
timestamp equals its parent's. That is impossible while a one second minimum
period is in force, and it is the reason the block number is not a free choice: a
node configured to transition later than 2,137,652 applies
`TimestampMoreRecentThanParent` to block 2,137,652
(`QbftBlockHeaderValidationRulesetFactory.java:80-83`), rejects it, and stops
syncing. Full evidence in `aerenew/docs/TRANZITIA-QBFT-SETTLED-2026-07-20.md`.
### Operational note for fresh nodes
A node synced from genesis against this config applies the transition
automatically. A brand-new isolated chain started from a config like this needs
`--sync-min-peers=1` to begin producing, which is an operational detail of
bootstrapping, not part of the consensus rule.
## Rationale
A configuration transition was chosen over a re-genesis because it preserves the
chain's entire history and, critically, the validator keys and account state.
Re-genesis was rejected: it destroys history and forces every integrator to
re-point. QBFT's timed transition is purpose-built for exactly this kind of
parameter change and avoids a client fork.
500 ms was chosen as a conservative first step below one second. It roughly halves
latency while staying comfortably within what a small, low-latency,
Foundation-operated validator set can sustain. Going lower (for example 250 ms or
100 ms) is possible in principle but was deliberately not attempted here, because
tighter periods increase the rate of missed-proposal rounds and stress
peer-to-peer timing, and there is no need to push that limit with the current
validator topology.
## Backwards Compatibility
None at the application layer. Block time is not part of the EVM; contracts do not
observe it directly. Note the second-order effect: any code that assumed a
one-second block period to convert block counts to wall-clock time (for example a
naive per-block reward constant) is now wrong by 2x. AERE hit exactly this: the
original staking contract computed rewards against a hardcoded blocks-per-year
constant and under-paid once blocks sped up. That was fixed in AereStakingV2
(`0x1D95eF6D17aeAB732dF914Ba2d018c270BC155FC`) by moving reward accrual to
timestamps, which is block-time-immune. New code MUST use `block.timestamp`, not
block height, for wall-clock math.
## Security Considerations
Reducing the block period narrows the timing margin for each consensus round. With
the current seven validators under a single operator this is low-risk because
network latency between the nodes is small and predictable, and QBFT finalizes
within the round among a small set. The honest caveats:
- **Small, single-operator validator set.** Sub-second finality here is a property
of a seven-node, one-operator topology, not of a large decentralized set. It
should not be read as a claim about behavior under a geographically dispersed,
independently operated validator set. Reassessing the block period will be part
of decentralizing the validator set.
- **No consensus-layer change beyond the parameter.** This is a timing parameter,
not a new consensus algorithm. It does not alter QBFT's fault tolerance
assumptions.
## Reference Implementation and On-Chain Deployment
This is a chain-configuration change, so there is no contract address. The
authoritative artifacts are the Besu QBFT genesis/config carrying the
`xblockperiodmilliseconds: 500` transition at block 2,137,652 (see Erratum 1),
and the chain history itself: block intervals before 2,137,652 are 1000 ms and
after are approximately 500 ms, verifiable via `eth_getBlockByNumber` timestamp
deltas on `https://rpc.aere.network`. Chain ID is 2800.
## Errata
**Erratum 1, 2026-07-20. The Mechanism JSON example was self-contradictory, and
the activation block was wrong.**
As originally published, the prose in Mechanism correctly described a `transitions`
block, but the JSON example nested `transitions` **inside** `qbft`, which is a form
Besu never reads. The example was:
```json
{
"_note": "WRONG-FORM, historical record of the original defect. Do not copy.",
"config": {
"qbft": {
"blockperiodseconds": 1,
"transitions": { "qbft": [ { "block": 2138451, "xblockperiodmilliseconds": 500 } ] }
}
}
}
```
That fence is retained above only as the historical record of the defect. It is
marked WRONG-FORM so the regression test skips it. It must not be copied.
Two things were corrected in the body:
1. **Path.** `transitions` moved from inside `config.qbft` to the config root, as
a sibling of `qbft`. Settled from the Besu 26.4.0 source
(`JsonGenesisConfigOptions.java:47`, `TransitionsConfigOptions.getQbftForks()`).
2. **Activation block.** `2,138,451` corrected to `2,137,652`. The original figure
was not measured. Live block timestamps show the one second cadence ending at
block 2,137,651, and block 2,137,652 carries the same timestamp as its parent,
which a one second period forbids. The `2,138,451` figure is roughly 800 blocks
too late and would halt a from-genesis sync at 2,137,652.
The key name `xblockperiodmilliseconds` was correct as originally published and is
unchanged. The 500 ms value is unchanged. Nothing about the deployed network
changed; only this document's description of it was wrong.
Evidence and Besu source citations: `aerenew/docs/TRANZITIA-QBFT-SETTLED-2026-07-20.md`.
## Post-Acceptance Outcome Record
*Appended 2026-07-20 under AIP-1 section 5. Nothing above this heading was
edited.*
**Measured block interval: 516.4 ms. Configured target: 500 ms.**
The transition worked: history, state and validator keys were preserved, and
intervals before block 2,137,652 (see Erratum 1) are 1000 ms while intervals after
are approximately 500 ms, as the sections above describe. But the realized mean
interval is **516.4 ms (measured)**, roughly 3.3% above the 500 ms target, not
500 ms exactly.
This is expected behavior rather than a defect: `xblockperiodmilliseconds` sets a
minimum period, and QBFT adds real proposal, gossip and commit latency on top of
it. A configured target and a measured cadence are different quantities.
**The obligation this creates.** Aere documents state the target as a
configuration value and the interval as a measured value, and never present 500 ms
as a measured result. Any derived figure that depends on block cadence, including
the EIP-2935 lookback duration quoted in AIP-7 and AIP-18 as "roughly 68 minutes",
is computed from the target and is therefore an approximation that runs about 3%
optimistic; at the measured 516.4 ms cadence, 8191 blocks is approximately 70.5
minutes.
## Copyright
Released to the public domain (CC0). No rights reserved.
+200
View File
@@ -0,0 +1,200 @@
# AIP-4: On-Chain Post-Quantum Signature Verification Suite
## Preamble
| Field | Value |
| --- | --- |
| AIP | 4 |
| Title | On-Chain Post-Quantum Signature Verification Suite |
| Author | AERE Foundation |
| Type | Standards Track |
| Category | Interface |
| Status | Final |
| Created | 2026-07-11 |
| Requires | None |
| Ratification | Foundation-ratified (pre-decentralization) |
## Abstract
This AIP documents AERE's suite of on-chain post-quantum signature verifiers,
implemented in pure Solidity and validated against official NIST Known-Answer-Test
(KAT) and ACVP vectors. The suite covers hash-based schemes (WOTS+, XMSS,
SPHINCS+/SLH-DSA) and lattice schemes (Falcon-512, Falcon-1024, ML-DSA-44), plus
the account-layer primitives that turn Falcon-512 verification into a usable
wallet. It is a retro-filed record of contracts already live on chain 2800. It is
explicit that this is an application and account layer capability today; AERE
consensus is not post-quantum.
## Motivation
A cryptographically relevant quantum computer would break the secp256k1 ECDSA
signatures that secure ordinary EVM accounts. The migration path the ecosystem
will eventually need is on-chain verification of NIST post-quantum signature
schemes, so that accounts and applications can require a quantum-resistant
signature. AERE's goal was to make those verifiers real and correct on a live EVM
chain, validated bit-for-bit against the official test vectors, rather than
described in a whitepaper.
There is a real scope boundary here that this AIP states plainly, because getting
it wrong would be a false claim: verifying a post-quantum signature inside a
contract is an application-layer capability. It does not make the chain's
consensus post-quantum. Validators on AERE still sign classical QBFT.
## Specification
### The verifier suite (live on chain 2800)
Each verifier is a pure-Solidity contract validated against official vectors.
Whether a verifier can record a result in a state-changing transaction, versus
only answer as a `view` via `eth_call`, is decided by the EIP-7825 per-transaction
gas cap of 16,777,216 (2^24). Schemes whose full verify fits under the cap expose
a state-changing `verifyAndRecord`; schemes whose full verify exceeds the cap in
pure Solidity are `view`-only until a native precompile exists (see below).
| Scheme | Contract | Address | On-chain mode | Evidence |
| --- | --- | --- | --- | --- |
| WOTS+ (hash-based, one-time) | AerePQCVerifier | `0x1cE2949e8cE3f1A77b178aF767a4455c08ec6F82` | records on-chain | hash-based, well under the cap; exact standalone gas to be measured (bounded above by the XMSS figure below, which contains a WOTS+ verify) |
| XMSS-SHA2_10_256 (RFC 8391, many-time) | AereXmssVerifier | `0x77b14E264D0bb08d304d4e0E527F0fCdFc88B112` | records on-chain | `verifyAndRecord` gasUsed 1,561,963 < 16,777,216 |
| SLH-DSA-SHA2-128s / SPHINCS+-SHA2-128s-simple (FIPS 205, stateless) | AereSphincsVerifier | `0xAfFc9F8d950969b46b54e77758BbFf7e000c87e6` | records on-chain | `verifyAndRecord` gasUsed 1,812,066 < 16,777,216 |
| Falcon-512 (NIST level 1 lattice) | AereFalcon512Verifier | `0x4E8e9682329e646784fB3bd01430aA4bA54D8fFC` | records on-chain | verify fits under the cap; demonstrated inside a full ERC-4337 userOp (gasUsed 10,278,313) and hybrid auth (gasUsed 10,299,873), both < 16,777,216 |
| Falcon-1024 (NIST level 5 lattice) | AereFalcon1024Verifier | `0xF0aFA59BaB2058e4B6e6B424b7f76750F1F66e36` | records on-chain (via precompile) | in this pure-Solidity contract `verifyAndRecord` is about 21.7M gas and EXCEEDS the 16,777,216 cap, so its `verify()` is a pure view; the scheme now records on-chain through the native Falcon-1024 precompile at `0x0AE2`, live on mainnet since block 9,189,161 (AIP-7) |
| ML-DSA-44 / Dilithium2 (FIPS 204 lattice) | AereMLDSA44Verifier | `0xf1F7A6Acd82D5DAf9AF3166a2F736EE52C5F85AE` | records on-chain (via precompile) | a full verify in this pure-Solidity contract is about 52.9M gas and EXCEEDS the cap, so its `verify()` is a pure view; the scheme now records on-chain through the native ML-DSA-44 precompile at `0x0AE3`, live on mainnet since block 9,189,161 (AIP-7) |
| Falcon/Dilithium-family lattice core (ring arithmetic, norm), n=64 demo | AereLatticeVerifier | `0x60c06E6A3CC201B46A16650be096C6E45424dfD9` | building block | supports the Falcon verifiers |
Validation vectors used, as repo fixtures:
- Falcon-512: `contracts/test/falcon512_kat0.json` (official NIST KAT).
- Falcon-1024: `contracts/test/falcon1024_kat0.json` (official round-3 KAT).
- XMSS: `contracts/test/fixtures/xmss-sha2_10_256-kat.json` (xmss-reference vectors).
- ML-DSA-44: `contracts/test/fixtures/mldsa44-acvp-tg8.json` (NIST ACVP
ML-DSA-sigVer, 15/15 cases reproduce NIST's expected results).
- SPHINCS+/SLH-DSA: `contracts/test/fixtures/sphincs-sha2-128s-acvp-tg31.json`
(NIST ACVP SLH-DSA-sigVer, 14/14 cases reproduce NIST's expected results).
### Account-layer primitives (live on chain 2800)
- **AerePQCAccountFactory** at `0xd5315Ea7caa60d320c4f34b1bEd70dd9cc02CE58`. A
CREATE2 factory that deploys an ERC-4337 v0.7 smart account whose sole owner is
a Falcon-512 public key (897 bytes), with no classical ECDSA fallback. Both
`validateUserOp` and EIP-1271 `isValidSignature` are decided by the live
AereFalcon512Verifier.
- **AerePQCAccount_sample** at `0xa42a5e7F72E46BadC11367650Ec34D676194326f`. A
sample account owned by a real Falcon-512 key, used to prove the EIP-1271 accept
path (`0x1626ba7e`) and a full userOp through the EntryPoint.
- **AereHybridAuth** at `0xc20390C9656ECe1AE37603c84E395bC898b3FAA1`. Authorizes
only if BOTH a secp256k1 ECDSA signature AND a Falcon-512 signature verify over
the same 32-byte hash. This is the pragmatic migration primitive: classical and
post-quantum in series, so an account is safe as long as either scheme holds.
### Standing of the suite
Across hash-based and lattice families, with each verifier validated against the
official NIST KAT/ACVP vectors and demonstrated on a live EVM chain:
we are not aware of any other public chain that verifies all of these on-chain.
We are not, however, the first public chain to verify a post-quantum signature
on-chain, and we do not claim to be. Algorand shipped the native Falcon-1024
`falcon_verify` AVM opcode in a stable release roughly ten months before AERE's
precompiles activated at block 9,189,161 (2026-07-12), and places Falcon deeper
in its stack than AERE does, inside its own state proofs. That prior art, with
sources and dates, is set out in
`aere-research/research/pqc-onchain-verification.md`, Section 8.
## Rationale
Pure-Solidity verifiers were built first because they run on the live chain today
with no client change and are auditable by anyone with an EVM. The design splits
cleanly along the EIP-7825 gas cap: the hash-based schemes and Falcon-512 fit
under the cap and can therefore record a verification result on-chain, which is
what an account or an application actually needs. Falcon-1024 and ML-DSA-44 are
too expensive to record in pure Solidity, so they are offered as `view` verifiers
(useful for off-chain-anchored checks and for correctness demonstration) until a
native precompile makes recording them feasible.
Hybrid ECDSA-plus-Falcon authorization (AereHybridAuth) was chosen as the first
account-facing product because it is the safest migration posture: it never
weakens the classical guarantee while adding the post-quantum one.
### Native precompile (live on mainnet chain 2800 since block 9,189,161)
Moving Falcon-1024 and ML-DSA-44 to record-on-chain, and making Falcon-512 and
SPHINCS+ far cheaper, requires a native precompile for SHAKE256 and for the
Falcon, ML-DSA, and SPHINCS verify routines. That work was implemented and
KAT-validated on an isolated Besu 26.4.0 scratch fork (source tag 26.4.0, commit
`d2032017`, chain 28099), which adds five native precompiles wrapping the
Bouncy Castle 1.83 BCPQC verifiers already on the client classpath (Falcon-512,
Falcon-1024, ML-DSA-44, SLH-DSA-SHA2-128s, SHAKE256), plus a native EIP-2935
8191-block lookback, with zero new dependencies and zero hand-rolled cryptography.
All NIST KAT and ACVP vectors pass in both directions, positive and negative
(15/15 ML-DSA-44 cases, 14/14 SLH-DSA cases). Measured full verify-and-record
gas on that fork: Falcon-512 86,336; Falcon-1024 145,496 (0.87% of the
16,777,216 cap); ML-DSA-44 351,050 (2.09%); SLH-DSA-SHA2-128s 558,276; SHAKE256
21,470. This moves Falcon-1024 (about 21.7M gas in pure Solidity) and ML-DSA-44
(about 52.9M gas) from view-only to record-on-chain with wide margin.
That fork is now LIVE on mainnet chain 2800, activated at block 9,189,161
(2026-07-12) as the AerePQC hard fork: a coordinated, client-only, flag-day
activation with no re-genesis and no state migration, which adds the five native
precompiles at the address band `0x0AE1`..`0x0AE5` (Falcon-512, Falcon-1024,
ML-DSA-44, SLH-DSA-SHA2-128s, SHAKE256) and the native EIP-2935 8191-block
lookback. The pure-Solidity AereFalcon1024Verifier and AereMLDSA44Verifier
contracts remain view-only, but the Falcon-1024 and ML-DSA-44 schemes now record
on-chain through the precompiles at `0x0AE2` and `0x0AE3`, demonstrated
end-to-end by a real Falcon-1024 attestation recorded through AerePQCAttestation
(`0x465d9E3b476BF98Aa1393079e240Db5D2a9bEA6A`, attestation tx `0xb659…9ec1`,
block 9,200,542, status 1). The activation is filed as its own Core AIP, AIP-7;
the mechanism is specified in `research/aip-draft-pqc-precompiles.md`. The
precompiles carry an internal self-audit only; an external audit is still pending
before they should secure material value.
## Backwards Compatibility
None. The verifiers and account primitives are additive contracts. They do not
change the EVM ruleset, existing accounts, or consensus. Ordinary secp256k1
accounts continue to work unchanged.
## Security Considerations
The single most important honesty point: **this is an application and account
layer capability, not post-quantum consensus.** AERE validators still sign
classical QBFT, so a quantum adversary that could forge validator signatures is
not addressed by these contracts. Do not read this AIP as a claim that AERE
consensus is post-quantum. It is not.
Further honest caveats:
- **Pure-Solidity view versus precompile record.** The pure-Solidity
AereFalcon1024Verifier and AereMLDSA44Verifier cannot record a result on-chain
because a recording transaction exceeds the 16,777,216 gas cap; their `verify()`
over `eth_call` is only as trustworthy as the node answering it. Since the
AerePQC hard fork (block 9,189,161, AIP-7), the Falcon-1024 and ML-DSA-44
schemes do record on-chain through the native precompiles at `0x0AE2` and
`0x0AE3`, which are consensus-anchored. Falcon-512, WOTS+, XMSS, and SPHINCS+
also record on-chain.
- **XMSS statefulness.** AereXmssVerifier verifies a signature but does not
enforce the signer's one-time-per-leaf state. Callers that rely on XMSS's
many-time security must track leaf usage off-chain. WOTS+ is one-time by
construction and must not be reused across messages.
- **Cost.** Falcon-512 verification is heavy (roughly 10.3M gas inside a full
userOp). It fits under the cap but is expensive; the native precompile is the
path to making it cheap.
- **Unaudited.** These verifiers have not had an external security audit. Their
assurance today rests on bit-for-bit agreement with the official NIST KAT/ACVP
vectors and on cross-checks against independent reference implementations, which
is strong evidence of correctness on the tested vectors but is not a substitute
for an audit.
## Reference Implementation and On-Chain Deployment
Verifier sources are under `contracts/contracts/` (glob for the PQC, Falcon,
XMSS, ML-DSA, and SPHINCS verifiers). All addresses in the tables above are copied
verbatim from `sdk-js/src/addresses.ts`. Each verifier is live and answerable via
`eth_call` on `https://rpc.aere.network` (chain ID 2800): official vectors return
true, tampered inputs return false. The recording transactions cited (XMSS,
SPHINCS+, the Falcon-512 account userOp, and the hybrid auth) are on-chain and
under the EIP-7825 cap.
## Copyright
Released to the public domain (CC0). No rights reserved.
</content>
+147
View File
@@ -0,0 +1,147 @@
# AIP-5: sAERE Receipt Token and AereSink Immutable Flywheel
## Preamble
| Field | Value |
| --- | --- |
| AIP | 5 |
| Title | sAERE Receipt Token and AereSink Immutable Flywheel |
| Author | AERE Foundation |
| Type | Standards Track |
| Category | ARC |
| Status | Final |
| Created | 2026-07-11 |
| Requires | 2 |
| Ratification | Foundation-ratified (pre-decentralization) |
## Abstract
This AIP documents AERE's protocol-revenue flywheel: an immutable three-bucket
router (AereSink) that splits incoming fee streams into burn, buyback-and-burn,
and staker-yield, and an ERC-4626 receipt token (sAERE) whose exchange rate drifts
up as the staker-yield bucket flows in. Neither contract has an owner, admin, or
upgrade path. It is a retro-filed record of contracts already live on chain 2800.
## Motivation
AERE wanted a single, credible mechanism to accrue protocol revenue to AERE
holders that no one, including the Foundation, could later divert or turn off. The
two failure modes to avoid were (1) an admin-controlled treasury that could
redirect fees, and (2) a receipt token whose yield could be gamed by
flash-loan sandwich attacks around the moment revenue arrives.
The design goal was an immutable router with fixed, publicly verifiable split
percentages, feeding a receipt vault that vests arrivals smoothly instead of in a
single-block step, so that stakers earn deterministically and no admin key is a
point of trust or a point of failure.
## Specification
### AereSink (immutable three-bucket router)
Address `0x69581B86A48161b067Ff4E01544780625B231676`. Source
`contracts/contracts/sink/AereSink.sol`.
Fee-source contracts call `flush(token, amount)` after approving the sink. The
sink splits the amount into three buckets by immutable basis points that MUST sum
to 10000 (the constructor reverts otherwise):
- **BURN_BPS = 1500 (15%)** to AereFeeBurnVault
(`0x696afDF4f814e6Fd6aa45CE14C498ed9375fB2c6`), an extra burn on top of the
37.5% coinbase burn in AIP-2.
- **BUYBACK_BPS = 4000 (40%)** buyback-and-burn: non-AERE fees are swapped to AERE
via the DEX router and then burned.
- **STAKER_YIELD_BPS = 4500 (45%)** to the sAERE vault, lifting its exchange rate.
If the flushed token is AERE (WAERE, `0x7e84d7d66d5da4cfE46Da67CDEeB05B323e1f5e8`),
the burn and buyback buckets merge into a single transfer to the burn vault and the
staker bucket transfers to sAERE directly, no swap. If the token is not AERE, each
bucket is swapped along `[token, AERE]` with an oracle-derived `amountOutMin` floor
so the swap cannot be sandwiched via pool-reserve manipulation.
Immutability invariants (enforced in code and tests): no owner, no admin, no
governance role; no `setBucket`, `setRecipient`, `setRouter`, or `pause`; bucket
recipients and basis points are set at deploy and are immutable. Replacing the
router means redeploying and rewiring fee sources, not mutating this contract.
### sAERE (ERC-4626 receipt token)
Address `0xA2125bE9C6fd4196D9F94757Df18B3a2A5e650b0`. Source
`contracts/contracts/staking/sAERE.sol`.
sAERE is a standard ERC-4626 vault: deposit WAERE, receive sAERE shares. The
WAERE-per-sAERE rate rises as the staker-yield bucket arrives. Two hardening
choices are normative:
- **Linear drip.** Arrivals are not recognized as an instantaneous jump in
`totalAssets`. They vest linearly over `DRIP_DURATION = 7 days`. `totalAssets()`
excludes the not-yet-vested reserve, so share price grows continuously, not in a
single-block step. `sync()` is permissionless and is called inside every deposit
and withdraw; AereSink also pings it after transferring yield in.
- **Inflation-attack widening.** `_decimalsOffset()` is overridden to 6 and a
dead-share seed is minted at construction, so the classic first-depositor
inflation attack is economically infeasible.
sAERE has no admin, no owner, no pause, no upgrade proxy, and no parameter
setters. `DRIP_DURATION` and the decimal offset are compile-time constants.
## Rationale
Immutability is the whole point. An admin-configurable router would reintroduce
exactly the trust assumption the flywheel is meant to remove, so AereSink has no
setters at all; changing the policy requires a visible redeploy and a rewire that
the community can observe. The 15/40/45 split weights holder accrual (buyback plus
staker yield is 85%) over pure burn (15%), on the view that a rising sAERE rate
plus buyback pressure is a stronger, more legible incentive than a large flat burn
alone.
The linear drip exists specifically to defeat the deposit-then-flush-then-redeem
sandwich: if yield landed as a step, a flash-loaned depositor could capture it in
one block. Vesting over seven days makes the per-block share-price change
negligible relative to any single attacker's position. Choosing an ERC-4626
receipt token (rather than a rebasing balance) keeps sAERE composable with the
wider DeFi tooling that already understands 4626.
## Backwards Compatibility
None. sAERE is a standard ERC-4626 token and AereSink is an additive router. They
introduce no new base token (AERE, via its WAERE wrapper, is the only token) and do
not change existing contracts. Fee sources opt in by calling `flush`.
## Security Considerations
- **No admin is a feature and a constraint.** Because neither contract has an
owner, a bug in either cannot be patched in place; the only remedy is a redeploy
and a rewire of fee sources. This is the accepted trade for removing admin trust.
- **Sandwich resistance depends on the oracle.** The buyback swap's `amountOutMin`
is computed from an oracle price floor, not from pool reserves. If AereSink is
deployed with a zero oracle (a test-only mode), swaps accept any non-zero output
and are sandwich-able. Production deployment MUST set a real oracle. The drip
mitigates the yield-timing sandwich independently of the swap path.
- **Swap liveness.** If a non-AERE buyback swap fails (no liquidity, slippage),
the tokens remain as dust and `sweepDust()` can re-flush later; a single dead
pair does not lock the whole flush. This is a liveness, not a safety, concern.
- **Unaudited.** These contracts have not had an external security audit. They
have been hardened across several internal review rounds (the drip and the
inflation-offset widening are outputs of those rounds), but internal review is
not an external audit.
- **Thin usage.** As with the rest of AERE today, real flush volume through the
sink is thin. The mechanism is live and immutable, but its economic effect is
only as large as the fee streams actually routed into it.
## Reference Implementation and On-Chain Deployment
- `contracts/contracts/sink/AereSink.sol` -> `0x69581B86A48161b067Ff4E01544780625B231676`
- `contracts/contracts/staking/sAERE.sol` -> `0xA2125bE9C6fd4196D9F94757Df18B3a2A5e650b0`
- Burn destination: AereFeeBurnVault `0x696afDF4f814e6Fd6aa45CE14C498ed9375fB2c6` (AIP-2)
- Base token: WAERE `0x7e84d7d66d5da4cfE46Da67CDEeB05B323e1f5e8`
- Deploy script: `contracts/deploy/deploy-saere-sink-stack.js` (splits 1500/4000/4500)
All addresses copied verbatim from `sdk-js/src/addresses.ts`. The immutable split
is readable on-chain via `AereSink.BURN_BPS()`, `BUYBACK_BPS()`, and
`STAKER_YIELD_BPS()`, which sum to 10000.
## Copyright
Released to the public domain (CC0). No rights reserved.
</content>
+155
View File
@@ -0,0 +1,155 @@
# AIP-6: ERC-4337 Passkey and Gasless Onboarding Stack
## Preamble
| Field | Value |
| --- | --- |
| AIP | 6 |
| Title | ERC-4337 Passkey and Gasless Onboarding Stack |
| Author | AERE Foundation |
| Type | Standards Track |
| Category | ARC |
| Status | Final |
| Created | 2026-07-11 |
| Requires | None |
| Ratification | Foundation-ratified (pre-decentralization) |
## Abstract
This AIP documents AERE's account-abstraction onboarding stack: ERC-4337-shaped
EntryPoints, passkey (WebAuthn / secp256r1) smart accounts that use the Fusaka
P-256 precompile, and a set of paymasters that let a new user transact without
first holding AERE for gas. It is a retro-filed record of contracts already live
on chain 2800.
## Motivation
The single hardest step in crypto onboarding is the cold start: a new user needs
gas to make their first transaction, but they cannot get gas without already
transacting or bridging in. AERE's answer is account abstraction plus paymasters,
so a user can create a wallet secured by a device passkey (Face ID, Touch ID,
Windows Hello, a security key) and have their first transactions sponsored, with
no seed phrase and no pre-funded gas.
Fusaka makes the passkey half cheap. Its RIP-7951 precompile at address `0x100`
verifies a secp256r1 / P-256 signature natively for a fixed cost of about 3,450
gas, versus roughly 250,000 gas to do the same check in Solidity. That is what
makes a passkey-signed userOp economical.
## Specification
### EntryPoints
- **AereEntryPoint** at `0x19773ba45287A64B05d0BCBD59D1371BF51Bd5D2`. A
lightweight ERC-4337-compatible EntryPoint used by the paymasters.
- **AereEntryPointV2** at `0x8D6f40598d552fF0Cb358b6012cF4227B86aF770`. The
current ERC-4337-shaped EntryPoint that the V2 accounts validate against.
### Passkey accounts
- **AerePasskeyAccountFactory** at `0xfB0eF980667A79Fe1AB69c5f2d512118F1B30739`.
V1, legacy. Single-passkey-owner smart account. Retained for the original demo
account.
- **AerePasskeyAccountFactoryV2** at `0x5FFa9a6487DA4641a1A1e7900ff2bD4525D34fdA`.
V2. Accounts are MultiOwnable (passkey owners and EOA owners), expose an
ERC-4337 `validateUserOp` shim and EIP-1271 `isValidSignature`, and support
recovery by an existing owner adding a new owner. `predictAddress(initialOwners,
salt)` gives the counterfactual address.
Signature verification for passkey owners routes through the Fusaka P-256
precompile at `0x100`.
### Paymasters
- **AereOnboardingPaymaster** at `0x4058E406475Dbed7056Aee0c808f293F05fEa879`.
Foundation-funded sponsorship for cold-start users. Rate-limited to 3 lifetime
userOps per sender and a sitewide cap of 100 sponsored userOps per day. This is
the "your first few transactions are free" primitive.
- **AereAppPaymasterFactory** at `0xEC22603E8712cBc5c31E53370D10f1a80CcB4DF0`. A
permissionless factory: any dApp clones its own AereAppPaymaster to sponsor its
own users on its own budget.
- **AereTokenPaymasterV2** at `0x217f56a5b0C7f35abe4D2fff924A6c13B85d7243`. Pay gas
in any whitelisted ERC-20 instead of AERE. `withdrawToken` uses `transfer()` so
the Foundation can sweep collected gas revenue (the V1 bug that stranded
collected tokens is fixed here).
- **AereStakeQuotaPaymasterV2** at `0xE50464ca7E8E7F542D1816B3172a2330cFE384E8`.
Stake AERE to earn a daily free-transaction quota, a Tron-style UX. It reads the
real AereStaking and AereLockedStaking state with bounded loops.
These V2 paymasters are the canonical ones; the relayer, website, and SDK point
here, not at the deprecated V1 paymasters.
## Rationale
The stack follows ERC-4337 rather than inventing a bespoke account model so that
existing bundler and account-abstraction tooling transfers directly, and so that
accounts are contracts (upgradable ownership, recovery, EIP-1271) rather than
raw EOAs.
Passkeys were chosen for the owner key because they remove the seed phrase, which
is the biggest single cause of self-custody loss, and because Fusaka's native
P-256 precompile makes on-chain WebAuthn verification cheap enough to use in every
userOp. The V2 accounts are MultiOwnable specifically to provide a recovery path:
an existing owner can add a new owner, so losing one device does not brick the
account.
Multiple paymasters exist because "gasless" means different things in different
contexts: a one-time cold-start subsidy (onboarding), a dApp sponsoring its own
users (app factory), paying gas in a stable ERC-20 (token paymaster), or earning
free transactions by staking (stake-quota). Each is a distinct policy, so each is
a distinct, narrowly-scoped paymaster rather than one over-configurable contract.
## Backwards Compatibility
None. These are additive contracts. Ordinary EOAs and existing contracts are
unaffected. Builders opt in by deploying accounts through the factories and wiring
a paymaster.
## Security Considerations
- **The EntryPoints are AERE's own implementations.** They are ERC-4337-compatible
in shape and interface, not the canonical audited Ethereum ERC-4337 EntryPoint
singleton. Integrators should treat them as AERE-specific and not assume
byte-level parity with mainnet Ethereum's EntryPoint.
- **Gasless is subsidized, not free.** AereOnboardingPaymaster spends Foundation
funds. Its 3-per-sender lifetime limit and 100-per-day sitewide cap exist to
bound abuse and cost; sponsorship is not an unlimited, permanent entitlement and
can be exhausted or turned down. Users past the free tier pay gas normally (in
AERE, in a whitelisted ERC-20, or via a stake quota).
- **Recovery is owner-mediated.** V2 account recovery works by an existing owner
adding a new owner. If all owner devices are lost and no recovery owner was
pre-registered, the account is not recoverable. Users should add a backup owner.
- **Passkey trust model.** Passkey security depends on the device's secure
element and the platform WebAuthn implementation. A compromised device or a
platform vulnerability is outside what the contract can defend against.
- **Single client, unaudited.** As with the rest of AERE today, this runs on a
single client (Besu QBFT) under a small Foundation-operated validator set, and
these contracts have not had an external security audit. The V1 passkey account
and V1 paymasters had known gaps (V1 was a demo-grade single-owner account with
no recovery, and two V1 paymasters had confirmed bugs); V2 closed those, and the
V1 contracts are left on-chain but deprecated. New integrations MUST use the V2
addresses.
## Reference Implementation and On-Chain Deployment
Sources under `contracts/contracts/passkey/` (accounts, factories, MultiOwnable,
EntryPointV2, WebAuthn, P256Probe) and `contracts/contracts/` plus
`contracts/contracts/paymaster/` (the paymasters and EntryPoint). Addresses:
- AereEntryPoint `0x19773ba45287A64B05d0BCBD59D1371BF51Bd5D2`
- AereEntryPointV2 `0x8D6f40598d552fF0Cb358b6012cF4227B86aF770`
- AerePasskeyAccountFactory (V1) `0xfB0eF980667A79Fe1AB69c5f2d512118F1B30739`
- AerePasskeyAccountFactoryV2 `0x5FFa9a6487DA4641a1A1e7900ff2bD4525D34fdA`
- AereOnboardingPaymaster `0x4058E406475Dbed7056Aee0c808f293F05fEa879`
- AereAppPaymasterFactory `0xEC22603E8712cBc5c31E53370D10f1a80CcB4DF0`
- AereTokenPaymasterV2 `0x217f56a5b0C7f35abe4D2fff924A6c13B85d7243`
- AereStakeQuotaPaymasterV2 `0xE50464ca7E8E7F542D1816B3172a2330cFE384E8`
All addresses copied verbatim from `sdk-js/src/addresses.ts`. The Fusaka P-256
precompile at `0x100` (RIP-7951) is active on chain 2800 from the Fusaka
activation (unix 1780220351, block 2,106,597).
## Copyright
Released to the public domain (CC0). No rights reserved.
</content>
+239
View File
@@ -0,0 +1,239 @@
# AIP-7: AerePQC Hard-Fork Activation (Native PQC Precompiles and Extended EIP-2935 Lookback)
## Preamble
| Field | Value |
| --- | --- |
| AIP | 7 |
| Title | AerePQC Hard-Fork Activation (Native PQC Precompiles and Extended EIP-2935 Lookback) |
| Author | AERE Foundation |
| Type | Standards Track |
| Category | Core |
| Status | Final |
| Created | 2026-07-16 |
| Requires | 4 |
| Ratification | Foundation-ratified (pre-decentralization) |
## Abstract
This AIP documents the AerePQC hard fork, a coordinated, client-only activation on
mainnet chain 2800 at block 9,189,161 (2026-07-12) that added two Core changes: five
native post-quantum verification precompiles at the address band `0x0AE1`..`0x0AE5`
(Falcon-512, Falcon-1024, ML-DSA-44, SLH-DSA-SHA2-128s, and SHAKE256), and the
native EIP-2935 8191-block historical-block-hash lookback. It is a retro-filed
record of a change already live on chain 2800. It is explicit that this fork
changed only the execution layer; AERE consensus is still classical secp256k1
ECDSA QBFT and is not post-quantum.
## Motivation
AIP-4 documents AERE's pure-Solidity post-quantum verifier suite. Two of those
schemes, Falcon-1024 and ML-DSA-44, cannot record a verification result in a
state-changing transaction in pure Solidity, because a recording transaction
exceeds the EIP-7825 per-transaction gas cap of 16,777,216 (2^24). Their
verification is correct but was reachable only as a read-only `eth_call` view,
which is only as trustworthy as the node answering it and is not consensus
anchored. The other schemes that do fit under the cap (notably Falcon-512, at
roughly 10.5M gas inside a full userOp) are correct but expensive.
The fix that removes both limits is a native precompile: the dominant cost inside
every one of these verifiers is SHAKE / Keccak-f[1600] streaming plus lattice ring
arithmetic, and moving that into audited native code, wrapped as an EVM precompile,
reduces each verification by more than an order of magnitude. This is the same
approach Ethereum uses for other heavy primitives (RIP-7951 for native P-256,
EIP-2537 for native BLS12-381). Bundling the native EIP-2935 write path into the
same fork gave the network extended trustless block-hash lookback in one scheduled
activation instead of two.
The goal was to make Falcon-1024 and ML-DSA-44 record on-chain within the same
16,777,216 per-transaction cap AERE keeps as a functional peer of Ethereum L1, to
make the schemes that already fit far cheaper, and to do so as a client-only fork
with no re-genesis and no state migration.
## Specification
### Activation point
The AerePQC hard fork activated on mainnet chain 2800 at **block 9,189,161**
(2026-07-12). It is configured as a Besu `futureEips` milestone with activation
timestamp `futureEipsTime = 1783820272` (2026-07-12 01:37:52 UTC). Activation added
precompile behavior and the EIP-2935 write path only. It did NOT change how blocks
are proposed, signed, or committed: blocks are still produced and committed by the
QBFT validator set signing classical secp256k1 ECDSA committed seals.
### Native PQC precompiles
The fork registers five native precompiles that wrap the Bouncy Castle 1.83
BCPQC verifiers already present on the client classpath, behind a dedicated
classloader-isolation boundary so that Bouncy Castle 1.83 cannot collide with the
older Bouncy Castle that Besu bundles. There is zero new hand-rolled cryptography.
| Address | Precompile | Standard | Output |
| --- | --- | --- | --- |
| `0x0000000000000000000000000000000000000AE1` | Falcon-512 verify | NIST round-3 Falcon | valid / invalid |
| `0x0000000000000000000000000000000000000AE2` | Falcon-1024 verify | NIST round-3 Falcon | valid / invalid |
| `0x0000000000000000000000000000000000000AE3` | ML-DSA-44 verify | FIPS 204 (internal interface) | valid / invalid |
| `0x0000000000000000000000000000000000000AE4` | SLH-DSA-SHA2-128s verify | FIPS 205 (internal interface) | valid / invalid |
| `0x0000000000000000000000000000000000000AE5` | SHAKE256 | FIPS 202 XOF | requested output bytes |
Each verify precompile is a pure function of its input bytes: it parses a packed,
length-prefixed public key, signature, and message; reverts deterministically on
malformed structure; and otherwise returns a valid/invalid decision. SHAKE256
returns the requested number of output bytes. Because a precompile result feeds a
consensus-critical state transition, every node MUST return byte-identical output
for identical input; the verify paths used are deterministic and integer-only
(Falcon verification never touches the floating-point signing path).
The full input encodings, per-scheme parameters, revert-versus-`0x00` semantics, and
gas model are specified in `research/aip-draft-pqc-precompiles.md`. Gas figures
below are the values measured on the pre-activation scratch fork (chain 28099) and
carried to mainnet.
| Scheme | Marginal verify-op gas | Full verify-and-record tx gasUsed | Share of 16,777,216 cap |
| --- | --- | --- | --- |
| SHAKE256 | 60 + 12/word | 21,470 | 0.13% |
| Falcon-512 | 40,000 | 86,336 | 0.51% |
| Falcon-1024 | 75,000 | 145,496 | 0.87% |
| ML-DSA-44 | 55,000 | 351,050 | 2.09% |
| SLH-DSA-SHA2-128s | 350,000 | 558,276 | 3.33% |
These figures move Falcon-1024 (about 21.7M gas in pure Solidity) and ML-DSA-44
(about 52.9M gas) from view-only to record-on-chain, and drop Falcon-512 from about
10.49M gas to 86,336.
### Native EIP-2935 (extended block-hash lookback)
The fork also activates the native EIP-2935 history-storage system contract at the
canonical address `0x0000F90827F1C53a10cb7A02335B175320002935`, a ring buffer of
the last 8191 block hashes. At the start of every block, the parent block hash is
written into slot `(number - 1) % 8191` by a consensus system call, before any user
transaction runs. There is no keeper, relayer, or Foundation key involved; the
write is a condition of block validity. Contracts read a hash by `STATICCALL` with
the 32-byte block number; a query outside the served window `[number - 8191,
number - 1]` reverts. At AERE's 0.5-second block time, 8191 blocks is roughly 68
minutes of trustless lookback, against the roughly 128 seconds the 256-block
`BLOCKHASH` opcode gives. The system contract's runtime bytecode is byte-identical
to Ethereum's Pectra deployment and was deployed post-genesis via the canonical
keyless "Nick's-method" transaction, so the block-0 state root is unchanged.
## Rationale
Native precompiles rather than more Solidity optimization: the pure-Solidity
verifiers are already heavily optimized (hand-written Keccak-f assembly) and the
remaining cost is intrinsic. Only native code removes it, which is the same
reasoning that justified RIP-7951 and EIP-2537 on Ethereum.
Wrapping a maintained, audited native library (Bouncy Castle) rather than
hand-rolling the verify keeps the security boundary at a reviewed implementation
plus a thin parsing adapter. The classloader-isolation boundary exists because Besu
bundles an older Bouncy Castle, and a naive classpath addition risks silently
binding the wrong implementation.
A single coordinated hard fork with no re-genesis was chosen over a chain restart
so the network kept its entire history, state, and validator keys, consistent with
the same discipline applied in AIP-3. Bundling EIP-2935 into the same activation
gave the network extended lookback and post-quantum verification in one scheduled
event. Keeping the same 16,777,216 per-transaction gas cap as Ethereum L1, rather
than raising a local gas limit, is deliberate: it is why the native precompile,
not an unbounded gas budget, is the correct fix.
The precompiles were placed at the `0x0AE1`..`0x0AE5` band already used on the
scratch fork, above the Ethereum standard precompiles, the EIP-2537 BLS12-381
range, and the RIP-7951 P-256 precompile at `0x100`, so upstream precompile
allocations do not collide. If upstream Ethereum later allocates into this band,
AERE will re-evaluate to preserve equivalence.
## Backwards Compatibility
None that breaks existing contracts. Before activation the five band addresses were
empty accounts and the EIP-2935 system address had no code; a call to any of them
behaved as a call to an empty address. After block 9,189,161 they behave as
precompiles and as the consensus-written history ring buffer. The pure-Solidity
verifiers documented in AIP-4 remain deployed and unchanged; contracts MAY migrate
to the precompiles for lower gas but are not required to. Integrators SHOULD gate
precompile use on chain height (past the activation block), not on probing.
Because AERE runs all validators under one operator and one client today,
activation was a flag-day upgrade of the client build across the validator set at
the fork block. A node that had not upgraded would compute different results for
calls into the band and fork off, so the upgrade was mandatory for all validators
and archive/RPC nodes at the fork block.
## Security Considerations
**This fork does not make AERE consensus post-quantum.** Validators continue to sign
classical secp256k1 QBFT committed seals. The precompiles are an application and
account layer capability. Any claim of post-quantum consensus on the basis of this
fork would be false and must not be made. Isolated-testnet work on a Falcon quorum
certificate and a second execution client is separate R&D and is not live on chain
2800.
**Single operator, one client.** Chain 2800 runs seven QBFT validators (f=2,
quorum 5-of-7), all Foundation-operated, on a single execution client (Hyperledger
Besu). Even at f=2, the validators are one operator and one client, so a consensus
bug in a precompile is not caught by client diversity, because there is no second
live client. This raises, not lowers, the bar for an external audit and for
extensive differential testing.
**Determinism and gas agreement.** Every node must compute the identical
accept/reject and the identical gas charge. The verify paths are deterministic and
integer-only, and the adapter reads no chain state or block context. Gas is priced
from native microbenchmarks so a precompile call cannot consume disproportionate
wall-clock time for its gas; malformed input reverts and consumes all supplied gas,
so it cannot be used as a cheap probe.
**A valid signature is not authorization.** A valid decision from a verify
precompile establishes only that the signature is valid for the given public key and
message. It does not establish freshness, ordering, replay protection, or key
ownership; consuming contracts (for example AerePQCAttestation) add their own nonce
and domain separation. For hash-based schemes with one-time-per-leaf state (XMSS,
WOTS+), a valid verification does not prove the signer has not reused a leaf.
**External audit pending.** The fork, the five precompiles, and the consuming
contracts carry an internal self-audit only. They have not undergone an external
security audit. Their assurance today rests on bit-for-bit agreement with the
official NIST KAT and ACVP vectors, cross-checks against independent
reimplementations (including a second execution client that runs the precompiles
byte-identically on an isolated testnet), and an on-chain end-to-end attestation.
They should not secure material value until an external audit lands.
## Reference Implementation and On-Chain Deployment
This is a client and chain-configuration change, so the precompile band and the
EIP-2935 system contract have no per-scheme deployment artifact of their own; the
authoritative artifact is the AERE Besu fork (base `hyperledger/besu:26.4.0`, gold
binary SHA-256 `7c5c0743088e9fa765d54c745814601b3c7a27a892e396156f88092b34c80772`)
and the chain history from block 9,189,161 onward.
On-chain evidence:
- **AerePQCAttestation** at `0x465d9E3b476BF98Aa1393079e240Db5D2a9bEA6A` (verbatim
from `sdk-js/src/addresses.ts`) is a permissionless, no-custody attestation
registry that verifies through the live precompiles. A real Falcon-1024 signature
(Bouncy Castle 1.83) was verified through the `0x0AE2` precompile and recorded on
mainnet: attestation tx `0xb659…9ec1`, block 9,200,542, gasUsed 692,206, status 1.
A transaction success alone proves the live precompile returned valid, because the
contract reverts `PQCVerificationFailed` otherwise.
- **AereCryptoRegistry** at `0xaE6fC596bb3eCcbf5c5D02D67B0Ef065b3Afbaa5`, a
crypto-agility registry over the five live precompiles.
- **AerePQCKeyRegistry** at `0x1eCa3c5ADcBD0b22636D8672b00faC6D89363691`
(proof-of-possession; `precompileFor(1) == 0x0ae1` confirmed on-chain), and
**AereThresholdPQCRegistry** at `0x9a6096F6FB3a7E54cF70DE12Cb3903Ae79D1C213`
(t-of-n post-quantum authorization via the precompiles).
- **EIP-2935 history contract** at `0x0000F90827F1C53a10cb7A02335B175320002935`,
deployed via the canonical keyless transaction
`0x67139a552b0d3fffc30c0fa7d0c20d42144138c8fe07fc5691f09c1cce632e15` (mined at
block 9,182,379, status 1); `eth_getCode` returns the canonical Pectra runtime,
which encodes the 8191-block (`0x1fff`) ring buffer.
All addresses above are copied verbatim from `sdk-js/src/addresses.ts`. The live
precompile band, its activation block, and the EIP-2935 window are verifiable on
`https://rpc.aere.network` (chain ID 2800): the current head is well past block
9,189,161, `eth_getCode` at the EIP-2935 address returns the 8191-block runtime, and
the recorded Falcon-1024 attestation is retrievable at block 9,200,542. The design
and gas model are specified in `research/aip-draft-pqc-precompiles.md`; the
pure-Solidity verifier suite that the precompiles accelerate is documented in AIP-4.
## Copyright
Released to the public domain (CC0). No rights reserved.
+118
View File
@@ -0,0 +1,118 @@
# AERE Improvement Proposals (AIPs)
An AIP (AERE Improvement Proposal) is a design document that describes a change
to the AERE Network (chain ID 2800), its contracts, its consensus parameters, or
its processes. An AIP records the motivation for a change, the exact mechanism,
the rationale for the design, and, when the change is already live, the on-chain
addresses and transactions that prove it exists.
AIPs are AERE's equivalent of Ethereum's EIP/ERC process. They exist so that any
reader, human or machine, can reconstruct why the chain works the way it does
from a single canonical, plain-text source instead of from marketing pages.
This directory is a local, self-contained scaffold. It is not published anywhere
and is not wired into any build or deployment. It is intended to be the seed of a
public AIP repository once the process is stable.
## What belongs in an AIP
- A protocol or consensus change (block time, fee routing, precompiles).
- A new contract standard or interface that other builders are expected to
integrate against.
- A token-standard or account-standard convention (ARC).
- A process or governance change (Meta).
Things that do not belong in an AIP: bug-fix redeploys that preserve an existing
interface (those are tracked in `sdk-js/src/addresses.ts` deprecation notes),
routine parameter tuning inside an already-ratified bound, and pure documentation.
## Lifecycle
An AIP moves through a small number of statuses. The happy path is
`Draft -> Review -> Last Call -> Final`. Standards that are never "done" (for
example a registry that keeps growing) settle in `Living` instead of `Final`.
| Status | Meaning |
| --- | --- |
| Draft | The proposal is written and formatted correctly and has an author. It may still change substantially. |
| Review | The author has marked it ready for wider scrutiny. Open questions are being resolved. |
| Last Call | Final review window. A fixed review period is stated. If no blocking issue is raised, it advances. |
| Final | Accepted and, for already-shipped work, live on chain 2800. The mechanism is now stable and should not change in a breaking way. |
| Living | Accepted and expected to keep being updated (for example an index or a registry-style standard). |
| Withdrawn | The author or the editors abandoned the proposal. Terminal. |
| Stagnant | Inactive in Draft or Review for an extended period. Can be revived. |
Retro-filed AIPs (documents written after the change already shipped) enter
directly at `Final` or `Living` and carry a note that they are backfilling
history. AIP-2 through AIP-7 in this scaffold are retro-filed.
## Categories and types
Every Standards Track AIP names one category:
- **Core**: consensus, block production, fee/burn accounting, precompiles, and
anything that changes how the chain itself behaves. Requires a client or
genesis/config change.
- **Networking**: peer-to-peer protocol, sync, and node-to-node messaging.
- **Interface**: contract-level interfaces, ABIs, RPC conventions, and
verification surfaces that builders integrate against.
- **ARC (token standards)**: AERE Request for Comment. Application and token
standards, for example ERC-20/4626 receipt tokens and ERC-4337 account
conventions, as adopted on AERE.
- **Meta**: process, governance, and the AIP process itself.
Types: Standards Track (Core, Networking, Interface, ARC), Meta, and
Informational. Informational AIPs give guidance and do not mandate anything.
## Honest governance note (read this)
AERE is not yet trustlessly governed. Today the network runs seven validators
under a single operator, one client (Hyperledger Besu QBFT), no external security
audit, and thin real usage. In that reality an AIP is not ratified by an on-chain
vote of independent stakeholders. It is **Foundation-ratified**: the AERE
Foundation account (`0x0243A4f47D44b40b65D33f20329dE20D00c6f3C3`, a single-key
Foundation-controlled account, not a deployed multisig) is the final editor and
approver.
Every AIP that predates validator and client decentralization carries the label
**"Foundation-ratified (pre-decentralization)"** so no reader mistakes editorial
ratification for trustless governance. As the validator set opens up and a second
client and independent stakers come online, the process is expected to migrate to
stake-weighted or validator-weighted ratification. That migration will itself be a
Meta AIP. Until then, the honest description of AERE governance is: a Foundation
publishes proposals, ships them, and records them here for public audit.
## How to file an AIP
1. Copy `aip-template.md` to `AIP-N.md`, where N is the next free integer.
2. Fill in every required section. Do not delete a section header; if a section
does not apply, write "None" under it.
3. Cite on-chain addresses verbatim from `sdk-js/src/addresses.ts`. Never invent
an address, a transaction hash, or a gas number. If a number has not been
measured, write "to be measured" rather than guessing.
4. Add a row to the index below.
5. Open it for editorial review. Until decentralization, the editor is the
Foundation.
## Index
| AIP | Title | Type / Category | Status | Note |
| --- | --- | --- | --- | --- |
| [1](./AIP-1.md) | AIP Purpose and Process | Meta | Living | The process itself |
| [2](./AIP-2.md) | Coinbase Fee-Burn Routing (37.5%) | Standards Track / Core | Final | Foundation-ratified (pre-decentralization) |
| [3](./AIP-3.md) | Sub-Second Block Period (500 ms QBFT) | Standards Track / Core | Final | Foundation-ratified (pre-decentralization) |
| [4](./AIP-4.md) | On-Chain Post-Quantum Signature Verification Suite | Standards Track / Interface | Final | Foundation-ratified (pre-decentralization) |
| [5](./AIP-5.md) | sAERE Receipt Token and AereSink Immutable Flywheel | Standards Track / ARC | Final | Foundation-ratified (pre-decentralization) |
| [6](./AIP-6.md) | ERC-4337 Passkey and Gasless Onboarding Stack | Standards Track / ARC | Final | Foundation-ratified (pre-decentralization) |
| [7](./AIP-7.md) | AerePQC Hard-Fork Activation (Native PQC Precompiles and Extended EIP-2935 Lookback) | Standards Track / Core | Final | Foundation-ratified (pre-decentralization) |
## Conventions
- Files are named `AIP-N.md`.
- One AIP per change. If a change has a Core part and an application part, either
file two AIPs or state clearly which layer each section addresses.
- Addresses, transaction hashes, gas figures, and block numbers must be
reproducible from the chain or from a repo fixture. Marketing numbers (for
example a design-ceiling throughput) are never presented as measured results.
</content>
</invoke>
+66
View File
@@ -0,0 +1,66 @@
# AIP-N: Title in Title Case
## Preamble
| Field | Value |
| --- | --- |
| AIP | N |
| Title | Short descriptive title |
| Author | Name or handle |
| Type | Standards Track / Meta / Informational |
| Category | Core / Networking / Interface / ARC / (omit for Meta and Informational) |
| Status | Draft / Review / Last Call / Final / Living / Withdrawn / Stagnant |
| Created | YYYY-MM-DD |
| Requires | Comma-separated AIP numbers, or None |
| Ratification | Foundation-ratified (pre-decentralization), or the governance basis in force |
## Abstract
Two to four sentences. State what the AIP does in plain language. A reader should
understand the whole change from this paragraph alone.
## Motivation
Why this change is worth making. What problem it solves, who it helps, and what
goes wrong without it. Be concrete. If the change is already live, say what
prompted it.
## Specification
The exact, unambiguous mechanism. This is the normative section. For a contract
change, describe the interface, the state, the invariants, and the parameters
with their values. For a consensus change, give the exact configuration keys and
values and the activation point. Use MUST / SHOULD / MAY where a requirement is
binding on implementers.
For anything that touches gas or size, cite only numbers that are measured
on-chain or sourced from a repo fixture. Label any unmeasured number as
"to be measured".
## Rationale
Why the design is the way it is. Alternatives considered and why they were
rejected. Trade-offs accepted.
## Backwards Compatibility
What breaks, what does not, and how integrators migrate. "None" if nothing
breaks.
## Security Considerations
Attack surface, trust assumptions, and known weaknesses. This section is required
and must be honest. If the change depends on a trusted operator, a small
validator set, or an unaudited contract, say so here.
## Reference Implementation and On-Chain Deployment
For a live change: the contract source path(s) in this repo, the canonical
address(es) copied verbatim from `sdk-js/src/addresses.ts`, and the proving
transaction hashes and block numbers where available. For a not-yet-live change:
the branch or spec that implements it and the plan to ship.
## Copyright
Released to the public domain (CC0). No rights reserved.
</content>