CHAIN++
A shared, tamper-evident record of who may use which data, under which agreement, and for how long. A post-quantum cryptography blockchain built for AI factories and their customers.
CHAIN++ is a blockchain of its own. It does not adopt Hyperledger Besu, Tessera, Solidity contracts, Ethereum keys or HashiCorp Vault. Its consensus, state machine, network channel, contract store and data guard were written for this one purpose.
CHAIN++ is a GPLv3 licenced blockchain: a shared, tamper-evident record of who may use which data, under which agreement, and for how long. It is built for AI factories and their customers: hospitals, companies, research groups and public bodies that hand data to a factory to train, fine-tune or run models.
The record is kept by the organisations that take part, not by any one of them. No single operator can change what it holds. Each entry is signed by the parties it concerns, so anyone with access can check who agreed to what, and when, without having to trust the node that shows it to them.
Every signature on the chain uses algorithms standardised by NIST in 2024 for the post-quantum era: ML-DSA and SLH-DSA for signing, and ML-KEM for key establishment. This is not an add-on or a future upgrade; the chain was designed around these algorithms from the start, because a signature must remain trustworthy for as long as the agreement it proves. Classical ECDSA and RSA are no longer defaults in the CHAIN++ design.
CHAIN++ is polymorphic: it supports several signature types at once, and each account and validator can use the type that fits its security needs. If one algorithm is later found to be weak, the federation can deprecate and retire it while the chain keeps running, without rewriting the chain or breaking existing agreements.
CHAIN++ also supports treechain (branching) semantics: a chain can split into independent branches that keep their own history while remaining anchored to a common root. This lets different factories, jurisdictions or customers run their own timelines without forcing a single global sequence. The treechain model borrows Ethereum's logic for building a tree chain but implements it with post-quantum cryptography; it is described in the Ethereum treechain document.
Watch the presentations
The initial engineering behind CHAIN++
Download video (MP4)Polymorphic Crypto Chains
Download video (MP4)Novel smart contract design for CHAIN++
The contract model is described in detail in the mutual customer contracts document.
On CHAIN++, a contract is a signed agreement between parties, not a program that the chain executes. The chain checks what can be verified automatically: who the parties are, that each of them signed, whether the agreement is still in force, and what data the agreement covers. The terms themselves are written in ordinary language in a contract file, readable by lawyers, auditors and data protection officers. This avoids the class of errors that have caused losses on Ethereum, where a mistake in deployed code cannot be corrected after the fact.
Every agreement is one contract record on the chain. A contract binds two to sixteen accounts, each in a role of an admitted contract type, and carries the period of validity, a fingerprint of the contract file and every party's signature.
The contract file itself is kept in the contract stores, one run by each factory. A party uploads the file to its own factory's store, which checks it against the chain before keeping it, and the other stores fetch a copy within seconds, so no single store is needed. The file may be encrypted so that only the parties can read it, or kept clear so that named readers can read it too.
The road to the new chain design
A traditional system puts the AI factory in charge of both the data and the record of how that data is used. The same organisation that receives, processes and monetises the data also writes the audit log, which means a customer or regulator has to trust the very party whose compliance is being checked. CHAIN++ removes that conflict by distributing the record across independent validators and cryptographically signing every entry, so no single operator can rewrite the history without being detected.
Existing blockchain platforms were also evaluated and did not entirely fit. A detailed comparison is in the blockchain comparison document.
- Hyperledger Tessera is no longer maintained, and Besu has removed the privacy feature it served.
- Ethereum and Besu rely on ECDSA on secp256k1, which a large quantum computer breaks.
- Their contracts are programs, which introduces a class of errors that cannot be corrected once deployed.
- Adding post-quantum cryptography to an existing platform would require rewriting its accounts, consensus, network identities and encryption at once, which amounts to building a new chain inside an old one.
CHAIN++ therefore starts from a small, auditable base: OpenSSL 3.5 for cryptography, the Python standard library, and one logging package.
CHAIN++ in action
CHAIN++ solves the ultimate question that every AI factory faces sooner or later: did this customer allow this use of this data? Was the data anonymised when it arrived? Who received it?
Today the answers usually lie in contracts, emails and log files held by the factory itself. CHAIN++ gives these answers from a record that every party holds a copy of and that nobody can quietly rewrite. It also stops data from leaving before the agreement for it is signed by everyone it names.
- The customer runs a data guard that examines the data set, records what kinds of data it holds and whether it is anonymised.
- The customer drafts a contract that names the data set, its classes and the terms, and signs it.
- The factory signs as well. If the data does not match the factory's declared limits, for example medical data that is not anonymised when the factory takes medical data only anonymised, the chain refuses the factory's signature.
- Only now is the set sent, and only to the guard of the customer's tenant at the factory.
- Years later an auditor can check, from the chain alone, that the agreement existed, who signed it, when, and what kind of data it covered, without seeing the data or the contract itself.
Participants
- AI factories. Each runs a validator, which helps decide what enters the record, and a contract store, which keeps the contract files.
- Customers. Each has an account on the chain with its own keys, from which it signs its agreements.
- Auditors and supervisors. They read the record and check it, but need not run anything.
Every participant is a known organisation that is registered before it can act. Nobody can join anonymously, unlike on Bitcoin or Ethereum.
Consensus
New entries are collected into blocks. A block is added only when enough validators have checked and signed it. In each round one validator, chosen in turn, proposes a block; the others check every entry against the rules and vote on it twice, first to accept it and then to confirm it. This is the Tendermint method.
With n validators of which at most f may fail or misbehave, n = 3f + 1 and the quorum q = 2f + 1. Four validators therefore tolerate one fault and need three signatures. The three signatures stay with the block as its certificate, and a block once certified is final: it is never undone.
Data guard
The data guard is a program that every party runs at its own site, through which all its data transfers pass. It closes the gap between what the contract says and what actually moves:
- The sender's guard examines the data set and records what kinds of data it holds and whether it is anonymised.
- It sends the set only once every party has signed, and only to the guard named in the contract.
- The receiving guard examines the set again and refuses it if it holds a kind of data that the contract does not name.
The guard image is signed by a registry of the federation with two post-quantum signatures, and every party checks it against the chain before running it.
Post-quantum cryptography from the beginning
A signature must stay trustworthy for as long as the agreement it proves, and that may outlast the arrival of a quantum computer. CHAIN++ therefore uses only the algorithms that NIST standardised in 2024 to resist a quantum computer:
- ML-DSA (FIPS 204) for signatures.
- SLH-DSA (FIPS 205) for the most conservative signatures.
- ML-KEM (FIPS 203) for key encapsulation.
Data is encrypted with AES-256-GCM and fingerprints are taken with SHA-3, both of which keep their strength against a quantum computer at these sizes. No classical signature or key exchange is used anywhere.
CHAIN++ supports several signature types so that the chain never depends on a single algorithm:
- mldsa65-sha3-256, the fast default.
- mldsa87-sha3-512, the same algorithm with a larger security margin.
- slhdsa256s-shake256, which rests only on the strength of a hash function and is the most conservative choice.
- pq-dual-v1, which needs both an ML-DSA and an SLH-DSA signature for governance decisions, so that breaking one is not enough.
If a signature type is later found to be weak, the validators can phase it out while the chain keeps running.
Federation: many factories, one record
Several AI factories can share one CHAIN++ chain. Each factory runs a validator, accounts and a contract store, and none controls the chain on its own. To keep it so, no factory may hold more than f of the n validators; with four validators, one each.
This lets customers of different factories sign agreements with each other directly, while each factory remains responsible for its own tenants and data handling. A customer's data goes only to the tenant named in the contract, and the contract file is sealed with ML-KEM-1024 so that only the parties can open it.
A factory joins by a governance decision that registers its account and admits its observer. A factory that leaves is removed the same way. Governance decisions need a quorum of validator signatures, so no single factory can register or revoke an account, admit a type, certify a block or alter the record.
Potential customers
CHAIN++ is designed for:
- AI factories that need to prove to customers, auditors and regulators how data is used.
- Customers that want a record they can verify themselves, rather than trusting the factory's logs.
- Federations of factories that need a shared governance layer across borders while keeping data residency under control.
Current status
CHAIN++ is currently a proof of concept that is approaching its first production state. Every function described here is implemented and verified by automated tests, including cluster tests with validators stopped and restarted, governance tests, guard tests and a deployment trial with four validators, two factories and two customers.
Before production it still needs:
- A distributed wallet, so keys can be split into shares across devices.
- A procedure for carrying the chain over when more than f validators lose their keys at once.
- A federation charter with agreed procedures for replacing validators, factory exit and incident response.
- Bounding the storage of old signatures.
- An independent security audit.
Questions and answers
Common questions about CHAIN++ are collected in the questions and answers document.