add a miner executable

miner.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+
+import argparse
+from urllib.parse import urlparse
+from src.crypto import Signing
+from src.protocol import Protocol
+from src.block import GENESIS_BLOCK
+
+def parse_addr_port(val):
+    url = urlparse("//" + val)
+    assert url.scheme == ''
+    assert url.path == ''
+    assert url.params == ''
+    assert url.query == ''
+    assert url.fragment == ''
+    assert url.port is not None
+    assert url.hostname is not None
+    return (url.hostname, url.port)
+
+def main():
+    parser = argparse.ArgumentParser(description="Blockchain Miner.")
+    parser.add_argument("--listen-address", default="",
+                        help="The IP address where the P2P server should bind to.")
+    parser.add_argument("--listen-port", default=0, type=int,
+                        help="The port where the P2P server should listen. Defaults a dynamically assigned port.")
+    parser.add_argument("--mining-pubkey", type=argparse.FileType('rb'),
+                        help="The public key where mining rewards should be sent to. No mining is performed if this is left unspecified.")
+    parser.add_argument("--bootstrap-peer", action='append', type=parse_addr_port,
+                        help="Addresses of other P2P peers in the network.")
+
+    args = parser.parse_args()
+
+    proto = Protocol(args.bootstrap_peer, GENESIS_BLOCK, args.listen_port, args.listen_address)
+    if args.mining_pubkey is not None:
+        pubkey = Signing(args.mining_pubkey.read())
+        args.mining_pubkey.close()
+        miner = Miner(proto, pubkey)
+        miner.start_mining()
+
+    # TODO: start RPC
+    import time
+    while True:
+        time.sleep(2**31)
+
+if __name__ == '__main__':
+    main()

src/protocol.py

@@ -174,11 +174,12 @@ class Protocol:
     for handling messages from other peers.
     """
 
-    def __init__(self, bootstrap_peer, primary_block, listen_port=0):
+    def __init__(self, bootstrap_peers, primary_block, listen_port=0, listen_addr=""):
         """
-        :param bootstrap_peer: the network address of the peer where we bootstrap the P2P network from
+        :param bootstrap_peers: network addresses of peers where we bootstrap the P2P network from
         :param primary_block: the head of the primary block chain
         :param listen_port: the port where other peers should be able to reach us
+        :param listen_addr: the address where other peers should be able to reach us
         """
 
         self.block_receive_handlers = []
@@ -203,11 +204,11 @@ class Protocol:
 
                 conn = PeerConnection(self.client_address, self.proto, self.request)
                 self.proto.peers.append(conn)
-        self.server = SocketServer(("", listen_port), IncomingHandler)
+        self.server = SocketServer((listen_addr, listen_port), IncomingHandler)
         self.server.serve_forever_bg()
 
         # we want to do this only after we opened our listening socket
-        self.peers.append(PeerConnection(bootstrap_peer, self))
+        self.peers.extend([PeerConnection(peer, self) for peer in bootstrap_peers])
 
         Thread(target=self._main_thread, daemon=True).start()
 

tests/test_proto.py

@@ -8,8 +8,8 @@ from time import sleep
 
 reward_key = Signing.generatePrivateKey()
 
-proto1 = Protocol(("127.0.0.1", 1337), GENESIS_BLOCK, 1337)
-proto2 = Protocol(("127.0.0.1", 1337), GENESIS_BLOCK, 1338)
+proto1 = Protocol([], GENESIS_BLOCK, 1337)
+proto2 = Protocol([("127.0.0.1", 1337)], GENESIS_BLOCK, 1338)
 miner1 = Miner(proto1, reward_key)
 miner2 = Miner(proto2, reward_key)
 miner2.start_mining()