file reorganization with top-level module

electrum/scripts/bip70.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+# create a BIP70 payment request signed with a certificate
+
+import tlslite
+
+from electrum.transaction import Transaction
+from electrum import paymentrequest
+from electrum import paymentrequest_pb2 as pb2
+
+chain_file = 'mychain.pem'
+cert_file = 'mycert.pem'
+amount = 1000000
+address = "18U5kpCAU4s8weFF8Ps5n8HAfpdUjDVF64"
+memo = "blah"
+out_file = "payreq"
+
+
+with open(chain_file, 'r') as f:
+    chain = tlslite.X509CertChain()
+    chain.parsePemList(f.read())
+
+certificates = pb2.X509Certificates()
+certificates.certificate.extend(map(lambda x: str(x.bytes), chain.x509List))
+
+with open(cert_file, 'r') as f:
+    rsakey = tlslite.utils.python_rsakey.Python_RSAKey.parsePEM(f.read())
+
+script = Transaction.pay_script('address', address).decode('hex')
+
+pr_string = paymentrequest.make_payment_request(amount, script, memo, rsakey)
+
+with open(out_file,'wb') as f:
+    f.write(pr_string)
+
+print("Payment request was written to file '%s'"%out_file)

electrum/scripts/block_headers.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+
+# A simple script that connects to a server and displays block headers
+
+import time
+from .. import SimpleConfig, Network
+from electrum.util import print_msg, json_encode
+
+# start network
+c = SimpleConfig()
+network = Network(c)
+network.start()
+
+# wait until connected
+while network.is_connecting():
+    time.sleep(0.1)
+
+if not network.is_connected():
+    print_msg("daemon is not connected")
+    sys.exit(1)
+
+# 2. send the subscription
+callback = lambda response: print_msg(json_encode(response.get('result')))
+network.send([('server.version',["block_headers script", "1.2"])], callback)
+network.subscribe_to_headers(callback)
+
+# 3. wait for results
+while network.is_connected():
+    time.sleep(1)

electrum/scripts/estimate_fee.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+from . import util
+import json
+from electrum.network import filter_protocol
+peers = filter_protocol(util.get_peers())
+results = util.send_request(peers, 'blockchain.estimatefee', [2])
+print(json.dumps(results, indent=4))

electrum/scripts/get_history.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+
+import sys
+from .. import Network
+from electrum.util import json_encode, print_msg
+from electrum import bitcoin
+
+try:
+    addr = sys.argv[1]
+except Exception:
+    print("usage: get_history <bitcoin_address>")
+    sys.exit(1)
+
+n = Network()
+n.start()
+_hash = bitcoin.address_to_scripthash(addr)
+h = n.get_history_for_scripthash(_hash)
+print_msg(json_encode(h))

electrum/scripts/peers.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+
+from . import util
+
+from electrum.network import filter_protocol
+from electrum.blockchain import hash_header
+
+peers = util.get_peers()
+peers = filter_protocol(peers, 's')
+
+results = util.send_request(peers, 'blockchain.headers.subscribe', [])
+
+for n,v in sorted(results.items(), key=lambda x:x[1].get('block_height')):
+    print("%60s"%n, v.get('block_height'), hash_header(v))

electrum/scripts/servers.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+
+from .. import set_verbosity
+from electrum.network import filter_version
+from . import util
+import json
+set_verbosity(False)
+
+servers = filter_version(util.get_peers())
+print(json.dumps(servers, sort_keys = True, indent = 4))

electrum/scripts/txradar.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+from . import util
+import sys
+try:
+    tx = sys.argv[1]
+except:
+    print("usage: txradar txid")
+    sys.exit(1)
+
+peers = util.get_peers()
+results = util.send_request(peers, 'blockchain.transaction.get', [tx])
+
+r1 = []
+r2 = []
+
+for k, v in results.items():
+    (r1 if v else r2).append(k)
+
+print("Received %d answers"%len(results))
+print("Propagation rate: %.1f percent" % (len(r1) *100./(len(r1)+ len(r2))))

electrum/scripts/util.py

@@ -0,0 +1,87 @@
+import select, time, queue
+# import electrum
+from .. import Connection, Interface, SimpleConfig
+
+from electrum.network import parse_servers
+from collections import defaultdict
+
+# electrum.util.set_verbosity(1)
+def get_interfaces(servers, timeout=10):
+    '''Returns a map of servers to connected interfaces.  If any
+    connections fail or timeout, they will be missing from the map.
+    '''
+    assert type(servers) is list
+    socket_queue = queue.Queue()
+    config = SimpleConfig()
+    connecting = {}
+    for server in servers:
+        if server not in connecting:
+            connecting[server] = Connection(server, socket_queue, config.path)
+    interfaces = {}
+    timeout = time.time() + timeout
+    count = 0
+    while time.time() < timeout and count < len(servers):
+        try:
+            server, socket = socket_queue.get(True, 0.3)
+        except queue.Empty:
+            continue
+        if socket:
+            interfaces[server] = Interface(server, socket)
+        count += 1
+    return interfaces
+
+def wait_on_interfaces(interfaces, timeout=10):
+    '''Return a map of servers to a list of (request, response) tuples.
+    Waits timeout seconds, or until each interface has a response'''
+    result = defaultdict(list)
+    timeout = time.time() + timeout
+    while len(result) < len(interfaces) and time.time() < timeout:
+        rin = [i for i in interfaces.values()]
+        win = [i for i in interfaces.values() if i.unsent_requests]
+        rout, wout, xout = select.select(rin, win, [], 1)
+        for interface in wout:
+            interface.send_requests()
+        for interface in rout:
+            responses = interface.get_responses()
+            if responses:
+                result[interface.server].extend(responses)
+    return result
+
+def get_peers():
+    config = SimpleConfig()
+    peers = {}
+    # 1. get connected interfaces
+    server = config.get('server')
+    if server is None:
+        print("You need to set a secure server, for example (for mainnet): 'electrum setconfig server helicarrier.bauerj.eu:50002:s'")
+        return []
+    interfaces = get_interfaces([server])
+    if not interfaces:
+        print("No connection to", server)
+        return []
+    # 2. get list of peers
+    interface = interfaces[server]
+    interface.queue_request('server.peers.subscribe', [], 0)
+    responses = wait_on_interfaces(interfaces).get(server)
+    if responses:
+        response = responses[0][1]  # One response, (req, response) tuple
+        peers = parse_servers(response.get('result'))
+    return peers
+
+
+def send_request(peers, method, params):
+    print("Contacting %d servers"%len(peers))
+    interfaces = get_interfaces(peers)
+    print("%d servers could be reached" % len(interfaces))
+    for peer in peers:
+        if not peer in interfaces:
+            print("Connection failed:", peer)
+    for msg_id, i in enumerate(interfaces.values()):
+        i.queue_request(method, params, msg_id)
+    responses = wait_on_interfaces(interfaces)
+    for peer in interfaces:
+        if not peer in responses:
+            print(peer, "did not answer")
+    results = dict(zip(responses.keys(), [t[0][1].get('result') for t in responses.values()]))
+    print("%d answers"%len(results))
+    return results

electrum/scripts/watch_address.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+
+import sys
+import time
+from electrum import bitcoin
+from .. import SimpleConfig, Network
+from electrum.util import print_msg, json_encode
+
+try:
+    addr = sys.argv[1]
+except Exception:
+    print("usage: watch_address <bitcoin_address>")
+    sys.exit(1)
+
+sh = bitcoin.address_to_scripthash(addr)
+
+# start network
+c = SimpleConfig()
+network = Network(c)
+network.start()
+
+# wait until connected
+while network.is_connecting():
+    time.sleep(0.1)
+
+if not network.is_connected():
+    print_msg("daemon is not connected")
+    sys.exit(1)
+
+# 2. send the subscription
+callback = lambda response: print_msg(json_encode(response.get('result')))
+network.subscribe_to_address(addr, callback)
+
+# 3. wait for results
+while network.is_connected():
+    time.sleep(1)