A simple Merkle tree for anonymous proof-of-unique-human (Bitpeople project)

[Bipedaljoe]

The ideal proof-of-unique-human system is likely the 1-on-1 simultaneous global event pseudonym parties I defined by 2018, and implemented on Ethereum soon after. But scalability is an issue, how to scale to 10 billion people which requires 1000x Ethereum transactions per second. One alternative, is a stand-alone ledger that only does PoUH. Such is surprisingly light-weight. It is quite unique as a "dApp", Bitpeople, in that it does not need to manage spam. It does everything in parallel naturally (thus no "transaction trie" root needed in the "blocks" as transaction order is irrelevant). It can govern itself by "one person, one unit of stake" simply by referencing the previous "block" Merkle root in the transactions (thus, unanimous vote, not just majority vote but unanimous). It can quite easily delegate construction of Merkle root and validation of state changes, via "one person, one unit of stake" as well, ideally as a validator hierarchy but in simpler earlier versions (without any changes in the ledger...) by central validators that audit everything (rather than the fragmented hierarchy approach that divides the responsibility). Maybe this interests someone here, the ledger idea is a few weeks old, defined here: https://pastebin.com/suTkDPNS. The Bitpeople whitepaper is on https://doc.bitpeople.org (but it is based on the smart contract version on Ethereum for the code examples). Peace

Code:

MixerToken {
    address             [32]byte
    mixer               [32]byte
}

Data {
    nym_a/b             [32]byte
    verified_a/b        bool
    disputed            bool
    court               [32]byte
    court_verified_a/b  bool
    registration_a/b/c  MixerToken
    invite_a/b          MixerToken
    proof_of_unique_human_a/b/c MixerToken
    new_elected_a/b/c   [32]byte
    new_commit_a/b/c    [32]byte
    commit_a/b          [32]byte
    seed_hits_a/b       uint32
    elected_a/b         [32]byte
}

LeafNode {
    prev_root           [32]byte
    data                Data
}

BranchNode {
    prev_root           [32]byte
    population_count    uint32
    invite_count        uint32
    dispute_count       uint32
    reassign_count      uint32
    seed_hits           uint32
    left_hash           [32]byte
    right_hash          [32]byte
}

Mixer {
    leaf_id             uint32
    mixer_idx           uint8
    token               MixerToken
    salt                [32]byte
}

[Bipedaljoe]

Bootstrapping such ledger semi-manually for a smaller population is very simple as well. Storing ledger in JSON like here for a four people genesis phase, https://pastebin.com/azUnPivi, named by the Merkle root of the tree, the tool to verify it is 200 lines of code, here in HTML+JS: https://claude.ai/public/artifacts/b2f8dd00-e693-4e4e-88e6-1449219f9812, but anyone can themselves or with AI build for any language instantly since very simple (here in Go, https://pastebin.com/fdhHg5Xp). The components to apply transactions at any phase, produce the new leaves, and then build the new tree (with same code as in verify script) with new root and save new JSON, very simple too. Simple systems are good because more of the users can understand it, and thereby secure it by also being able to build anything in it from scratch. It's a fairly flexible system since the consensus is the unanimous "people vote" by referencing the previous phase merkle root in the transactions, and the system to coordinate production of Merkle root is not the main consensus.

[Bipedaljoe]

The formal specifications plus scripts to verify the ledger Merkle root and to run the Event phase now on https://ledger.bitpeople.org.