A small Substrate chain where each node operator gets exactly one vote – feedback welcome

Hi all,

I’m building MADAR Network, an independent chain built with the Polkadot SDK. The idea is simple: voting power is per person, not per coin. Each approved operator runs one validator and gets exactly one vote in finality, with no staking.

How it works today:

  • Operators apply, and a 2-of-3 committee approves them (one vote each).
  • Upgrades and admissions go through the same 2-of-3 committee; there is no sudo.
  • The node app is one click on Windows and Linux, and voting is turned on with one button after approval.

It runs as a public testnet, with no token yet. The code is open (Apache-2.0): github.com/MADAR-NETWORK/MADAR

The hard question I’d love your views on: how do you keep “one person, one vote” without collecting IDs? Today it rests on approval by the committee, and I know that doesn’t scale.

If you’d like to try running a node: madar-network.com/operators

Thanks for reading.

Hi. You can’t have one person, one vote without a trusted authority, or other trust assumptions that replace it, to check who is a unique person (Douceur’s result, “The Sybil Attack”, 2002). Today that authority is your committee.

What you are asking is: can we avoid a Sybil attack without asking for IDs in a Proof of Authority chain?

That is in essence a proof of personhood problem. There are some ways to approach it (e.g. Encointer with simultaneous in-person meetups, BrightID with social vouching, Idena with synchronized puzzles). They don’t need IDs, but they replace the central authority with other trust assumptions, such as physical presence, simultaneous human tests, or a trusted social graph, and each one has its own weaknesses.

But there is another issue that your question is not addressing: economic security. Let’s say you are able to identify unique identities (with or without asking for IDs). Then you have a set of unique identities that have voting power.

What ensures that those people/entities will not misbehave?

In a PoW chain, miners invest in hardware that is only valuable if the chain keeps its value, so mining honestly pays more than attacking.

In a PoS chain, if you misbehave you get slashed and lose your stake.

In a PoA chain, validators are usually known institutions. If one misbehaves, the other validators remove it, but the real deterrent is the loss of its reputation. Lawsuits are possible, because the identity is known.

In MADAR, without IDs or stake, you end up with a group of entities with nothing to lose except their seat and future rewards. To attack the network, someone only has to pay enough operators to get a majority of the votes, and with a small operator set that is cheap. The cost of that attack does not grow with the value the chain secures, but the gain does.

One possible direction: move to a regular PoA with known identities. That means giving up the “no IDs” goal, but it gives you the deterrent that PoA depends on: reputation and legal action, while keeping one person, one vote.

You’re right on both points. Today the committee is the trust anchor for “one person”, and I’d rather say that plainly than pretend otherwise. And you’re right that unique identities alone don’t give economic security: without a cost to misbehave, a small set can simply be bought.

What we have today, and where it falls short:

  • Admission is not only the committee: it also uses vouching by existing operators, a computational puzzle and a random lottery. These make sybils slower and more visible, but as you say, they don’t make an attack expensive.
  • Approval can be withdrawn, which removes that operator’s vote and future rewards. That’s a deterrent only as long as the rewards are worth more than a bribe.

So the honest summary is: today the network is effectively a small PoA run in the open, and the open question is how to add a real cost before the operator set and the value grow.

Two directions I’m weighing, and I’d value your view on which is less bad:

  1. A refundable bond per operator (fixed, not proportional to wealth, so it keeps one vote each), lost on proven misbehaviour.
  2. Moving the trust anchor to known, accountable operators, as you suggest, at least for the finality set.

Would a fixed per-operator bond meaningfully change the bribery math in your view, or does it just move the problem?

On the bond question: it helps with one attack and not the other. GRANDPA equivocation is provable onchain, so a bond can be slashed for double voting (pallet_grandpa reports it; with no staking you’d wire the slash yourself). Finalizing two conflicting forks needs more than a third of the set to sign both, so a safety attack costs at least that many bonds. Stalling finality is different. An operator who just stops voting hasn’t signed anything you can slash, so more than a third of the set can stall for free unless you add an offline penalty.

Two details decide whether the bond works. The unbonding delay has to be longer than the window to report equivocation, or someone can misbehave and withdraw before the report lands. And the committee is still the real boundary: two of three keys can admit operators and push runtime upgrades, so two keys could admit their own operators and post the bonds themselves. Separate keys for admission and upgrades, plus a delay on runtime upgrades, would close most of that.

Thanks, this is very useful.

Agreed on the split: a bond covers equivocation, which is provable, but not stalling. For stalling we’d need an offline penalty on top, otherwise more than a third of the set can stop finality at no cost.

Noted on unbonding: the withdrawal delay has to be longer than the equivocation report window, or the bond means nothing.

And you’re right that the committee is the real boundary today. Separating admission keys from upgrade keys and adding a delay on runtime upgrades is the direction we’ll take. It would let the network see an upgrade coming and react before it executes. We’ll post here when that design is ready.

Adding a bond would mimic what a PoS chain does, but with one important difference. In PoS, the stake and what the chain secures are usually in the same token. In Polkadot, for example, both are in DOT, so when the price moves, both move together.

We can think about it as a kind of vault with a very strong lock that is expensive to break. Nobody will break it while the cost is higher than what is inside. But if the value inside keeps going up and the lock stays at the same, at some point breaking it becomes worth it. In PoS, the lock (the stake) gets stronger when the token price goes up, and when the price goes down, what is inside is also worth less.

So a slashable bond can work, but only while the value on the chain stays below the bond, or as long as the bond covers the possible gain from misbehaving.

I’m not aware of a chain that runs a PoA like this, but bridges have used the idea. In Interlay, for example, operators lock more collateral than the BTC they hold, and can only hold as much BTC as their collateral covers (Interlay Docs). You, in theory, could apply the same rule here: cap the value the chain accepts based on the total bond.

Thanks, the vault picture is a clear way to put it. In PoA the bond and what it protects are not in the same unit, so a fixed bond gets weaker as the chain holds more value, and slashing alone doesn’t fix that.

The Interlay rule is the part I’ll take: limit what the chain accepts to what the total bond covers, with a safety margin, and only raise the limit when the bond grows. We’re still on public testnet with no token on chain, so this can go into the design before mainnet instead of being added later. I’ll write it up together with how authority keys are split, and share it here when it’s ready.

Thanks for the pointer to the Interlay docs, that’s the example I was missing.