resilience-me

contract BitPeople {
    function proofOfUniqueHuman(uint t, address account) external view returns (bool) {}
    function population(uint t) external view returns (uint) {}
}
contract PAN { function setTaxRate(uint tax) external {} }
contract Schedule {
    uint constant public genesis = 1710568800;
    uint constant public period = 4 weeks;
    function schedule() public view returns(uint) { return ((block.timestamp - genesis) / period); }
}

resilience-me

package clique

import (
	"bytes"
	"encoding/binary"
	"errors"
	"fmt"
	"math/big"
	"sync"
	"time"

resilience-me

// An opt-in random number generator that uses potentially every single person in BitPeople (thus potentially
// every person in the world) to generate a random number. It uses a commit-reveal scheme, combined with "mutating"
// the committed value (thus, no one is able to know what they vote for, but they can ensure their vote is random).
// The RNG selects a number between 0 and N, where N is the number of people who participate. The result conforms 
// to Poisson distribution e^-1/k!. The RNG is intended to be used by BitPeople, to shuffle the registered population 
// using Fisher-Yates shuffle, and, it can be used by any other application on the ledger as well.

contract Kleroterion is Mixer {

    BitPeople bitpeople = BitPeople(0x0000000000000000000000000000000000000005);

resilience-me

# This simulation creates a web of trust with a static number of trust lines 
# per person. The swarm redistribution pulses then find credit line paths based 
# on those trust lines, without any loops (credit lines in Ripple cannot loop, 
# because when they do credit is cleared. )

from __future__ import division
import random

# Set parameters for the simulation

resilience-me

from __future__ import division
import random

# Set parameters for the simulation

totalNodes = 4 ** 6

connections = 4

totalHops = 5+1

resilience-me

// this labyrinth contract as a public utility can be used as an "entropy crawler", 
// using the state itself as a source of entropy (generated entirely from human social coordination 
// that is highly random. )

contract Labyrinth {

  uint entropy;
  
  function getRandomNumber() public returns (uint) {
    entropy ^= uint(blockhash(entropy % block.number));

resilience-me

function getRandomNumber(uint _treasureMap, uint _iterations) returns (uint) {
  for(uint i = 0; i<_iterations; i++) {
    _tresasureMap ^= blockhash(block.number % _treasureMap);
  }
  return _treasureMap;
}

resilience-me

contract PseudonymPairs {

    mapping(address => uint) pseudonymID;
    mapping(uint => address) pseudonymIndex;

    struct PairUtility {
        mapping(uint => uint) index;
        uint counter;
    }
    PairUtility[2] pairingUtility;

resilience-me

The story of "XPAT", from a schelling point to a cult

The original idea of "bitnation" from 2014 was pretty good, to have a symbol as a schelling point, for a grass roots movement around the reformation into the networked society. Basically, a metaphor to meet around, since the world had not reached a point where those metaphors could be factual. I associated my work with "bitnation" in 2014 because that original vision was inspiring. What happened in 2016 and going forwards, is that Susanne and her husband took that symbol as a schelling point, and centralized it around a separate idea, an example of memetic hitchhiking, and "XPAT" was the result. It is not in my self-interest to associate with "bitnation" as a schelling point anymore, because it got corrupted and there is nothing left to associate with.

The tale of two token sales, from people at the frontier

The first "bitnation" token sale was in 2014, and when I discovered it, I found it to be highly inspiring

resilience-me

# cook your code here
import random
list=[]
bots=[]
duplicate = 0

for i in range(2000):

          r=random.randint(1,1000)
          if list.count(r) < 2: