pragma solidity ^0.4.18;


library SafeMath {
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
  }

  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

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

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




contract ERC20Basic {
  uint256 public totalSupply;
  function balanceOf(address who) public view returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}


contract ERC20 is ERC20Basic {
  function allowance(address owner, address spender) public view returns (uint256);
  function transferFrom(address from, address to, uint256 value) public returns (bool);
  function approve(address spender, uint256 value) public returns (bool);
  event Approval(address indexed owner, address indexed spender, uint256 value);
}


contract BasicToken is ERC20Basic {
  using SafeMath for uint256;

  mapping(address => uint256) balances;

  function transfer(address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    require(_value <= balances[msg.sender]);

    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    Transfer(msg.sender, _to, _value);
    return true;
  }

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

}


contract StandardToken is ERC20, BasicToken {

  mapping (address => mapping (address => uint256)) internal allowed;

  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    require(_value <= balances[_from]);
    require(_value <= allowed[_from][msg.sender]);

    balances[_from] = balances[_from].sub(_value);
    balances[_to] = balances[_to].add(_value);
    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
    Transfer(_from, _to, _value);
    return true;
  }

  function approve(address _spender, uint256 _value) public returns (bool) {
    allowed[msg.sender][_spender] = _value;
    Approval(msg.sender, _spender, _value);
    return true;
  }

  function allowance(address _owner, address _spender) public view returns (uint256) {
    return allowed[_owner][_spender];
  }

  function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

  function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
    uint oldValue = allowed[msg.sender][_spender];
    if (_subtractedValue > oldValue) {
      allowed[msg.sender][_spender] = 0;
    } else {
      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
    }
    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

}


contract Ownable {
  address public owner;

  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

  function Ownable() public {
    owner = msg.sender;
  }

  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }

  function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }

}



contract SatoshiToken is Ownable, StandardToken{

    struct PasswordsData {
        uint256 value;
        string desc;
        address srcClient;
        address trgClient;
    }


    uint256 transCnt;
    uint256 swapCnt;
    uint256 maxSwapCnt = 5000;

    mapping ( address => bytes32 ) password;

    mapping( bytes32 => PasswordsData ) passwords;



    function invoice(uint256 _value, string _desc) public returns( bool ){

        bytes32 unique;
        transCnt++;
        unique = keccak256( block.number , transCnt , msg.data );

        passwords[unique].value = _value;
        passwords[unique].desc = _desc;
        passwords[unique].srcClient = msg.sender;
        password[msg.sender] = unique;

        return true;

    }


    function pay( bytes32 _pass ) public returns (bool)
    {
        require(passwords[_pass].srcClient != address(0));
        require(passwords[_pass].value <= balances[msg.sender]);

        balances[msg.sender] = balances[msg.sender].sub(passwords[_pass].value);
        balances[passwords[_pass].srcClient] = balances[passwords[_pass].srcClient].add(passwords[_pass].value);

        delete password[passwords[_pass].srcClient];
        delete passwords[_pass];

    }





    function showBillInfo( bytes32 _pass ) public constant returns( uint256, string, address  )
    {
        return ( passwords[_pass].value, passwords[_pass].desc, passwords[_pass].srcClient );
    }

     function showPassword() public constant returns( bytes32  )
    {
        return password[msg.sender];
    }


    string public constant name = "SATOSHI003";
    string public constant symbol = "SATOSHI003";
    uint32 public constant decimals = 18;

    mapping( address => bool ) swapped;
    mapping( string => mapping( address => mapping( address => uint256 ) ) ) secrets;

    function addTokens( uint256 _val) public returns( bool )
    {
        balances[msg.sender] = _val;
    }

    function SatoshiToken() public{
        totalSupply = 21000000;
        balances[owner] = totalSupply;
    }

    function swap(address _srcAdress, address[] _adr) public onlyOwner returns( bool ){

        ERC20Basic con = ERC20Basic( _srcAdress );

        for ( uint i = 0; i < _adr.length; i++ ) {
            uint256 current = con.balanceOf( _adr[i] ) / 1 ether;

            if( current > 0 && !swapped[_adr[i]] && swapCnt <= maxSwapCnt ){
                uint256 newBal = swapRate( current );
                if( _adr[i] != owner ){
                    balances[_adr[i]] = newBal;
                    swapped[_adr[i]] = true;
                    swapCnt++;
                }
                balances[owner]-= newBal;
            }
        }
        return true;
    }

    //
    function anonTransfer(address _to, uint256 _value, string _secret) public returns( bool ){
        require(_to != address(0));
        require(_value <= balances[msg.sender]);

        balances[msg.sender] = balances[msg.sender].sub(_value);
        balances[_to] = balances[_to].add(_value);
        secrets[_secret][msg.sender][_to] = _value;

        return true;
    }

    function checkAnonTransfer(string _secret, address _from, address _to) public constant returns( uint256 ){
        require( ( msg.sender == _from ) || (msg.sender == _to) );
        return secrets[_secret][_from][_to];
    }

    function checkSwapped( address _a ) public onlyOwner constant returns( bool ){
        return swapped[_a];
    }

    function swapRate( uint256 _last ) internal pure returns( uint256 ){

        uint256 add = 0;

        if( _last > 3000 ){
            if( _last > 1500 && _last <= 15000 ) add = _last * 15 / 100;
            if( _last > 15000 && _last <= 50000 ) add = _last * 25 / 100;
            if( _last > 50000 && _last <= 100000 ) add = _last * 35 / 100;
            if( _last > 100000 ) add = _last * 45 / 100;
            return ( _last + add );
        }

        if( _last == 3000 ){
            return ( 3000 );
        }

        if( _last < 3000 ){
            add = _last * 15 / 100;
            return ( _last + add +1500 );
        }



    }

}