0xAnonymous

contract Oracle {

    mapping (uint => uint) public seed;

    mapping (uint => mapping (uint => uint)) public points;
    mapping (uint => uint[]) public leaderboard;
    mapping (uint => mapping (uint => uint)) public leaderboardIndex;

    struct Score {
        uint start;

0xAnonymous

contract MoneySupplyTax is Coin {

    address taxCollector;
    uint taxRate;
    mapping(address => uint) taxDeclared;
    
    function enforceTax(address _account) internal {
        uint undeclared = taxrate**(block.timestamp - taxDeclared[_account]);
        balanceOf[_account] *= undeclared;
        if(_account == taxCollector) balanceOf[_account] += totalSupply - totalSupply*undeclared;

0xAnonymous

contract Polytopia {

    uint constant public period = 4 weeks;
    uint constant public genesis = 1604127600;

    uint constant public randomize = 2 weeks;
    uint constant public premeet = 3 weeks;

    uint public hour;

0xAnonymous

The man in the middle attack

Collusion attacks described above cannot be prevented other than by a culture of honest behaviour. They have minimal returns, the fake accounts gained is percentageColluding^2 and scale with an inverse square law, and the protocol considers them to be allowed and an unavoidable (and minimal) cost. Man in the middle attacks on the other hand, are entirely defendable. There are different ways to defend against that attack, I will here describe the one I think works best for the protocol.

Man in the middle attacks are well known in communication systems such as key exchange protocols. One approach to defend against them is by using a third party to authenticate the channel. The defense protocol I prefer for Pseudonym Pairs relies on a form of third party authentication, but in contrast to a certificate authority in key exchange protocol, the third party here is another person within the Pseudonym Pairs population.

The pair agrees on a third party authenticator, and they do so in

0xAnonymous

How to join the Pseudonym Pairs test net

The Pseudonym Pairs smart contract is fully implemented (source code), but, there is not yet a simple app client to "talk" to it. So, if you want to participate in testing it on the EthereumF Ropsten network it is probably necessary that you learn a bit of how Ethereum works, since you have to do some of the communication manually.

To opt-in to the test net, you just tell the contract to let you be part of it. You have to do that before the test net launches the first Pseudonym event. This first step of agreeing on a "genesis population" will require a bit of trust when the main net launches, but for the test net it will just accept anyone (which means technically bots could hijack the test net at genesis, but there is no profit resting on it so.. )

You command the contract 0x901e01E2d433ab5384A9bBc1C97714c35077D86E to let you opt-in with the command 0xd6074e14 that will invoke the function

0xAnonymous

Pseudonym Pairs: a proof-of-unique-human system

Pseudonym Pairs is a coordination game for global proof-of-unique-human, through monthly pseudonym events that last 15 minutes, where every single person on Earth is randomly paired together with another person, 1-on-1, to verify that the other is a human being, in a pseudo-anonymous context. The proof-of-unique-human is that you are with the same person for the whole event. The proof-of-unique-human is untraceable from month to month, much like cash. True anonymity.

Implementation

The Pseudonym Pairs system is built around the functions register(), immigrate(), dispute() and reassign(). The schedule is enforced with scheduler(). Personhood is verified with the public mapping proofOfPersonhood. Mixing is done with external contracts. Incredibly simple.

0xAnonymous

contract PseudonymPairs {
    
    uint entropy;
    function getRandomNumber() internal returns (uint){
        entropy = uint(keccak256(abi.encodePacked(now, msg.sender, blockhash(block.number - 1), entropy)));
        return entropy;
    }

    uint public maxValue = 2**256-1;
    

0xAnonymous

The Imitation Game: A proof-of-unique-human system

The Imitation Game is built around the functions register(), immigrate(), dispute() and reassign(). The schedule is enforced with scheduler(). Personhood is verified with the public mapping proofOfPersonhood. Mixing is done with external contracts.

For a complete reference implementation, see ImitationGame.sol.

Synapses

0xAnonymous

contract ImitationGame {
    
    uint entropy;
    function getRandomNumber() internal returns (uint){
        entropy = uint(keccak256(abi.encodePacked(now, msg.sender, blockhash(block.number - 1), entropy)));
        return entropy;
    }
    
    uint public maxValue = 2**256-1;
    

0xAnonymous

The proof-of-unique-human system Anonymous

The proof-of-unique-human system Anonymous is built around the functions register(), immigrate(), dispute() and reassign(). The schedule is enforced with scheduler(). Personhood is verified with the public mapping proofOfPersonhood. Mixing is done with external contracts.

For a complete reference implementation, see Anonymous.sol.