All work

netbank

A prototype of a bank you don’t have to take at its word. Accounts live in a shared chain of blocks kept by independent nodes, and clients check their own balances.

Type
Special project, prototype
Platform
C++20, web
Our part
Architecture and development
Year
2026
netbank

The idea

In an ordinary bank the client trusts the statement. Here we wanted an operator’s mistake or fraud to be provable, not just noticeable.

How it works

Money moves only with the client’s Ed25519 signature. Roubles are issued by a single gateway. Witnesses re-execute every block and sign it, and a block is final once a quorum signs: two of three. An operator who signs two different blocks at the same height ends up in the fraud evidence.

The client cabinet

The cabinet installs on a phone like an app. The key stays in the browser, and the balance is checked with a Merkle proof against the block header from a witness, not from the operator. An account can be frozen only openly, with a reason and a term. The cabinet also has a delay for large transfers, guardians of whom any two of three can restore the key, and a delayed key change.

Honest limits

It is a prototype. Operator rotation falls short of full BFT, keys in the browser are for demonstration, and there is no TLS between nodes.

A block sealed by a quorum

The ledger is a book and a block is a page. The operator’s lever only turns pages; a page is sealed when at least two of the three witness seals come down.

3 665
Witness dies touching the page: two of three make the block finalPages are blocks of the chain; the operator's lever only turns themThe client's key and drawer, and hash tags on a cord: the Merkle proofA model of netbank, a fintech prototype of a bank that cannot lose a client. It is a C++20 ledger: accounts live in a shared chain of blocks kept independently by the nodes. Money moves only with the client's own Ed25519 signature, so the operator cannot move it, any more than open the drawer without the key; only the gateway issues roubles. Witness nodes re-execute every block and sign it, and a block is final with a quorum of 2 of 3 witness signatures: on the bench, two seals of three. The operator's lever turns the page but can never press a seal. The client checks their balance themselves, with a Merkle proof against the block header at a witness, not at the operator (the demo cabinet shows "proven by block #3665, 3 witness signatures"). An operator who signs two different blocks at one height ends up in fraud evidence. The demo network has 2 operators, 3 witnesses and 1 regulator.

Under the hood

  • C++20: a deterministic core with no network, disk or clock, a block chain and a node with an HTTP API.
  • Monocypher: Ed25519 signatures and BLAKE2b hashes, a Merkle proof for every account.
  • A demo network in Docker Compose: two operators, three witnesses and a regulator.
  • Web clients check signatures and proofs right in the browser: the explorer, the cabinet and the operator panel.
  • A Python cross-check of the arithmetic and an “evil operator” scenario that the witnesses catch.

C++20 · Monocypher · Ed25519 · Merkle · Docker · PWA

Shall we talk about your project?

Discuss your project