AaronFiore/electrum
1
0
Fork 0
Code Activity

Remove explicit send calls, part deux (#4408)

Browse Source 
* Rename synchronous_get to synchronous_send

This makes it more inline with the method 'send' of which
synchronous_send is the, well, synchronous version.

* Move protocol strings from scripts to network

This is again a small step in the right direction. The network module is
going to accumulate more and more of these simple methods. Once
everything is moved into that module, that module is going to be split.

Note that I've left the scripts which use scripts/util.py alone. I
suspect the same functionality can be reached when using just
lib/network.py and that scripts/util.py is obsolete.

* Remove protocol string from verifier and websocket

Websocket still has some references, that'll take more work to remove. Once the
network module has been split this should be easy.
I took the liberty to rename a variable to better show what it is.

* Remove protocol strings from remainder

The naming scheme I'm following for the newly introduced methods in the network
module is: 'blockchain.<subject>.<action>' -> def <action>_(for|to)_<subject>

* Move explicit protocol calls closer to each other

This makes it easier to keep track of the methods which are due to be
extracted.

* Remove `send` when using `get_transaction`

This is the final step to formalize (the informal) interface of the network
module.
A chance of note is changed interface for async/sync calls. It is no longer
required to use the `synchronous_send` call. Merely NOT passing a callback
makes the call synchronous. I feel this makes the API more intuitive to work
with and easier to replace with a different network module.

* Remove send from get_merkle_for_transaction

The pattern which emerged for calling the lambda yielded an slight refactor.
I'm not happy with the name for the `__invoke` method.

* Remove explict send from websockets

* Remove explicit send from scripts

* Remove explicit send from wallet

* Remove explicit sync_send from commands, scripts

* Remove optional timeout parameter

This parameter doesn't seem to be used a lot and removing it makes the
remaining calls easier. Potentionally a contentious choice!

* Rename `broadcast` to `broadcast_transaction`

Doing so makes the method name consistent with the other ElectrumX protocol
method names.

* Remove synchronous_send

Now every method is intuitive in what it does, no special handling required.
The `broadcast_transaction` method is weird. I've opted not to change the
return type b/c I found it hard to know what the exact consequences are. But
ideally this method should just works as all the other ElectrumX related
messages. On the other hand this shows nicely how you _can_ do something
differnt quite easy.

* Rename the awkwardly name `__invoke` method

The new name reflects what it does.

* Process the result of linter feedback

I've used flake8-diff (and ignored a couple of line length warnings).

* Rename tx_response to on_tx_response

This fell through the cracks when this branch was rebased.

* subscript_to_scripthash should be get_balance

An oversight while refactoring.

* Add missing return statement

Without this statement the transaction would have been broadcasted twice.

* Pass list of tuples to send not single tuple

* Add @staticmethod decorator

* Fix argument to be an array
This commit is contained in:
Harm Aarts
2018-06-06 15:06:04 +02:00
committed by ghost43
parent 0fb3d3c825
commit e57e55aad8
14 changed files with 154 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
lib/network.py
View File

@@ -620,26 +620,6 @@ class Network(util.DaemonThread):
# Response is now in canonical form
self.process_response(interface, response, callbacks)
def map_scripthash_to_address(self, callback):
def cb2(x):
x2 = x.copy()
p = x2.pop('params')
addr = self.h2addr[p[0]]
x2['params'] = [addr]
callback(x2)
return cb2
def subscribe_to_addresses(self, addresses, callback):
hash2address = {bitcoin.address_to_scripthash(address): address for address in addresses}
self.h2addr.update(hash2address)
msgs = [('blockchain.scripthash.subscribe', [x]) for x in hash2address.keys()]
self.send(msgs, self.map_scripthash_to_address(callback))
def request_address_history(self, address, callback):
h = bitcoin.address_to_scripthash(address)
self.h2addr.update({h: address})
self.send([('blockchain.scripthash.get_history', [h])], self.map_scripthash_to_address(callback))
def send(self, messages, callback):
'''Messages is a list of (method, params) tuples'''
messages = list(messages)
@@ -668,6 +648,7 @@ class Network(util.DaemonThread):
self.subscriptions[k] = l
# check cached response for subscriptions
r = self.sub_cache.get(k)
if r is not None:
self.print_error("cache hit", k)
callback(r)
@@ -802,12 +783,6 @@ class Network(util.DaemonThread):
blockchain.catch_up = None
self.notify('updated')
def request_header(self, interface, height):
#interface.print_error("requesting header %d" % height)
self.queue_request('blockchain.block.get_header', [height], interface)
interface.request = height
interface.req_time = time.time()
def on_get_header(self, interface, response):
'''Handle receiving a single block header'''
header = response.get('result')
@@ -1062,27 +1037,134 @@ class Network(util.DaemonThread):
def get_local_height(self):
return self.blockchain().height()
def synchronous_get(self, request, timeout=30):
@staticmethod
def __wait_for(it):
"""Wait for the result of calling lambda `it`."""
q = queue.Queue()
self.send([request], q.put)
it(q.put)
try:
r = q.get(True, timeout)
result = q.get(block=True, timeout=30)
except queue.Empty:
raise util.TimeoutException(_('Server did not answer'))
if r.get('error'):
raise Exception(r.get('error'))
return r.get('result')
def broadcast(self, tx, timeout=30):
tx_hash = tx.txid()
if result.get('error'):
raise Exception(result.get('error'))
return result.get('result')
@staticmethod
def __with_default_synchronous_callback(invocation, callback):
""" Use this method if you want to make the network request
synchronous. """
if not callback:
return Network.__wait_for(invocation)
invocation(callback)
def request_header(self, interface, height):
self.queue_request('blockchain.block.get_header', [height], interface)
interface.request = height
interface.req_time = time.time()
def map_scripthash_to_address(self, callback):
def cb2(x):
x2 = x.copy()
p = x2.pop('params')
addr = self.h2addr[p[0]]
x2['params'] = [addr]
callback(x2)
return cb2
def subscribe_to_addresses(self, addresses, callback):
hash2address = {
bitcoin.address_to_scripthash(address): address
for address in addresses}
self.h2addr.update(hash2address)
msgs = [
('blockchain.scripthash.subscribe', [x])
for x in hash2address.keys()]
self.send(msgs, self.map_scripthash_to_address(callback))
def request_address_history(self, address, callback):
h = bitcoin.address_to_scripthash(address)
self.h2addr.update({h: address})
self.send([('blockchain.scripthash.get_history', [h])], self.map_scripthash_to_address(callback))
# NOTE this method handles exceptions and a special edge case, counter to
# what the other ElectrumX methods do. This is unexpected.
def broadcast_transaction(self, transaction, callback=None):
command = 'blockchain.transaction.broadcast'
invocation = lambda c: self.send([(command, [str(transaction)])], c)
if callback:
invocation(callback)
return
try:
out = self.synchronous_get(('blockchain.transaction.broadcast', [str(tx)]), timeout)
out = Network.__wait_for(invocation)
except BaseException as e:
return False, "error: " + str(e)
if out != tx_hash:
if out != transaction.txid():
return False, "error: " + out
return True, out
def get_history_for_scripthash(self, hash, callback=None):
command = 'blockchain.scripthash.get_history'
invocation = lambda c: self.send([(command, [hash])], c)
return Network.__with_default_synchronous_callback(invocation, callback)
def subscribe_to_headers(self, callback=None):
command = 'blockchain.headers.subscribe'
invocation = lambda c: self.send([(command, [True])], c)
return Network.__with_default_synchronous_callback(invocation, callback)
def subscribe_to_address(self, address, callback=None):
command = 'blockchain.address.subscribe'
invocation = lambda c: self.send([(command, [address])], c)
return Network.__with_default_synchronous_callback(invocation, callback)
def get_merkle_for_transaction(self, tx_hash, tx_height, callback=None):
command = 'blockchain.transaction.get_merkle'
invocation = lambda c: self.send([(command, [tx_hash, tx_height])], c)
return Network.__with_default_synchronous_callback(invocation, callback)
def subscribe_to_scripthash(self, scripthash, callback=None):
command = 'blockchain.scripthash.subscribe'
invocation = lambda c: self.send([(command, [scripthash])], c)
return Network.__with_default_synchronous_callback(invocation, callback)
def get_transaction(self, transaction_hash, callback=None):
command = 'blockchain.transaction.get'
invocation = lambda c: self.send([(command, [transaction_hash])], c)
return Network.__with_default_synchronous_callback(invocation, callback)
def get_transactions(self, transaction_hashes, callback=None):
command = 'blockchain.transaction.get'
messages = [(command, [tx_hash]) for tx_hash in transaction_hashes]
invocation = lambda c: self.send(messages, c)
return Network.__with_default_synchronous_callback(invocation, callback)
def listunspent_for_scripthash(self, scripthash, callback=None):
command = 'blockchain.scripthash.listunspent'
invocation = lambda c: self.send([(command, [scripthash])], c)
return Network.__with_default_synchronous_callback(invocation, callback)
def get_balance_for_scripthash(self, scripthash, callback=None):
command = 'blockchain.scripthash.get_balance'
invocation = lambda c: self.send([(command, [scripthash])], c)
return Network.__with_default_synchronous_callback(invocation, callback)
def export_checkpoints(self, path):
# run manually from the console to generate checkpoints
cp = self.blockchain().get_checkpoints()