Hi there
What do you think about using bitcoins as a voting system with the following traits:
- public: meaning that,
- everyone can create a vote to a specified question
- everyone can check and verify the identities and the number of votes per voter
- anonymous: the vote of a voter cannot be attributed to him, but only to a (big enough) pool of voters
I am thinking of the following "algorithm":
- 1. creation of the question and answers
A single bitcoin transaction ( := txA) represents a question. the outputs of txA are bitcoin addresses of the voters ( := addr_init_voter1, addr_init_voter2, ...) and they are unambigously matchable with the identities (:= id_voter1, id_voter2, ...) (for example public keys, which are also nice to build a web of trust) of the voters for example in a public database (e.g.: keyserver) or an id-blockchain or something else.
The inputs of txA do not matter much. Generally the person who asks the question will provide enough bitcoins for all voters, check the recipients and then sign the input. Another possibility is that each voter provides his share himself and this way txA must be signed by all the voters. Maybe there is a possibility (i did not find one yet and i do not see the possibility to do so) to lend bitcoins to txA by all voters so that after some time after the vote the bitcoins will be transferred back to them.
The important part is that txA is only considered a valid question if all the outputs (in amount and address) are considered valid by all voters.
For each possible answer a bitcoin address is given (:= addr_answer1 , addr_answer2, ...) by the question creator (he has the private keys to them) to which the voters can finally transfer their bitcoins.
- 2. anonymisation of bitcoins
Because addr_init_voter1 identifies id_voter1 as its owner, the bitcoins have to be transfered to another address. So voter1 creates a whole bunch of new addresses (:= addr_anon1_voter1, addr_anon2_voter1, ...) and creates and checks transactions (:= txANON1, txANON2, ...) with other voters in the form of:
txANON1{
inputs: addr_init_voter1, addr_init_voter2 (amount=0.7*total (:= amountFrom( txA )To( addr_init_voter2 ))) , ...
outputs: addr_anon1_voter1 (amount= 0.5*total), addr_anon2_voter1 (amount=0.5*total), addr_anon1_voter2 (amount=0.7*total)
}
txANON2{
inputs: addr_anon1_voter1 (amount=total), addr_init_voter2 (amount=0.3*total) , ...
outputs: addr_anon3_voter1 (amount= amountof(addr_anon1_voter1)), addr_anon2_voter2 (amount= amountof(addr_init_voter2)(eg.:0.3*total)),...
}
the transactions obfuscate who owns a bitcoin at a specific addr_anon{i}_voter{j}. They are checked on the correct sum of the amounts from each address owner before signing them and after 1 voter has consented with the transaction the transaction cannot be changed. So there is a building phase in which the transaction is build and then a verification phase in which it is verified by each input owner.
Are enough of these transactions done between the voters each voter holds a number of addresses in his wallet which have summed up the same amount of bitcoins as transmitted from txA to addr_init_voter{j}, if no voter has given his coins to another voter. you can not add bitcoins to txANON{k} which do not originate in txA or another txANON{l}. the voters (or their software) have to check this before signing
[/li]
- 3. voting and counting the votes
To actually vote the voter has to transmit his bitcoins to the answer address (or multiple addresses in a weighted vote (e.g.: 30% for Answ1 and 70% for Answ2)).
to get the result of a vote one has to:
- count and add the amount of all transactions before the end of the vote (determined by blocknumber) to the answer address
- make sure all these bitcoins originate in the txA transaction (i believe this is named colored bitcoins)
- invalidate the whole vote, if there are transactions from the addr_answer{m} to another address in a block before the vote-terminating block because they might have been used again in this vote.
lets just simply call these colored bitcoins votecoins or something.
to be applicable in practice the following traits must also hold true:
- value(votecoin) << value(bitcoin( amount(bitcoin)==amount(votecoin)) or else would you vote or take the money?
- there must exist a client which automagically creates and checks the txANON and counts and validates a vote in reasonable time
- ...
Hmmmm.. Do you get what i mean? Does this work?
If this is already implemented somewhere please give a link. Otherwise please implement!
If i have the time i will try to code this stuff myself, but i have yet to find a decent (non-java) ( java hater
) documented library.
l like
https://github.com/jgarzik/picocoin the most at the moment. especially because of the gotos to the output labels in the functions
I really do not consider this as method to hold political elections (although there would be the possibility of worldwide direct democracy, if this works), but more as a tool to reach consens about interface design or specifications of some kind of software or hardware without calling and forming multiple commitees all over the world.
So please respond. It does not matter if you think its crap or good. Maybe i can start a poll later ...
