Supra Consensus Verification
HyperNova verifies messages from Supra against the consensus of the Supra validator committee. Supra certifies each block with a single aggregated threshold signature. The verifier therefore needs only one signature check per certified block, together with Merkle proofs that place the message in the transactions that the block certifies.
HyperNova uses this method for every message that originates on Supra, whether on SupraMVM or on SupraEVM:
| Direction | Verifier | Accumulator root it checks |
|---|---|---|
| SupraMVM → Ethereum | Hypernova contract on Ethereum | SupraMVM |
| SupraMVM → SupraEVM | Hypernova contract on SupraEVM | SupraMVM |
| SupraEVM → SupraMVM | supra_hypernova_core on SupraMVM | SupraEVM |
Committee threshold certificates
Supra reaches consensus through Moonshot, its Byzantine fault-tolerant (BFT) protocol, in which an authorized committee of validators serves each epoch. Besides the keys of its individual validators, each committee has aggregated threshold public keys. A signature that verifies against a threshold key can exist only after the corresponding threshold of the committee has signed.
A committee has several threshold types. The verifier stores only the threshold keys of the two it uses:
| Threshold | Used for |
|---|---|
ClanMajority | Transactions Inclusion Certificates, which certify the contents of a block |
BcftQuorum | Committee Authorization Certificates, which authorize the next committee |
Because the threshold is enforced inside the aggregated key, the verifier checks one signature against one public key. It never enumerates validators, counts votes or tracks stake on-chain. The committee’s member list enters the committee hash only as a single membersHash.
Proof bundle
A relayer submits the following with each message:
| Component | Purpose |
|---|---|
| Event | The event that carries the message: a Move event from SupraMVM, or an EVM log from SupraEVM. |
| Event Merkle proof | Proves that the claimed transaction emitted the event, against that transaction’s event accumulator root. |
| Transaction Merkle proof | Proves that the transaction was executed, against the transaction accumulator root that the certificate covers. |
| Transactions Inclusion Certificate | The committee’s ClanMajority signature over the block’s accumulator roots, block height and epoch. |
Together, these components link a committee key that the verifier holds to the event:
No ancestry proof is needed. The transaction accumulator is append-only, so the certificate of the block that contains the message, or of any later block, covers the message. Supra RPC nodes build the proofs against the latest certified block.
Supra commits every executed transaction, and every event that each transaction emits, to Merkle accumulators. The certificate covers the accumulator roots of both SupraMVM and SupraEVM, so one certificate serves messages from either of them. Each verifier checks the transaction proof against the root of the message’s source, as the table at the top of this page shows. The certificate also binds the block height, chain and epoch, so it cannot be reused for a different block, chain or epoch.
Hypernova checks the signature with the EIP-2537 BLS12-381 precompile and rejects a signature equal to the point at infinity. supra_hypernova_core checks it with the native bls12381 Move module. Message and Proof Formats specifies the exact leaf hashes and the certificate digest.
Verification checks
Before it accepts a message, the verifier checks that:
- The certificate comes from the configured Supra chain.
- The verification fee is paid.
Hypernovatakes the fee as the transaction value and requires exactly the fee per message.supra_hypernova_corecharges the fee in SUPRA from the signing account. - A registered committee signed the certificate, and that committee’s epoch is within the epoch tolerance of the latest known committee.
- The event is HyperNova’s message event, emitted by the registered source contract or module, and addressed to this chain.
- On EVM chains, the event’s
callermatches theexpectedCallerthat the receiving contract passes. On SupraMVM, the receiving module checks the sender from the verified log. - The receiving application has not processed the message before.
- The event and transaction Merkle proofs are valid against the certified root.
- The certificate signature is valid, unless the verifier has already cached the root for that block.
The two verifiers run these checks in different orders. If any check fails, the verifier rejects the submission.
The admin of each verifier sets its epoch tolerance. The current values are:
| Verifier | Epoch tolerance |
|---|---|
Hypernova on Ethereum Mainnet | 12 epochs, about one day |
Hypernova on Sepolia | 336 epochs, about 28 days |
Hypernova on SupraEVM Devnet | 336 epochs |
supra_hypernova_core on SupraMVM Devnet | 12 epochs |
Certificate caching
Signature verification is the most expensive check, so the verifier performs it at most once per block. After the verifier verifies the first certificate for a block, it caches the block’s accumulator root against the block height. Later messages from the same block are checked against the cached root, without a signature check.
If a later certificate for the same height carries a different root, Hypernova rejects it. supra_hypernova_core ignores the roots in a later certificate and checks the transaction proof against the cached root.
Hypernova also has entry points that take no certificate, such as verifyMessagePostedOnSupraWithoutCertificate. They accept a message only from a block whose root is already cached, and otherwise revert with InclusionCertificateNotVerified. On SupraEVM Devnet, the admin can remove cached roots with revokeMoveVmTxInclusionMerkleRoots.
Hypernova has batch entry points that verify several messages from one block with a single signature check. A batch is atomic: if any message fails, the whole batch is rejected. supra_hypernova_core verifies one message per call.
Committee updates
The verifier must always know the current Supra committee. At each epoch boundary, a permissionless Committee Updater submits the new committee together with a Committee Authorization Certificate. On Mainnet and Testnet, a new epoch currently starts every two hours. The verifier accepts the update only if:
- The committee hash that the verifier recomputes from the submitted committee matches the certificate.
- The certificate carries a valid
BcftQuorumsignature from the latest committee that the verifier trusts. Committees therefore form a chain, anchored at the first committee, which the admin sets after deployment. - The new committee’s epoch is strictly greater than the latest known epoch, so an update can never roll the verifier back. The
Hypernovacontract on Sepolia, deployed from a pre-release build, does not check this yet. - The new committee has both a
BcftQuorumkey and aClanMajoritykey.
The verification fee funds the Committee Updater’s reward. The admin can also set the latest committee directly. The admin uses this path to set the first committee, and to recover when updates have been missed for many epochs. See Committee Updaters.
Edge cases
| Scenario | Handling |
|---|---|
| Many messages proven against one certified block | The first verification caches the block’s root; later messages use the cache. |
| A certificate for an already-verified height has a different root | Hypernova rejects it. supra_hypernova_core checks the proof against the cached root. |
| A message without a certificate comes from a block that is not cached | Hypernova rejects it with InclusionCertificateNotVerified. |
| The certifying committee is older than the epoch tolerance | The verifier rejects the certificate. |
| The certifying committee was never registered | The verifier rejects the certificate. |
| The committee rotates | A Committee Updater registers the new committee. |
A new committee lacks a BcftQuorum or a ClanMajority key | The verifier rejects the update. |
| Committee updates were missed for many epochs | The admin sets the latest committee directly. |
| The event comes from another contract or targets another chain | The verifier rejects it. |
| The same message is submitted twice | The verifier rejects the repeat. |
| A proof is invalid or tampered with | The verifier rejects the submission. The relayer loses only its gas. |