Virtual Pseudonym Parties are based on the idea of Offline Pseudonym Parties, published by Bryan Ford and MIT back in 2007, and moves the pseudonym event into the virtual space, using telepresence such as Google Hangouts or similar ways of communicating, and does the event more frequently, most probably once a month.

POIs could be described as a-personal "temporary access tokens". The POIs do not store any data about the nyms, nor do they trace to a nyms previous POI, so there is no record of "who you are" other than a one-time-use ethereum address.

Using "Anti Bot Token" as security tokens for the Virtual Pseudonym Parties dApp

ABT tokens would be used to secure the Virtual Pseudonym Parties network, and would devalue in the case of a bot attack, and so the ABT that the attacker bought to be able to perform their attack would have lost all their value.

Distributing ABT tokens by letting POI users "mine" them

The ABT would gain value because there is demand for ABT to be able to pay the deposit and fees for registering for a pseudonym round, and the value would grow as the Virtual Pseudonym Parties network reaches enough users so that the POIs actually represent a Proof-of-Individuality, and the user mass makes it secure against bot attacks.

One way to grow the Virtual Pseudonym Parties network organically could be to let users "mine" ABT. This would distribute ABT amongst people who can then sell ABT to others who become interested in the network, so the early adopters are rewarded for their work for building up the network.

contract mineABTs is ABT {
  ProofOfIndividuality public proofOfIndividuality;

  function mineABTs {
    proofOfIndividuality = ProofOfIndividuality(0xa4879Ea62BD45AafB90A19edeB1AFd7Aae19765D);
  }

  mapping(address => bool) rewardClaimed; // each month gives you a POI generated on a new address

  function claimReward() {
    if(rewardClaimed[msg.sender] == true) throw;
    if(proofOfIndividuality.verifyPOI(msg.sender) == false) throw;
    if(totalSupply > 10000000) throw;
    balanceOf[msg.sender] += 1;
    totalSupply += 1;
    rewardClaimed[msg.sender] = true;
  }
}

The size of the deposits and fees are governed by the users, so they could govern those to prevent bot attacks during the ABT distribution phase.

uint public depositGovernance;
  
mapping(address => uint) public depositSizeVote;

function vote(uint _depositSize) payable atTime(registration, pseudonymEvent) {
  if(depositSizeVote[msg.sender] + msg.value < _depositSize) _depositSize = depositSizeVote[msg.sender] + msg.value;
  depositGovernance -= depositSizeVote[msg.sender];
  depositGovernance += _depositSize;
  depositSizeVote[msg.sender] = _depositSize;
  deposit[msg.sender] += msg.value;
}

function countVotes() atTime(pseudonymEvent, 0) {
  uint newDepositSize;
  if(numUsers != 0) newDepositSize = depositGovernance / numUsers;
  proofOfIndividuality.newRound(newDepositSize);
}

The ABT token would use the standard token framework making it easy to buy, sell and transfer ABT via token-exchanges and with UIs like Ethereum Wallet.

contract ABT {

    /* Public variables of the token */
    string public name;
    string public symbol;
    uint8 public decimals;
    
    uint public totalSupply;
    
    /* This creates an array with all balances */
    mapping (address => uint256) public balanceOf;
    
    /* This generates a public event on the blockchain that will notify clients */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /* Initializes contract with name, symbol and decimals */

    function ABT() {
        name = "Anti Bot Token";     
        symbol = "ABT";
        decimals = 18;
    }

    /* Send coins */
    function transfer(address _to, uint256 _value) {
        if (balanceOf[msg.sender] < _value) throw;           // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
        balanceOf[msg.sender] -= _value;                     // Subtract from the sender
        balanceOf[_to] += _value;                            // Add the same to the recipient
        Transfer(msg.sender, _to, _value);                   // Notify anyone listening that this transfer took place
    }

}

contract PseudonymRound is ABT {

    function register() {
        if(!transfer(this, depositSize + fee)) throw;
    }
}