Bitcoin Forum

pragma solidity ^0.4.19;

contract SimpleStorage {
  bytes input;
  function setInput(bytes enterBytes){
    input = enterBytes;
  }
}

["0x00"]

["0x00","0xaa","0xff","0xaa","0xaa","0xaa","0xaa","0xaa",
"0x00","0xaa","0xff","0xaa","0xaa","0xaa","0xaa","0xaa",
"0x00","0xaa","0xff","0xaa","0xaa","0xaa","0xaa","0xaa",
"0x00","0xaa","0xff","0xaa","0xaa","0xaa","0xaa","0xaa"]

["0x00","0xaa","0xff","0xaa","0xaa","0xaa","0xaa","0xaa",
"0x00","0xaa","0xff","0xaa","0xaa","0xaa","0xaa","0xaa",
"0x00","0xaa","0xff","0xaa","0xaa","0xaa","0xaa","0xaa",
"0x00","0xaa","0xff","0xaa","0xaa","0xaa","0xaa","0xaa","0xaa"]

    // Notifica generazione x tokens all'indirizzo specificato
    event TokenGenerato(address indexed _address, uint _reward);

    function getFreeTokens(){
        uint amount = 100  * 10 ** uint256(decimals);
        
        if (balanceOf[msg.sender] >= amount) throw; 
      
        totalSupply += amount;
        balanceOf[msg.sender] += amount;
        
        TokenGenerato(msg.sender, amount);
        
    }

TokenGenerato(msg.sender, 1000  * 10 ** uint256(decimals));        

pragma solidity ^0.4.9;

contract Figlio {
    uint risultato;

    function Figlio(uint valore_iniziale) public {
        risultato = valore_iniziale;
    }
    function setRisultato(uint value) {
        risultato = value;
    }
    function getRisultato() constant returns (uint) { 
        return risultato;
    }
}

pragma solidity ^0.4.9;

contract Figlio {
    function setRisultato(uint value);
    function getRisultato() constant returns(uint);
}

contract Padre {
    address indirizzo_figlio;
    Figlio figlio;
    function Padre(address new_figliolo) public {
        indirizzo_figlio = new_figliolo;
        figlio = Figlio(indirizzo_figlio);
    }
    function setNuovoFiglio(address new_figliolo) {
        indirizzo_figlio = new_figliolo;
        figlio = Figlio(indirizzo_figlio);
    }
    function setRisultato(uint value) {
        return figlio.setRisultato(value);
    }
    function getRisultato()  constant returns(uint) {
        return figlio.getRisultato();
    }
        
}

mapping (address => bool) whiteList;

   function doSomething() {
        // recupera la lista whiteList dall altro smart contract
        
        if (whiteList[msg.sender] == false) throw;

        // fai qualcosa
    }

function distributeToken(address[] addresses, uint256 _value) onlyOwner {
     for (uint i = 0; i < addresses.length; i++) {
         balances[owner] -= _value;
         balances[addresses[i]] += _value;
         Transfer(owner, addresses[i], _value);
     }
}

["0xindirizzo_1", "0xindirizzo_2", "0xindirizzo_3"]

    
function setPass(string pass) {
        uint pass_cryptata = uint(keccak256(pass));
...
}

pragma solidity ^0.4.4;

contract SafeMath {
  function safeMul(uint a, uint b) internal returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function safeSub(uint a, uint b) internal returns (uint) {
    assert(b <= a);
    return a - b;
  }

  function safeAdd(uint a, uint b) internal returns (uint) {
    uint c = a + b;
    assert(c>=a && c>=b);
    return c;
  }

  function assert(bool assertion) internal {
    if (!assertion) throw;
  }
}

contract Token {
  
  function balanceOf(address _owner) constant returns (uint256 balance) {}
  function transfer(address _to, uint256 _value) returns (bool success) {}
  function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
  function approve(address _spender, uint256 _value) returns (bool success) {}
}


contract Banca is SafeMath{
  mapping (address => mapping (address => uint)) public tokens; //questo mappa un indirizzo di un token con un la mappatura di un indirizzo di un proprietario e la quantità di quei tokens
  
  event Deposit(address token, address user, uint amount, uint balance);
  event Withdraw(address token, address user, uint amount, uint balance);
  
  function Banca(){
  
  }
  
  function depositoToken(address token, uint amount) {
    if (token==0) throw;
    if (!Token(token).transferFrom(msg.sender, this, amount)) throw;
    tokens[token][msg.sender] = safeAdd(tokens[token][msg.sender], amount);
    Deposit(token, msg.sender, amount, tokens[token][msg.sender]);
  }
  
  function prelievoToken(address token, uint amount) {
    if (token==0) throw;
    if (tokens[token][msg.sender] < amount) throw;
    tokens[token][msg.sender] = safeSub(tokens[token][msg.sender], amount);
    if (!Token(token).transfer(msg.sender, amount)) throw;
    Withdraw(token, msg.sender, amount, tokens[token][msg.sender]);
  }
}  
 

mapping (address => mapping (address => uint)) public tokens; 

approve(address _spender, uint256 _value)

 function depositoToken(address token, uint amount) {
    if (token==0) throw;
    if (!Token(token).transferFrom(msg.sender, this, amount)) throw;
    tokens[token][msg.sender] = safeAdd(tokens[token][msg.sender], amount);
    Deposit(token, msg.sender, amount, tokens[token][msg.sender]);
  }

function transfer(address _to, uint256 _value) returns (bool success) {}

function prelievoToken(address token, uint amount) public payable{
    if (token==0) throw;
    if (tokens[token][msg.sender] < amount) throw;
    tokens[token][msg.sender] = safeSub(tokens[token][msg.sender], amount);
    if (!Token(token).transfer(msg.sender, amount)) throw;
    Withdraw(token, msg.sender, amount, tokens[token][msg.sender]);
  }

    function transfer(address _from, address _to, uint256 _value) public returns (bool success) {
        _transfer(_from, _to, _value);
        return true;
    }

function checkOwnershipEvents() {
                  document.getElementById("response3").innerHTML = ""
                  
                  var pf = web3.eth.contract(scAbi).at(scAddress);
                  // watch for an event with {some: 'args'}
                  var myEvent = pf.ProofOfOwnership({ some: 'args' }, { fromBlock: 0, toBlock: 'latest' });
                  // would get all past logs again.
                  var myResults = myEvent.get(function (error, logs) {
                      console.log(logs);
                      var event1;
                      for (var i = 0; i < logs.length ; i++) {
                          event1 = JSON.stringify(logs[i].args);
                          document.getElementById("response3").innerHTML += '<font color="green">Proof of ownership received: </font>' + JSON.stringify(event1) + '<br>'
                      }
                  });
              }

   function () payable{

        // Qui dentro poi usi msg.sender per sapere chi e' il destinatario dei token e msg.value per calcolare quanti token spedirgli


        LogReceivedFunds(msg.sender, msg.value);


    }

function pay() payable 
        public
        returns(bool success)
    {
        //Operazioni ...

        LogReceivedFunds(msg.sender, msg.value);
        return true;
    }

mapping (address => uint256) public locked;

    event Lock(address indexed _owner, uint256 _value);
    event Unlock(address indexed _owner, uint256 _value);

    function lock(uint256 _value) public returns (bool success){
        require(safeSub(balances[msg.sender], locked[msg.sender]) >= _value); // New check for token availability - Makkara
        locked[msg.sender] = _value;
        emit Lock(msg.sender, _value); // Raise event for locked tokens.
        return true;
    }
    
    function locked() public view returns (uint256 _value){
        return locked[msg.sender];
    }
    
    function unlock(uint256 _value) public returns (bool success){
        require(locked[msg.sender] >= _value); 
        locked[msg.sender]-=_value;
        return true;
    }

// Abstract contract for the full ERC 20 Token standard
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
pragma solidity ^0.4.21;

contract SafeMath {
  function safeMul(uint256 a, uint256 b) internal returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function safeSub(uint256 a, uint256 b) internal returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
    uint256 c = a + b;
    assert(c>=a && c>=b);
    return c;
  }

  function assert(bool assertion) internal {
    if (!assertion) throw;
  }
}

contract EIP20Interface {
    /* This is a slight change to the ERC20 base standard.
    function totalSupply() constant returns (uint256 supply);
    is replaced with:
    uint256 public totalSupply;
    This automatically creates a getter function for the totalSupply.
    This is moved to the base contract since public getter functions are not
    currently recognised as an implementation of the matching abstract
    function by the compiler.
    */
    /// total amount of tokens
    uint256 public totalSupply;

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) public view returns (uint256 balance);

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transfer(address _to, uint256 _value) public returns (bool success);

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);

    /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @param _value The amount of tokens to be approved for transfer
    /// @return Whether the approval was successful or not
    function approve(address _spender, uint256 _value) public returns (bool success);

    /// @param _owner The address of the account owning tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @return Amount of remaining tokens allowed to spent
    function allowance(address _owner, address _spender) public view returns (uint256 remaining);

    /// @notice `msg.sender` locks the amount of `_value` tokens
    /// @param _value The amount of tokens to be locked
    /// @return Whether the lock was successful or not
    function lock(uint256 _value) public returns (bool success);
    
    /// @notice `msg.sender` check the amount of tokens locked
    /// @return The amount of tokens locked
    function locked() public view returns (uint256 _value);

    /// @notice `msg.sender` unlocks the amount of `_value` tokens
    /// @param _value The amount of tokens to be unlocked
    /// @return Whether the unlock was successful or not
    function unlock(uint256 _value) returns (bool success);

    // solhint-disable-next-line no-simple-event-func-name
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    event Lock(address indexed _owner, uint256 _value);
    event Unlock(address indexed _owner, uint256 _value);
}


contract EIP20 is EIP20Interface, SafeMath {

    uint256 constant private MAX_UINT256 = 2**256 - 1;
    mapping (address => uint256) public balances;
    mapping (address => mapping (address => uint256)) public allowed;
    mapping (address => uint256) public locked;
    /*
    NOTE:
    The following variables are OPTIONAL vanities. One does not have to include them.
    They allow one to customise the token contract & in no way influences the core functionality.
    Some wallets/interfaces might not even bother to look at this information.
    */
    string public name;                   //fancy name: eg Simon Bucks
    uint8 public decimals;                //How many decimals to show.
    string public symbol;                 //An identifier: eg SBX

    function EIP20(
        uint256 _initialAmount,
        string _tokenName,
        uint8 _decimalUnits,
        string _tokenSymbol
    ) public {
        balances[msg.sender] = _initialAmount * 10 ** uint256(_decimalUnits);               // Give the creator all initial tokens
        totalSupply = _initialAmount * 10 ** uint256(_decimalUnits);                        // Update total supply
        name = _tokenName;                                   // Set the name for display purposes
        decimals = _decimalUnits;                            // Amount of decimals for display purposes
        symbol = _tokenSymbol;                               // Set the symbol for display purposes
        locked[msg.sender] = 0;  //Initialize locked tokens for the creator - Makkara
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(safeSub(balances[msg.sender], locked[msg.sender]) >= _value); // New check for token availability - Makkara
        balances[msg.sender] -= _value;
        balances[_to] += _value;
        emit Transfer(msg.sender, _to, _value); //solhint-disable-line indent, no-unused-vars
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        uint256 allowance = allowed[_from][msg.sender];
        require(safeSub(balances[_from], locked[_from]) >= _value && allowance >= _value);
        balances[_to] += _value;
        balances[_from] -= _value;
        if (allowance < MAX_UINT256) {
            allowed[_from][msg.sender] -= _value;
        }
        emit Transfer(_from, _to, _value); //solhint-disable-line indent, no-unused-vars
        return true;
    }

    function balanceOf(address _owner) public view returns (uint256 balance) {
        return balances[_owner];
    }

    function approve(address _spender, uint256 _value) public returns (bool success) {
        require(safeSub(balances[msg.sender], locked[msg.sender]) >= _value); // New check for token availability - Makkara
        allowed[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value); //solhint-disable-line indent, no-unused-vars
        return true;
    }

    function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }
    
    function lock(uint256 _value) public returns (bool success){
        require(safeSub(balances[msg.sender], locked[msg.sender]) >= _value); // New check for token availability - Makkara
        locked[msg.sender] = _value;
        emit Lock(msg.sender, _value); // Raise event for locked tokens.
        return true;
    }
    
    function locked() public view returns (uint256 _value){
        return locked[msg.sender];
    }
    
    function unlock(uint256 _value) public returns (bool success){
        require(locked[msg.sender] >= _value); 
        locked[msg.sender]-=_value;
        emit Unlock(msg.sender, _value); // Raise event for unlocked tokens.
        return true;
    }
    
}

contract ERC721 {
    
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function ownerOf(uint256 _tokenId) external view returns (address owner);
    function approve(address _to, uint256 _tokenId) external;
    function transfer(address _to, uint256 _tokenId) external;
    function transferFrom(address _from, address _to, uint256 _tokenId) external;

    event Transfer(address from, address to, uint256 tokenId);
    event Approval(address owner, address approved, uint256 tokenId);
}

string public constant name = "Tokenized Item";
  string public constant symbol = "NFTI";

  struct Token { // Definizione delle informazioni mantenute dal token
    address mintedBy;
    uint64 mintedAt;
    string description; /*Aggiunta allo scopo di rendere più comprensibile l’esempio, in realtà questo potrebbe essere un hash di un link IPFS o maggiori informazioni sul token senza incidere troppo sui costi derivanti dall’utilizzo delle informazioni all’interno dello smart contract*/
  }

  Token[] tokens; // Array dei token in esistenza

   //Mappature 
  mapping (uint256 => address) public tokenIndexToOwner; //Token -> User
  mapping (address => uint256) ownershipTokenCount; //User -> Token
  mapping (uint256 => address) public tokenIndexToApproved; //Token -> User approvato a spendere il token

//Evento
  event Mint(address owner, uint256 tokenId, string description);

function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
    return tokenIndexToOwner[_tokenId] == _claimant;
  }

  function _approvedFor(address _claimant, uint256 _tokenId) internal view returns (bool) {
    return tokenIndexToApproved[_tokenId] == _claimant;
  }

  function _approve(address _to, uint256 _tokenId) internal {
    tokenIndexToApproved[_tokenId] = _to;

    Approval(tokenIndexToOwner[_tokenId], tokenIndexToApproved[_tokenId], _tokenId);
  }

  function _transfer(address _from, address _to, uint256 _tokenId) internal {
    ownershipTokenCount[_to]++;
    tokenIndexToOwner[_tokenId] = _to;

    if (_from != address(0)) {
      ownershipTokenCount[_from]--;
      delete tokenIndexToApproved[_tokenId];
    }

    Transfer(_from, _to, _tokenId);
  }

  function _mint(address _owner, string description) internal returns (uint256 tokenId) {
    Token memory token = Token({
      mintedBy: _owner,
      mintedAt: uint64(now),
      description: description
    });
    tokenId = tokens.push(token) - 1;

    Mint(_owner, tokenId, description);

    _transfer(0, _owner, tokenId);
  }

  function mint(string description) external returns (uint256) {
    return _mint(msg.sender,description);
  }

  function getToken(uint256 _tokenId) external view returns (address mintedBy, uint64 mintedAt,string description) {
    Token memory token = tokens[_tokenId];

    mintedBy = token.mintedBy;
    mintedAt = token.mintedAt;
    description = token.description;
  }

pragma solidity ^0.4.18;

contract ERC721 {
    
    function totalSupply() public view returns (uint256 total);
    function balanceOf(address _owner) public view returns (uint256 balance);
    function ownerOf(uint256 _tokenId) external view returns (address owner);
    function approve(address _to, uint256 _tokenId) external;
    function transfer(address _to, uint256 _tokenId) external;
    function transferFrom(address _from, address _to, uint256 _tokenId) external;

    event Transfer(address from, address to, uint256 tokenId);
    event Approval(address owner, address approved, uint256 tokenId);
}

contract NFTItem is ERC721 {
 
  string public constant name = "Tokenized Item";
  string public constant symbol = "NFTI";

  /*** DATA TYPES ***/

  struct Token {
    address mintedBy;
    uint64 mintedAt;
    string description;
  }

  Token[] tokens;

  mapping (uint256 => address) public tokenIndexToOwner;
  mapping (address => uint256) ownershipTokenCount;
  mapping (uint256 => address) public tokenIndexToApproved;

  event Mint(address owner, uint256 tokenId, string description);


  /*** INTERNAL FUNCTIONS ***/

  function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
    return tokenIndexToOwner[_tokenId] == _claimant;
  }

  function _approvedFor(address _claimant, uint256 _tokenId) internal view returns (bool) {
    return tokenIndexToApproved[_tokenId] == _claimant;
  }

  function _approve(address _to, uint256 _tokenId) internal {
    tokenIndexToApproved[_tokenId] = _to;

    Approval(tokenIndexToOwner[_tokenId], tokenIndexToApproved[_tokenId], _tokenId);
  }

  function _transfer(address _from, address _to, uint256 _tokenId) internal {
    ownershipTokenCount[_to]++;
    tokenIndexToOwner[_tokenId] = _to;

    if (_from != address(0)) {
      ownershipTokenCount[_from]--;
      delete tokenIndexToApproved[_tokenId];
    }

    Transfer(_from, _to, _tokenId);
  }

  function _mint(address _owner, string description) internal returns (uint256 tokenId) {
    Token memory token = Token({
      mintedBy: _owner,
      mintedAt: uint64(now),
      description: description
    });
    tokenId = tokens.push(token) - 1;

    Mint(_owner, tokenId, description);

    _transfer(0, _owner, tokenId);
  }


  /*** ERC721 IMPLEMENTATION ***/

  function totalSupply() public view returns (uint256) {
    return tokens.length;
  }

  function balanceOf(address _owner) public view returns (uint256) {
    return ownershipTokenCount[_owner];
  }

  function ownerOf(uint256 _tokenId) external view returns (address owner) {
    owner = tokenIndexToOwner[_tokenId];

    require(owner != address(0));
  }

  function approve(address _to, uint256 _tokenId) external {
    require(_owns(msg.sender, _tokenId));

    _approve(_to, _tokenId);
  }

  function transfer(address _to, uint256 _tokenId) external {
    require(_to != address(0));
    require(_to != address(this));
    require(_owns(msg.sender, _tokenId));

    _transfer(msg.sender, _to, _tokenId);
  }

  function transferFrom(address _from, address _to, uint256 _tokenId) external {
    require(_to != address(0));
    require(_to != address(this));
    require(_approvedFor(msg.sender, _tokenId));
    require(_owns(_from, _tokenId));

    _transfer(_from, _to, _tokenId);
  }

  function tokensOfOwner(address _owner) external view returns (uint256[]) {
    uint256 balance = balanceOf(_owner);

    if (balance == 0) {
      return new uint256[](0);
    } else {
      uint256[] memory result = new uint256[](balance);
      uint256 maxTokenId = totalSupply();
      uint256 idx = 0;

      uint256 tokenId;
      for (tokenId = 1; tokenId <= maxTokenId; tokenId++) {
        if (tokenIndexToOwner[tokenId] == _owner) {
          result[idx] = tokenId;
          idx++;
        }
      }
    }

    return result;
  }

  function mint(string description) external returns (uint256) {
    return _mint(msg.sender,description);
  }

  function getToken(uint256 _tokenId) external view returns (address mintedBy, uint64 mintedAt,string description) {
    Token memory token = tokens[_tokenId];

    mintedBy = token.mintedBy;
    mintedAt = token.mintedAt;
    description = token.description;
  }
}

Smart contract (waves - appunti sparsi)
    white paper <https://wavesplatform.com/files/docs/white_paper_waves_smart_contracts.pdf>
    video esempio <https://hooktube.com/watch?v=sOZuE9Ebfko>
    documentazione <https://docs.wavesplatform.com/en/technical-details/waves-contracts-language-description.html>
        Associ uno scrip ad un account
        Le transazioni sono valide se lo script approva
            Firme e altri dati
            proofs
                ?
            Numero blocchi della catena
            dati presenti nella catena, oracoli
                Inseriti con DataTransaction
            Gli script possono essere sostituiti o annullati associandone uno nuovo
                A meno che lo script precedente non lo vieti
            Default script di un account
                sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPk)
            
        Costo script
            Dipendono dalla complessità
            max 8kByte
            minimo: 0.004 WAVES
            Costi minimi (non script) <https://docs.wavesplatform.com/en/technical-details/transactions-fees.html>
        Esempi
            Vedi documentazione <https://docs.wavesplatform.com/en/technical-details/waves-contracts-language-description/approach-and-capabilities.html>
                Account scambia solo BTC
                    let cooperPubKey = base58'BVqYXrapgJP9atQccdBPAgJPwHDKkh6A8'
                    let BTCId = base58'8LQW8f7P5d5PZM7GtZEBgaqRPGSzS3DfPuiXrURJ4AJS'
                    match tx {
                        case o: Order =>
                            sigVerify(tx.bodyBytes, tx.proofs[0], cooperPubKey ) && (o.assetPair.priceAsset == BTCId || o.assetPair.amountAsset == BTCId)
                        case _ => sigVerify(tx.bodyBytes, tx.proofs[0], cooperPubKey )
                    }
                Buy back ad uno specifico prezzo in WAVES
                    let myAssetId = base58'BVqYXrapgJP9atQccdBPAgJPwHDKkh6B9'
                    let cooperPubKey = base58'BVqYXrapgJP9atQccdBPAgJPwHDKkh6A8'
                    match tx {
                        case o: Order =>
                            o.assetPair.priceAsset == base58'' && o.assetPair.amountAsset == myAssetId && o.price == 500000 && o.amount == 1000 && o.orderType == Buy
                        case _ => sigVerify(tx.bodyBytes, tx.proofs[0], cooperPubKey )
                    }
        come associare uno script ad un account
            ...
        DataTransaction
            Da capire

function withdrawToken_to(address _token, address _to, uint _amount) 

if (!Token(token).transfer(msg.sender, amount)) throw;

if (!Token(token).transfer(_to, amount)) throw;

function withdrawToken_to(address token, address _to, uint amount) public payable{
    if (token==0) throw;
    if (tokens[token][msg.sender] < amount) throw;
    tokens[token][msg.sender] = safeSub(tokens[token][msg.sender], amount);
    if (!Token(token).transfer(_to, amount)) throw;
    Withdraw(token, _to, amount, tokens[token][msg.sender]);
  }

mapping (address => mapping (address => uint)) public tokens; //questo mappa un indirizzo di un token con un la mappatura di un indirizzo di un proprietario e la quantità di quei tokens

function newPurchase()
		public
		payable
		returns(address newContract)
	{
		Purchase c = (new Purchase).value(msg.value)(address(msg.sender));
		contracts.push(c);
		lastContractAddress = address(c);
		emit newPurchaseContract(c);
		return c;
	}

pragma solidity 0.4.18;
contract Balls {
    function addressFrom(address _origin, uint _nonce) public pure returns (address) {
        if(_nonce == 0x00)     return address(keccak256(byte(0xd6), byte(0x94), _origin, byte(0x80)));
        if(_nonce <= 0x7f)     return address(keccak256(byte(0xd6), byte(0x94), _origin, byte(_nonce)));
        if(_nonce <= 0xff)     return address(keccak256(byte(0xd7), byte(0x94), _origin, byte(0x81), uint8(_nonce)));
        if(_nonce <= 0xffff)   return address(keccak256(byte(0xd8), byte(0x94), _origin, byte(0x82), uint16(_nonce)));
        if(_nonce <= 0xffffff) return address(keccak256(byte(0xd9), byte(0x94), _origin, byte(0x83), uint24(_nonce)));
        return address(keccak256(byte(0xda), byte(0x94), _origin, byte(0x84), uint32(_nonce))); // more than 2^32 nonces not realistic
    }    
}