Flight specification

NENE Flight is an optimistic rollup whose settlement and data availability live on NEAR Protocol. The gas asset is NENE (18 decimals, the same unit as nene-2250.meme-cooking.near). wNEAR is the second bridged asset. Chain id 8943 is the Rhea pool id, used here as a protocol constant, not as a claim that Rhea operates the rollup.

Aurora is an EVM implemented as a NEAR contract: every Ethereum-style transaction is a NEAR receipt. Flight does the opposite. A sequencer executes a batch off NEAR and posts one header: parent commit, post commit, transaction root, DA hash, gas, base fee. NEAR stores the header and the blob. It does not re-execute the batch unless someone proves a fault.

Soft finality is the sequencer's executed post-state, available as soon as the batch is sealed. On this devnet that is inside the same tick as inclusion. A production sequencer signs that receipt in well under a second; the design target is ~100ms.

NEAR inclusion is the propose_batch call. NEAR finality is already near one second, so the header is settled fast. Hard finality is the challenge window. Production constant: 1 hour (PRODUCTION_WINDOW_SEC). This devnet compresses it to 8 simulated NEAR blocks so the theft-or-slash choice is visible. The devnet clock is not mainnet NEAR.

FlightTx v1 is a typed envelope signed by secp256k1 over keccak, with chain id inside the digest. It is not an RLP legacy Ethereum transaction. The VM implements a documented opcode subset (arithmetic, comparison, bitwise, SHA3, environment, memory, storage, jumps, logs, CALL, RETURN, REVERT) with Yellow-Paper results and a v1 gas schedule that is intentionally not Ethereum's quadratic memory expansion. PUSH, DUP and SWAP ranges are complete.

The bird lane is a native transfer. Transfers do not pass through an AMM, so sequencer ordering cannot sandwich them. Calls hit the Hatch counter at 0x…8943, whose inc() selector is keccak("inc()")[0:4]. A CALL is one trace step; the callee runs atomically. Phase 3 splits call frames.

The batch payload is the ordered transaction hashes plus the forced deposits. Its keccak is the DA hash. A header that does not match the bytes is rejected. Design limit for the NEAR port: 64 KiB chunks, 512 KiB per batch, under NEAR receipt limits. At a few dozen bytes per transfer that is tens of thousands of transfers per settlement. That is a design target, not a benchmark of this TypeScript VM.

Deposits sit in a forced inbox. propose() refuses a batch that omits them, in order. That is the censorship-resistance property for bridging. The sequencer can still delay ordinary transactions for one batch; the bond and, later, sequencer rotation are what price that delay.

The sequencer publishes a hash after every step. A challenger bonds 100 NENE. Both parties bisect until they agree on the pre-state of a step and disagree on its post-state. The referee re-executes that step. If the sequencer was wrong, their 500 NENE bond is slashed to the challenger and the batch is discarded: soft state snaps back to the hard head and the transactions return to the mempool. If the challenger was wrong, their bond is slashed and the batch can still finalize.

On this devnet the referee re-executes the prefix. That is sound at testbed size. The production witness is a merkle multiproof of the touched accounts plus one Flight-ISA instruction, so the NEAR contract checks a single step inside its gas limit. The Rust contract in contracts/flight-settlement already verifies headers, the window, withdrawal proofs, and a bounded transfer-lane transition. The EVM one-step on NEAR is explicitly phase 3. Do not tell users it is already on-chain.

If nobody challenges, finalize() accepts the claimed root without re-execution. The fraud page lets that happen on purpose. An unchallenged +1,000 NENE credit becomes canonical and the closed supply breaks. That is the optimistic assumption, stated in the open.

Base fee follows an EIP-1559-shaped update around a target of 400,000 gas per batch, floored at 1,000 yocto-NENE per gas. Half the base fee is burned to the zero address. Half goes to the treasury account 0x…007e, which phase 4's DAO is supposed to own. The priority fee goes to the sequencer. A transfer of 21,000 gas at the genesis base fee costs 0.000000021 NENE.

On this testnet, phase 4 rotates the proposer by test-NENE stake over the testnet height, and the treasury fee switch is a stake-weighted vote. The hash is not a NEAR block hash, and the vote is not a NEAR DAO. The sequencer bond is still what a fraud game slashes.

The executable specification is TypeScript, tested with node:test. The NEAR contract is the settlement port. The console in this app is a driver for the same FlightDevnet the tests use.

• flight/src/codec.tskeccak, uint256, merkle proofs
• flight/src/crypto.tssecp256k1 FlightTx signatures
• flight/src/evm.tssubset VM, assembler, Hatch bytecode
• flight/src/state.tsworld root, withdrawals, constants
• flight/src/chain.tsbatches, bridge, bisection, devnet
• flight/test/protocol.test.tssupply, slash, grief, unchallenged lie
• contracts/flight-settlementNEAR settlement, bond, DA, proofs
• docs/ARCHITECTURE.mdlong-form version of this page

Not in this release: full Ethereum JSON-RPC, RLP transactions, CREATE/CREATE2, the precompiles, a production prover on NEAR gas, or a deployment to mainnet. Stake rotation and the fee vote run on the testnet only. Calling that mainnet would be a lie bigger than Cuckoo's root.