Helloobelisk

.gitignore

@@ -1,3 +1,6 @@
 *.pyc
 *.o
 *.so
+config.json
+tags
+.*.sw*

README.md

@@ -11,6 +11,11 @@ The darkwallet gateway is a daemon providing the following services to wallets:
 Generally the gateway tries to provide all services a wallet may need acting as a proxy to mask the user address so as to not compromise it in many services.
 
 
+Install:
+-------------
+
+see INSTALL file
+
 Running:
 -----------
 
@@ -27,25 +32,25 @@ Client cheatlist:
 
 Fetching a block header
 ```
-$ curl http://localhost:8888/block/000000000000000145f738890dc703e7637b677f15e9a49ea2eeca6e6e3c5f51
+$ curl http://localhost:8888/rest/v1/block/000000000000000145f738890dc703e7637b677f15e9a49ea2eeca6e6e3c5f51
 {"nonce": 2595258480, "timestamp": 1391031759, "version": 2, "prev_hash": "00000000000000012af08fe29312627aa6f74aa7f617925da4f4f3a572a95da0", "merkle": "088d6b08fbca5c9fb5c1970a7af5a17847d67635b80ca6f12bd982218e2a83ac", "bits": 419558700}
 ```
 
 Fetching block transactions
 ```
-$ curl http://localhost:8888/block/000000000000000145f738890dc703e7637b677f15e9a49ea2eeca6e6e3c5f51/transactions
+$ curl http://localhost:8888/rest/v1/block/000000000000000145f738890dc703e7637b677f15e9a49ea2eeca6e6e3c5f51/transactions
 {"transactions": ["0118256f73a29a2d6c06ea21fc48166ebf5acbcfaf57da3e173be7018e245338", "4424d7f653e29d731f95091d478816743c320fd7fa6a94f9bf8d4b2d7baf0975", ....
 ```
 
 Fetching transaction 
 ```
-$ curl http://localhost:8888/tx/5a002b39d70d0c3197afa1d2ae874083631f5a43cd4fe2b2cc35347d863f00f7
+$ curl http://localhost:8888/rest/v1/tx/5a002b39d70d0c3197afa1d2ae874083631f5a43cd4fe2b2cc35347d863f00f7
 {"inputs": [{"previous_output": ["da03f16974423bf6425be37e7a6297587a35f117ce3b657e781eeff0098faed5", 0], "sequence": 4294967295, ....
 ```
 
 address history 
 
 ```
-$ curl http://localhost:8888/address/1dice3jkpTvevsohA4Np1yP4uKzG1SRLv
+$ curl http://localhost:8888/rest/v1/address/1dice3jkpTvevsohA4Np1yP4uKzG1SRLv
 { "history" : [{"spend_hash": "cdf6ea4f4590fbc847855cf68af181f1398b8997081cf0cfbd14e0f2cf2808ea", "output_height": 228180, "spend_index": 0, "value": 1000000, ....
 ```

client/test.html

@@ -14,7 +14,7 @@
         write_to_screen("CONNECTED");
         test(client);
     };
-    var client = new GatewayClient("ws://obelisk.unsystem.net:8888/", handle_connect);
+    var client = new GatewayClient("ws://localhost:8888/", handle_connect);
 
     client.on_error = function(evt) {
         write_to_screen('<span style="color: red;">ERROR:</span> ' + evt.data);

daemon/base58.py

@@ -25,7 +25,7 @@ def b58encode(v):
 
     return (__b58chars[0]*nPad) + result
 
-def b58decode(v, length):
+def b58decode(v, length=None):
     """ decode v into a string of len bytes."""
     long_value = 0L
     for (i, c) in enumerate(v[::-1]):
@@ -47,4 +47,4 @@ def b58decode(v, length):
     if length is not None and len(result) != length:
         return None
 
-    return result
+    return result

daemon/gateway.py

@@ -1,15 +1,11 @@
 #!/usr/bin/env python
 
-import logging
 import tornado.options
 import tornado.web
 import tornado.websocket
-import os.path
 import obelisk
-import json
 import threading
 import code
-from collections import defaultdict
 
 import config
 
@@ -27,6 +23,7 @@
 
 import rest_handlers
 import obelisk_handler
+import querysocket_handler
 import jsonchan
 import broadcast
 import ticker
@@ -43,110 +40,32 @@ def __init__(self, service):
         settings = dict(debug=True)
         settings.update(options.as_dict())
         client = obelisk.ObeliskOfLightClient(service)
+        self.client = client
         self.obelisk_handler = obelisk_handler.ObeliskHandler(client)
         self.brc_handler = broadcast.BroadcastHandler()
         self.p2p = CryptoTransportLayer(config.get('p2p-port', 8889), config.get('external-ip', '127.0.0.1'))
         self.p2p.join_network(config.get('seeds', []))
         self.json_chan_handler = jsonchan.JsonChanHandler(self.p2p)
         self.ticker_handler = ticker.TickerHandler()
-
+        #websocket uri space
         handlers = [
-            # /block/<block hash>
-            (r"/block/([^/]*)(?:/)?", rest_handlers.BlockHeaderHandler),
-
-            # /block/<block hash>/transactions
-            (r"/block/([^/]*)/transactions(?:/)?",
-                rest_handlers.BlockTransactionsHandler),
-
-            # /tx/
-            (r"/tx(?:/)?", rest_handlers.TransactionPoolHandler),
-
-            # /tx/<txid>
-            (r"/tx/([^/]*)(?:/)?", rest_handlers.TransactionHandler),
-
-            # /address/<address>
-            (r"/address/([^/]*)(?:/)?", rest_handlers.AddressHistoryHandler),
-
-            # /height
-            (r"/height(?:/)?", rest_handlers.HeightHandler),
+            ## WebSocket Handler
+            (r"/", querysocket_handler.QuerySocketHandler)
+        ]
 
-            # /
-            (r"/", QuerySocketHandler)
+        # helloobelisk uri space
+        uri_space= r"/rest/v1/"
+        other_handlers = [
+            (uri_space + r'net(?:/)?', rest_handlers.NetHandler),
+            (uri_space + r'height(?:/)?', rest_handlers.HeightHandler),
+            (uri_space + r'address/([^/]*)(?:/)?', rest_handlers.AddressHistoryHandler),
+            (uri_space + r'tx/([^/]*)(?:/)?', rest_handlers.TransactionHandler),
+            (uri_space + r'block/([^/]*)(?:/)?', rest_handlers.BlockHeaderHandler),
+            (uri_space + r"block/([^/]*)/transactions(?:/)?",  rest_handlers.BlockTransactionsHandler),
         ]
+        all_handlers = other_handlers + handlers
+        tornado.web.Application.__init__(self, all_handlers, **settings)
 
-        tornado.web.Application.__init__(self, handlers, **settings)
-
-class QuerySocketHandler(tornado.websocket.WebSocketHandler):
-
-    # Set of WebsocketHandler
-    listeners = set()
-    # Protects listeners
-    listen_lock = threading.Lock()
-
-    def initialize(self):
-        self._obelisk_handler = self.application.obelisk_handler
-        self._brc_handler = self.application.brc_handler
-        self._json_chan_handler = self.application.json_chan_handler
-        self._ticker_handler = self.application.ticker_handler
-        self._subscriptions = defaultdict(dict)
-        self._connected = False
-
-    def open(self):
-        logging.info("OPEN")
-        with QuerySocketHandler.listen_lock:
-            self.listeners.add(self)
-        self._connected = True
-
-    def on_close(self):
-        logging.info("CLOSE")
-        disconnect_msg = {'command': 'disconnect_client', 'id': 0, 'params': []}
-        self._connected = False
-        self._obelisk_handler.handle_request(self, disconnect_msg)
-        self._json_chan_handler.handle_request(self, disconnect_msg)
-        with QuerySocketHandler.listen_lock:
-            self.listeners.remove(self)
-
-    def _check_request(self, request):
-        return request.has_key("command") and request.has_key("id") and \
-            request.has_key("params") and type(request["params"]) == list
-
-    def on_message(self, message):
-        try:
-            request = json.loads(message)
-        except:
-            logging.error("Error decoding message: %s", message, exc_info=True)
-
-        # Check request is correctly formed.
-        if not self._check_request(request):
-            logging.error("Malformed request: %s", request, exc_info=True)
-            return
-        # Try different handlers until one accepts request and
-        # processes it.
-        if self._json_chan_handler.handle_request(self, request):
-            return
-        if self._obelisk_handler.handle_request(self, request):
-            return
-        if self._brc_handler.handle_request(self, request):
-            return
-        if self._ticker_handler.handle_request(self, request):
-            return
-        logging.warning("Unhandled command. Dropping request: %s",
-            request, exc_info=True)
-
-    def _send_response(self, response):
-        try:
-            self.write_message(json.dumps(response))
-        except tornado.websocket.WebSocketClosedError:
-            self._connected = False
-            logging.warning("Dropping response to closed socket: %s",
-               response, exc_info=True)
-
-    def queue_response(self, response):
-        try:
-            # calling write_message or the socket is not thread safe
-            ioloop.add_callback(self._send_response, response)
-        except:
-            logging.error("Error adding callback", exc_info=True)
 
 class DebugConsole(threading.Thread):
 
@@ -170,5 +89,8 @@ def main(service):
 
 if __name__ == "__main__":
     service = config.get("obelisk-url", "tcp://127.0.0.1:9091")
-    main(service)
+    try:
+        main(service)
+    except KeyboardInterrupt:
+        reactor.stop()
 

daemon/obelisk_handler.py

@@ -1,5 +1,6 @@
 from twisted.internet import reactor
 
+import base58 
 import logging
 import obelisk
 
@@ -131,7 +132,7 @@ def call_method(self, method, params):
 
     def translate_arguments(self, params):
         if len(params) != 1 and len(params) != 2:
-            raise ValueError("Invalid parameter list length")
+            raise ValueError("Invalid parameter list length %s" % len(params))
         address = params[0]
         if len(params) == 2:
             from_height = params[1]

daemon/querysocket_handler.py

@@ -0,0 +1,81 @@
+import tornado
+import logging
+import threading
+from collections import defaultdict
+import json
+
+
+class QuerySocketHandler(tornado.websocket.WebSocketHandler):
+
+    # Set of WebsocketHandler
+    listeners = set()
+    # Protects listeners
+    listen_lock = threading.Lock()
+
+    def initialize(self):
+        self._obelisk_handler = self.application.obelisk_handler
+        self._brc_handler = self.application.brc_handler
+        self._json_chan_handler = self.application.json_chan_handler
+        self._ticker_handler = self.application.ticker_handler
+        self._subscriptions = defaultdict(dict)
+        self._connected = False
+
+    def open(self):
+        logging.info("OPEN")
+        with QuerySocketHandler.listen_lock:
+            self.listeners.add(self)
+        self._connected = True
+
+    def on_close(self):
+        logging.info("CLOSE")
+        disconnect_msg = {'command': 'disconnect_client', 'id': 0, 'params': []}
+        self._connected = False
+        self._obelisk_handler.handle_request(self, disconnect_msg)
+        self._json_chan_handler.handle_request(self, disconnect_msg)
+        with QuerySocketHandler.listen_lock:
+            self.listeners.remove(self)
+
+    def _check_request(self, request):
+        return request.has_key("command") and request.has_key("id") and \
+            request.has_key("params") and type(request["params"]) == list
+
+    def on_message(self, message):
+        try:
+            request = json.loads(message)
+        except:
+            logging.error("Error decoding message: %s", message, exc_info=True)
+            return 
+
+        # Check request is correctly formed.
+        if not self._check_request(request):
+            logging.error("Malformed request: %s", request, exc_info=True)
+            return
+        # Try different handlers until one accepts request and
+        # processes it.
+        if self._json_chan_handler.handle_request(self, request):
+            return
+        if self._obelisk_handler.handle_request(self, request):
+            return
+        if self._brc_handler.handle_request(self, request):
+            return
+        if self._ticker_handler.handle_request(self, request):
+            return
+        logging.warning("Unhandled command. Dropping request: %s",
+            request, exc_info=True)
+
+    def _send_response(self, response):
+        try:
+            self.write_message(json.dumps(response))
+        except tornado.websocket.WebSocketClosedError:
+            self._connected = False
+            logging.warning("Dropping response to closed socket: %s",
+               response, exc_info=True)
+
+    def queue_response(self, response):
+        ioloop = tornado.ioloop.IOLoop.current()
+        try:
+            # calling write_message or the socket is not thread safe
+            ioloop.add_callback(self._send_response, response)
+        except:
+            logging.error("Error adding callback", exc_info=True)
+