One-way communication offline funds transfer using QR-code

Tribler/Core/Modules/restapi/trustchain_endpoint.py

@@ -13,7 +13,11 @@ class TrustchainEndpoint(resource.Resource):
     def __init__(self, session):
         resource.Resource.__init__(self)
 
-        child_handler_dict = {"statistics": TrustchainStatsEndpoint, "blocks": TrustchainBlocksEndpoint}
+        child_handler_dict = {
+            "statistics": TrustchainStatsEndpoint,
+            "blocks": TrustchainBlocksEndpoint,
+            "bootstrap": TrustchainBootstrapEndpoint
+        }
 
         for path, child_cls in child_handler_dict.iteritems():
             self.putChild(path, child_cls(session))
@@ -165,3 +169,67 @@ def render_GET(self, request):
 
         blocks = mc_community.persistence.get_latest_blocks(self.identity.decode("HEX"), limit_blocks)
         return json.dumps({"blocks": [dict(block) for block in blocks]})
+
+
+class TrustchainBootstrapEndpoint(TrustchainBaseEndpoint):
+    """
+    Bootstrap a new identity and transfer some bandwidth tokens to the new key.
+    """
+
+    def render_GET(self, request):
+        """
+        .. http:get:: /trustchain/bootstrap?amount=int
+
+        A GET request to this endpoint generates a new identity and transfers bandwidth tokens to it.
+        The amount specifies how much tokens need to be emptied into the new identity
+
+            **Example request**:
+
+            .. sourcecode:: none
+
+                curl -X GET http://localhost:8085/trustchain/bootstrap?amount=1000
+
+            **Example response**:
+
+            .. sourcecode:: javascript
+
+                {
+                    "private_key": "TGliTmFDTFNLOmC4BR7otCpn+NzTBAFwKdSJdpT0KG9Zy5vPGX6s3rDXmNiDoGKyToLeYYB88vj9\nRj5NW
+                                    pbNf/ldcixYZ2YxQ7Q=\n",
+                    "transaction": {
+                        "down": 0,
+                        "up": 1000
+                    },
+                    "block": {
+                        "block_hash": "THJxNlKWMQG1Tio+Yz5CUCrnWahcyk6TDVfRLQf7w6M=\n",
+                        "sequence_number": 1
+                    }
+                }
+        """
+
+        mc_community = self.get_trustchain_community()
+        if not mc_community:
+            request.setResponseCode(http.NOT_FOUND)
+            return json.dumps({"error": "trustchain community not found"})
+
+        available_tokens = mc_community.get_bandwidth_tokens()
+
+        if 'amount' in request.args:
+            try:
+                amount = int(request.args['amount'][0])
+            except ValueError:
+                request.setResponseCode(http.BAD_REQUEST)
+                return json.dumps({"error": "Provided token amount is not a number"})
+
+            if amount <= 0:
+                request.setResponseCode(http.BAD_REQUEST)
+                return json.dumps({"error": "Provided token amount is zero or negative"})
+        else:
+            amount = available_tokens
+
+        if amount <= 0 or amount > available_tokens:
+            request.setResponseCode(http.BAD_REQUEST)
+            return json.dumps({"error": "Not enough bandwidth tokens available"})
+
+        result = mc_community.bootstrap_new_identity(amount)
+        return json.dumps(result)

Tribler/Test/Community/Triblerchain/test_community.py

@@ -386,3 +386,65 @@ def test_get_default_trust(self):
         other_trust = blockingCallFromThread(reactor, other.community.get_trust, node.community.my_member)
         self.assertEqual(node_trust, 1)
         self.assertEqual(other_trust, 1)
+
+    def test_get_bandwidth_tokens_for_self(self):
+        """
+        Test that the bandwidth tokens the own node has is the upload - the download total of all blocks.
+        """
+        # Arrange
+        node, other = self.create_nodes(2)
+        transaction = {'up': 10, 'down': 5}
+        transaction2 = {'up': 5, 'down': 10}
+        TestTriblerChainCommunity.create_block(node, other, self._create_target(node, other), transaction)
+        TestTriblerChainCommunity.create_block(other, node, self._create_target(other, node), transaction2)
+
+        # Get statistics
+        node_trust = blockingCallFromThread(reactor, node.community.get_bandwidth_tokens, node.community.my_member)
+        other_trust = blockingCallFromThread(reactor, other.community.get_bandwidth_tokens, other.community.my_member)
+        self.assertEqual(node_trust, 5)
+        self.assertEqual(other_trust, -5)
+
+    def test_get_bandwidth_tokens(self):
+        """
+        Test that the bandwidth tokens nodes have is the upload - the download total of all blocks.
+        """
+        # Arrange
+        node, other = self.create_nodes(2)
+        transaction = {'up': 10, 'down': 5}
+        transaction2 = {'up': 5, 'down': 10}
+        TestTriblerChainCommunity.create_block(node, other, self._create_target(node, other), transaction)
+        TestTriblerChainCommunity.create_block(other, node, self._create_target(other, node), transaction2)
+
+        # Get statistics
+        node_trust = blockingCallFromThread(reactor, node.community.get_bandwidth_tokens, other.community.my_member)
+        other_trust = blockingCallFromThread(reactor, other.community.get_bandwidth_tokens, node.community.my_member)
+        self.assertEqual(node_trust, -5)
+        self.assertEqual(other_trust, 5)
+
+    def test_get_default_bandwidth_tokens(self):
+        """
+        Test that the bandwidth token amount for nodes without blocks is 0.
+        """
+        # Arrange
+        node, other = self.create_nodes(2)
+
+        # Get statistics
+        node_trust = blockingCallFromThread(reactor, node.community.get_bandwidth_tokens, other.community.my_member)
+        other_trust = blockingCallFromThread(reactor, other.community.get_bandwidth_tokens, node.community.my_member)
+        self.assertEqual(node_trust, 0)
+        self.assertEqual(other_trust, 0)
+
+    def test_bootstrapping(self):
+        """
+        Test that bootstrapping process works.
+        """
+        # Arrange
+        node, = self.create_nodes(1)
+
+        node_bootstrap = blockingCallFromThread(reactor, node.community.bootstrap_new_identity, 100)
+        self.assertNotEqual(node_bootstrap['private_key'],
+                            node.community.my_member.private_key.key_to_bin().encode('base64'))
+        self.assertEqual(node_bootstrap['transaction']['up'], 100)
+        self.assertEqual(node_bootstrap['transaction']['down'], 0)
+        self.assertEqual(node_bootstrap['block']['sequence_number'], 1)
+        self.assertNotEqual(node_bootstrap['block']['block_hash'], "")

Tribler/Test/Community/Trustchain/test_trustchain_utilities.py

@@ -16,7 +16,7 @@ class TestBlock(TrustChainBlock):
     Also used in other test files for TrustChain.
     """
 
-    def __init__(self, transaction=None, previous=None):
+    def __init__(self, transaction=None, previous=None, key=None):
         crypto = ECCrypto()
         other = crypto.generate_key(u"curve25519").pub().key_to_bin()
 
@@ -27,7 +27,11 @@ def __init__(self, transaction=None, previous=None):
             TrustChainBlock.__init__(self, (encode(transaction), previous.public_key, previous.sequence_number + 1,
                                             other, 0, previous.hash, 0, 0))
         else:
-            self.key = crypto.generate_key(u"curve25519")
+            if key:
+                self.key = key
+            else:
+                self.key = crypto.generate_key(u"curve25519")
+
             TrustChainBlock.__init__(self, (
                 encode(transaction), self.key.pub().key_to_bin(), random.randint(50, 100), other, 0,
                 sha256(str(random.randint(0, 100000))).digest(), 0, 0))

Tribler/Test/Core/Modules/RestApi/test_trustchain_endpoint.py

@@ -166,3 +166,95 @@ def test_get_blocks_unlimited(self):
         self.should_check_equality = False
         return self.do_request('trustchain/blocks/%s' % TestBlock().public_key.encode("HEX"),
                                expected_code=200)
+
+    @deferred(timeout=10)
+    def test_get_bootstrap_identity_no_community(self):
+        """
+        Testing whether the API returns error 404 if no trustchain community is loaded when bootstrapping a new identity
+        """
+        self.dispersy.get_communities = lambda: []
+        return self.do_request('trustchain/bootstrap', expected_code=404)
+
+    @deferred(timeout=10)
+    def test_get_bootstrap_identity_all_tokens(self):
+        """
+        Testing whether the API return all available credit when no argument is supplied
+        """
+        transaction = {'up': 100, 'down': 0, 'total_up': 100, 'total_down': 0}
+        transaction2 = {'up': 100, 'down': 0}
+
+        def verify_response(response):
+            response_json = json.loads(response)
+            self.assertEqual(response_json['transaction'], transaction2)
+
+        test_block = TestBlock(transaction=transaction, key=self.tc_community.my_member.private_key)
+        self.tc_community.persistence.add_block(test_block)
+
+        self.should_check_equality = False
+        return self.do_request('trustchain/bootstrap', expected_code=200).addCallback(verify_response)
+
+    @deferred(timeout=10)
+    def test_get_bootstrap_identity_partial_tokens(self):
+        """
+        Testing whether the API return partial available credit when argument is supplied
+        """
+        transaction = {'up': 100, 'down': 0, 'total_up': 100, 'total_down': 0}
+        transaction2 = {'up': 50, 'down': 0}
+
+        def verify_response(response):
+            response_json = json.loads(response)
+            self.assertEqual(response_json['transaction'], transaction2)
+
+        test_block = TestBlock(transaction=transaction, key=self.tc_community.my_member.private_key)
+        self.tc_community.persistence.add_block(test_block)
+
+        self.should_check_equality = False
+        return self.do_request('trustchain/bootstrap?amount=50', expected_code=200).addCallback(verify_response)
+
+    @deferred(timeout=10)
+    def test_get_bootstrap_identity_not_enough_tokens(self):
+        """
+        Testing whether the API returns error 400 if bandwidth is to low when bootstrapping a new identity
+        """
+        transaction = {'up': 100, 'down': 0, 'total_up': 100, 'total_down': 0}
+        test_block = TestBlock(transaction=transaction, key=self.tc_community.my_member.private_key)
+        self.tc_community.persistence.add_block(test_block)
+
+        self.should_check_equality = False
+        return self.do_request('trustchain/bootstrap?amount=200', expected_code=400)
+
+    @deferred(timeout=10)
+    def test_get_bootstrap_identity_not_enough_tokens_2(self):
+        """
+        Testing whether the API returns error 400 if bandwidth is to low when bootstrapping a new identity
+        """
+        transaction = {'up': 0, 'down': 100, 'total_up': 0, 'total_down': 100}
+        test_block = TestBlock(transaction=transaction, key=self.tc_community.my_member.private_key)
+        self.tc_community.persistence.add_block(test_block)
+
+        self.should_check_equality = False
+        return self.do_request('trustchain/bootstrap?amount=10', expected_code=400)
+
+    @deferred(timeout=10)
+    def test_get_bootstrap_identity_zero_amount(self):
+        """
+        Testing whether the API returns error 400 if amount is zero when bootstrapping a new identity
+        """
+        self.should_check_equality = False
+        return self.do_request('trustchain/bootstrap?amount=0', expected_code=400)
+
+    @deferred(timeout=10)
+    def test_get_bootstrap_identity_negative_amount(self):
+        """
+        Testing whether the API returns error 400 if amount is negative when bootstrapping a new identity
+        """
+        self.should_check_equality = False
+        return self.do_request('trustchain/bootstrap?amount=-1', expected_code=400)
+
+    @deferred(timeout=10)
+    def test_get_bootstrap_identity_string(self):
+        """
+        Testing whether the API returns error 400 if amount is string when bootstrapping a new identity
+        """
+        self.should_check_equality = False
+        return self.do_request('trustchain/bootstrap?amount=aaa', expected_code=400)

Tribler/community/triblerchain/community.py

@@ -8,7 +8,7 @@
 from Tribler.community.trustchain.community import TrustChainCommunity
 from Tribler.dispersy.util import blocking_call_on_reactor_thread
 
-MIN_TRANSACTION_SIZE = 1024*1024
+MIN_TRANSACTION_SIZE = 1024 * 1024
 
 
 class PendingBytes(object):
@@ -163,7 +163,7 @@ def on_tunnel_remove(self, subject, change_type, tunnel, candidate):
         from Tribler.community.tunnel.tunnel_community import Circuit, RelayRoute, TunnelExitSocket
         assert isinstance(tunnel, Circuit) or isinstance(tunnel, RelayRoute) or isinstance(tunnel, TunnelExitSocket), \
             "on_tunnel_remove() was called with an object that is not a Circuit, RelayRoute or TunnelExitSocket"
-        assert isinstance(tunnel.bytes_up, int) and isinstance(tunnel.bytes_down, int),\
+        assert isinstance(tunnel.bytes_up, int) and isinstance(tunnel.bytes_down, int), \
             "tunnel instance must provide byte counts in int"
 
         up = tunnel.bytes_up
@@ -215,6 +215,59 @@ def get_trust(self, member):
             # We need a minimum of 1 trust to have a chance to be selected in the categorical distribution.
             return 1
 
+    def get_bandwidth_tokens(self, member=None):
+        """
+        Get the bandwidth tokens for another member.
+        Currently this is just the difference in the amount of MBs exchanged with them.
+
+        :param member: the member we interacted with
+        :type member: dispersy.member.Member
+        :return: the amount of bandwidth tokens for this member
+        :rtype: int
+        """
+        if member is None:
+            member = self.my_member
+
+        block = self.persistence.get_latest(member.public_key)
+        if block:
+            return block.transaction['total_up'] - block.transaction['total_down']
+
+        return 0
+
+    def bootstrap_new_identity(self, amount):
+        """
+        One-way payment channel.
+        Create a new temporary identity, and transfer funds to the new identity.
+        A different party can then take the result and do a transfer from the temporary identity to itself
+        """
+
+        # Create new identity for the temporary identity
+        tmp_member = self.dispersy.get_new_member(u"curve25519")
+
+        # Create the transaction specification
+        transaction = {
+            'up': 0, 'down': amount
+        }
+
+        # Create the two half blocks that form the transaction
+        local_half_block = TriblerChainBlock.create(transaction, self.persistence, self.my_member.public_key,
+                                                    link_pk=tmp_member.public_key)
+        local_half_block.sign(self.my_member.private_key)
+        tmp_half_block = TriblerChainBlock.create(transaction, self.persistence, tmp_member.public_key,
+                                                  link=local_half_block, link_pk=self.my_member.public_key)
+        tmp_half_block.sign(tmp_member.private_key)
+
+        self.persistence.add_block(local_half_block)
+        self.persistence.add_block(tmp_half_block)
+
+        # Create the bootstrapped identity format
+        block = {'block_hash': tmp_half_block.hash.encode('base64'),
+                 'sequence_number': tmp_half_block.sequence_number}
+
+        result = {'private_key': tmp_member.private_key.key_to_bin().encode('base64'),
+                  'transaction': {'up': amount, 'down': 0}, 'block': block}
+        return result
+
 
 class TriblerChainCommunityCrawler(TriblerChainCommunity):
     """