Ethereum and Bitcoin now have a combined total value of over 12 billion USD, which is not a lot from a linear point of view where 30 steps take you to thirty, but in an exponential world, if you take 30 steps, 1, 2, 4, 8, 16, by step 30 you’re at a billion. That is the rate of growth of these new decentralized crypto-states. As our legal and financial machinery becomes an information technology, they also come to evolve based on the law of accelerating returns, and our linear perception no longer applies to them.

Cypto-currency makes taxation impossible, there will be no record of income for anyone, and it will be impossible to tax by hunting people and companies down, and this is the main selling point of crypto-states, as it inevitably starves statism to the point where it ceases to exist. Basically, globally available cryptography gives individuals the same advantage the Enigma machine gave the German army against the allies, and this strategic advantage is now available to everyone.

The idea of universal basic income is often center around state-funded basic income, but, even for those who do like the idea of basic income at gun-point, that system is not going to be able to sustain itself, since cryptography dis-intermediates the very ability to exert centralized control. Again, an Enigma machine in the hand of every individual on the planet provides a strategic advantage, and centralized government will not be able to compete against that.
Now, if we cannot force one another to share wealth, which besides not being possible in a future world is also inhuman and revolting, could we come up with a different way to do it ?

I’ve been working on designing new types of incentives that could enable universal basic income even in a world where taxation has become impossible. The idea behind the system, that I call Resilience, is to reward people and companies for choosing to consume from entities that donate to the system. When they do so, they will inherit what I call a Taxeme, that will extract the same amount of wealth when someone else consumes from them. The system is based on paying it forward, and rewards people for spreading a behavior of donating part of their income.

Those who pay forward a Taxeme will get rewards from future people and companies whose transactions and business grow outwards from where the Taxeme originated, forming a perpetual wealth redistribution cycle that is driven not by violence, but by something similar to the golden rule.

One metaphor to describe the Resilience system is to call it darwinian basic income. The rules of the system, how Taxemes are inherited and selected by the consumer, and how future donations feed back into past donators, are designed to self-organize into a behavior of wealth sharing that emerges naturally from how the system is designed. The system taps into self-interest, short-term gratification etc, and the rest of what makes us human, and weaves a highly complex network upon which people can get rewards from the future, basically.

There is a time-dimension to is, that is very different from how we usually think about the everyday state of affairs, but as it is encoded into the system itself, people don’t need to think about it, they just join the network, spread Taxemes that extract lots of wealth, and then enjoy their basic income to its full extent, providing social resilience as we humans are emotional beings, and our ability to feel empathy and to communicate our worries work best when our limbic systems are relaxed, providing space to negotiate business deals so that we perhaps could co-exist peacefully, and transcend the very idea of, and need for, politics.

Deploying Taxemes on the Ethereum world computer

Lower Taxemes are dominant, favoring a spread of high-tax-rate Taxemes that lead to dividend pathways the provide more flow of basic income. When a dividend pathway is formed, it gains a width proportional to the tax-rate of the Taxeme that was inherited, and a volume based on the size of the transaction.

During a purchase, the taxCollector() method is called, and it finds the active Taxeme of _to

function makePayment(address _to, uint256 _value) public {
    if (balanceOf[msg.sender] < _value) throw;           // Check if the sender has enough
    uint256 paymentRecieved = taxCollector(_to, _value);
    transfer(msg.sender, _to, paymentRecieved);
}

The taxCollector() in turn calls the processTax() method, that recursively uses up Taxemes of _to up to the _value of the purchase.

function taxCollector(address _to, uint256 _value) internal returns (uint256 paymentRecieved){
    uint256 taxCollected = processTax(_to, _value);
    paymentRecieved = _value - taxCollected;
    SwarmRedistribution(taxCollected);
    totalSupply -= taxCollected;
    return paymentRecieved;
}

processTax() looks up the active Taxeme of _to, processes it and does calculateTax(), and if the volume of the active Taxeme was < _value, it continues to the Taxeme next in line, the second lowest, and so on.

function processTax(address _to, uint256 _value) internal returns(uint256 taxCollected) {
    bytes32 taxemeID; uint volume;
    if(PersonalTaxeme[_to] < TaxemeRate[LowestTaxeme[_to]] || LowestTaxeme[_to] == 0) {
        taxemeID = newTaxeme(msg.sender, _to, _value);
        volume = TaxemeVolume[taxemeID];
    }
    else taxemeID = LowestTaxeme[_to]; volume = TaxemeHosts[taxemeID][_to];
    
    uint rate = TaxemeRate[taxemeID];
    
    if(_value < volume) {
        inheritTaxeme(msg.sender, _to, taxemeID, _value);
        return calculateTax(_to, taxemeID, _value, rate);
    }    
    else {
        uint remainingValue = _value - volume;
        taxCollected += calculateTax(_to, taxemeID, volume, rate);
        taxCollected += processTax(_to, remainingValue);
        return taxCollected;
    }
}

function calculateTax(address _to, bytes32 taxemeID, uint256 _value, uint rate) internal returns (uint256 taxCollected){
    taxCollected = _value * rate / 1000; 
    TaxemeHosts[taxemeID][_to] -= _value;
    TaxemeVolume[taxemeID] -= _value;
    return taxCollected;
}

The inherited Taxeme is appended to the list of existing Taxemes that a user might host, through the inheritTaxeme() method in the smart-contract.

function inheritTaxeme(address _from, address _to, bytes32 taxemeID, uint256 volume) {
    if(LowestTaxeme[_from] != 0) { 
        bytes32 previous = iterateThroughTaxemes(LowestTaxeme[_from], _from, taxemeID);
        bytes32 next = TaxemesIndex[_from][previous] ;
        appendTaxeme(taxemeID, _from, previous, next);
    }      
    else LowestTaxeme[_from] = taxemeID; 

    TaxemeHosts[taxemeID][_to] -= volume;
    TaxemeHosts[taxemeID][_from] += volume;
}

inheritTaxeme() in turn calls iterateThroughTaxemes() and appendTaxeme()

function iterateThroughTaxemes(bytes32 taxemeID, address _node, bytes32 taxemeToAppend) internal returns(bytes32 previous) {
    bytes32 nextTaxemeID = TaxemesIndex[_node][taxemeID];
    if(TaxemeRate[nextTaxemeID] > TaxemeRate[taxemeToAppend]) return taxemeID;
    iterateThroughTaxemes(nextTaxemeID, _node, taxemeToAppend);
}
function appendTaxeme(bytes32 IDofInheritedTaxeme, address _node, bytes32 previous, bytes32 next) internal {
    TaxemesIndex[_node][previous] = IDofInheritedTaxeme;
    TaxemesIndex[_node][IDofInheritedTaxeme] = next;
}

The RES token is the currency of the system. It is based on the standard token framework. Selling RES for ETH will be limited, and one idea for that is that a person can withdraw only that which they receive as basic income, and at the cost of some basic income. For the system as a whole, exchange of RES to ETH is 1:1, but as only people can withdraw and not companies, there would emerge a marketplace for withdrawals and companies would have to use it to withdraw.

contract RES {

string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
event Transfer(address indexed from, address indexed to, uint256 value);

function RES() {
    name = "RES";                                       // Set the name for display purposes     
    symbol = "RES";                                     // Set the symbol for display purposes    
    decimals = 18;                                      // Amount of decimals for display purposes    
}    
function buy() public {
    balanceOf[msg.sender] += msg.value;
    totalSupply += msg.value;
}
function sell(uint _value) public {                                   // un-regulated for testing purposes
    if (balanceOf[msg.sender] < _value) throw;          
    balanceOf[msg.sender] -= _value;
    msg.sender.send(_value);
    totalSupply -= _value;
}
function transfer(address _from, address _to, uint256 _value) internal {
    balanceOf[_from] -= _value;                     // Subtract from the sender
    balanceOf[_to] += _value;                       // Add the same to the recipient
    Transfer(_from, _to, _value);                   // Notify anyone listening that this transfer took place
}  

}

Pooling basic income to make it universal

The system plans to include a secondary layer, so that people can choose to pool their UBI with one another. The UBI from the core system will be relative to how well one spreads Taxemes. The UBI-pooling lets people share their basic income with friends and family 1:1.