QShortcut(QKeySequence("Ctrl+PgDown"), self, lambda: tabs.setCurrentIndex( (tabs.currentIndex() + 1 )%tabs.count() ))
self.connect(self, QtCore.SIGNAL('update_status'), self.update_status)
- self.connect(self, QtCore.SIGNAL('banner_signal'), lambda: self.console.showMessage(self.wallet.interface.banner) )
+ self.connect(self, QtCore.SIGNAL('banner_signal'), lambda: self.console.showMessage(self.network.banner) )
self.connect(self, QtCore.SIGNAL('transaction_signal'), lambda: self.notify_transactions() )
self.history_list.setFocus(True)
self.setWindowTitle( title )
self.update_wallet()
# set initial message
- self.console.showMessage(self.wallet.interface.banner)
+ self.console.showMessage(self.network.banner)
# Once GUI has been initialized check if we want to announce something since the callback has been called before the GUI was initialized
self.notify_transactions()
from PyQt4.QtGui import *
from PyQt4.QtCore import *
-from electrum.interface import DEFAULT_SERVERS, DEFAULT_PORTS
+from electrum import DEFAULT_SERVERS, DEFAULT_PORTS
from qt_util import *
status = _("Please choose a server.") + "\n" + _("Select 'Cancel' if you are offline.")
server = interface.server
- self.servers = interface.get_servers()
+ self.servers = network.get_servers()
vbox = QVBoxLayout()
from wallet import WalletSynchronizer, WalletStorage
from wallet_factory import WalletFactory as Wallet
from verifier import TxVerifier
-from network import Network
-from interface import Interface, pick_random_server, DEFAULT_SERVERS
+from network import Network, DEFAULT_SERVERS, DEFAULT_PORTS
+from interface import Interface
from simple_config import SimpleConfig
import bitcoin
import account
return new_bits, new_target
- def request_header(self, i, h):
+ def request_header(self, i, h, queue):
print_error("requesting header %d from %s"%(h, i.server))
- i.send([ ('blockchain.block.get_header',[h])], 'get_header')
+ i.send([ ('blockchain.block.get_header',[h])], lambda i,r: queue.put((i,r)))
- def retrieve_header(self, i):
+ def retrieve_header(self, i, queue):
while True:
try:
- r = i.get_response('get_header',timeout=1)
+ ir = queue.get(timeout=1)
except Queue.Empty:
print_error('timeout')
continue
+ if not ir:
+ continue
+
+ i, r = ir
+
if r.get('error'):
print_error('Verifier received an error:', r)
continue
header = final_header
chain = [ final_header ]
requested_header = False
-
+ queue = Queue.Queue()
+
while self.is_running():
if requested_header:
- header = self.retrieve_header(interface)
+ header = self.retrieve_header(interface, queue)
if not header: return
chain = [ header ] + chain
requested_header = False
height = header.get('block_height')
previous_header = self.read_header(height -1)
if not previous_header:
- self.request_header(interface, height - 1)
+ self.request_header(interface, height - 1, queue)
requested_header = True
continue
prev_hash = self.hash_header(previous_header)
if prev_hash != header.get('prev_block_hash'):
print_error("reorg")
- self.request_header(interface, height - 1)
+ self.request_header(interface, height - 1, queue)
requested_header = True
continue
def get_chunks(self, i, header, height):
requested_chunks = []
+ queue = Queue.Queue()
min_index = (self.local_height + 1)/2016
max_index = (height + 1)/2016
for n in range(min_index, max_index + 1):
print_error( "requesting chunk", n )
- i.send([ ('blockchain.block.get_chunk',[n])], 'get_header')
+ i.send([ ('blockchain.block.get_chunk',[n])], lambda i,r:queue.put(r))
requested_chunks.append(n)
break
while requested_chunks:
try:
- r = i.get_response('get_header',timeout=1)
+ r = queue.get(timeout=1)
except Queue.Empty:
continue
if not r: continue
continue
# 3. handle response
- method = r['method']
params = r['params']
result = r['result']
- if method == 'blockchain.block.get_chunk':
- index = params[0]
- self.verify_chunk(index, result)
- requested_chunks.remove(index)
+ index = params[0]
+ self.verify_chunk(index, result)
+ requested_chunks.remove(index)
DEFAULT_TIMEOUT = 5
-DEFAULT_PORTS = {'t':'50001', 's':'50002', 'h':'8081', 'g':'8082'}
-
-DEFAULT_SERVERS = {
- 'the9ull.homelinux.org': {'h': '8082', 't': '50001'},
- 'electrum.coinwallet.me': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'},
- 'electrum.dynaloop.net': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'},
- 'electrum.koh.ms': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'},
- 'electrum.novit.ro': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'},
- 'electrum.stepkrav.pw': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'},
- 'ecdsa.org': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'},
- 'electrum.mooo.com': {'h': '8081', 't': '50001'},
- 'electrum.bitcoins.sk': {'h': '8081', 's': '50002', 't': '50001', 'g': '8'},
- 'electrum.no-ip.org': {'h': '80', 's': '50002', 't': '50001', 'g': '443'},
- 'electrum.drollette.com': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'},
- 'btc.it-zone.org': {'h': '80', 's': '110', 't': '50001', 'g': '443'},
- 'electrum.yacoin.com': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'},
- 'electrum.be': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'}
-}
-
-
-
-def filter_protocol(servers, p):
- l = []
- for k, protocols in servers.items():
- if p in protocols:
- l.append( ':'.join([k, protocols[p], p]) )
- return l
-
-
-
proxy_modes = ['socks4', 'socks5', 'http']
return random.choice( filter_protocol(DEFAULT_SERVERS,'s') )
-
-
class Interface(threading.Thread):
-
def init_server(self, host, port, proxy=None, use_ssl=True):
self.host = host
self.port = port
#json
self.message_id = 0
self.unanswered_requests = {}
- #banner
- self.banner = ''
self.pending_transactions_for_notifications= []
- def parse_servers(self, result):
- """ parse servers list into dict format"""
-
- servers = {}
- for item in result:
- host = item[1]
- out = {}
- version = None
- pruning_level = '-'
- if len(item) > 2:
- for v in item[2]:
- if re.match("[stgh]\d*", v):
- protocol, port = v[0], v[1:]
- if port == '': port = DEFAULT_PORTS[protocol]
- out[protocol] = port
- elif re.match("v(.?)+", v):
- version = v[1:]
- elif re.match("p\d*", v):
- pruning_level = v[1:]
- if pruning_level == '': pruning_level = '0'
- try:
- is_recent = float(version)>=float(PROTOCOL_VERSION)
- except:
- is_recent = False
-
- if out and is_recent:
- out['pruning'] = pruning_level
- servers[host] = out
-
- return servers
-
-
def queue_json_response(self, c):
# uncomment to debug
print_error("received error:", c)
if msg_id is not None:
with self.lock:
- method, params, channel = self.unanswered_requests.pop(msg_id)
- response_queue = self.responses[channel]
- response_queue.put((self,{'method':method, 'params':params, 'error':error, 'id':msg_id}))
+ method, params, callback = self.unanswered_requests.pop(msg_id)
+ callback(self,{'method':method, 'params':params, 'error':error, 'id':msg_id})
return
if msg_id is not None:
with self.lock:
- method, params, channel = self.unanswered_requests.pop(msg_id)
+ method, params, callback = self.unanswered_requests.pop(msg_id)
result = c.get('result')
- if method == 'server.version':
- self.server_version = result
-
- elif method == 'server.banner':
- self.banner = result
- self.network.trigger_callback('banner')
-
- elif method == 'server.peers.subscribe':
- self.servers = self.parse_servers(result)
- self.network.trigger_callback('peers')
-
else:
- # notification: find the channel(s)
+ # notification
method = c.get('method')
params = c.get('params')
with self.lock:
for k,v in self.subscriptions.items():
if (method, params) in v:
- channel = k
+ callback = k
break
else:
print_error( "received unexpected notification", method, params)
print_error( self.subscriptions )
return
-
- response_queue = self.responses[channel]
- response_queue.put((self, {'method':method, 'params':params, 'result':result, 'id':msg_id}))
-
- def get_response(self, channel='default', block=True, timeout=10000000000):
- ir = self.responses[channel].get(block, timeout)
- if ir:
- return ir[1]
+ callback(self, {'method':method, 'params':params, 'result':result, 'id':msg_id})
- def register_channel(self, channel, queue=None):
- if queue is None:
- queue = Queue.Queue()
- with self.lock:
- self.responses[channel] = queue
- def poke(self, channel):
- self.responses[channel].put(None)
+ def on_version(self, i, result):
+ self.server_version = result
def init_http(self, host, port, proxy=None, use_ssl=True):
self.send([])
- def send_http(self, messages, channel='default'):
+ def send_http(self, messages, callback):
import urllib2, json, time, cookielib
print_error( "send_http", messages )
method, params = m
if type(params) != type([]): params = [params]
data.append( { 'method':method, 'id':self.message_id, 'params':params } )
- self.unanswered_requests[self.message_id] = method, params, channel
+ self.unanswered_requests[self.message_id] = method, params, callback
self.message_id += 1
if data:
if timeout:
# ping the server with server.version, as a real ping does not exist yet
- self.send([('server.version', [ELECTRUM_VERSION, PROTOCOL_VERSION])])
+ self.send([('server.version', [ELECTRUM_VERSION, PROTOCOL_VERSION])], self.on_version)
continue
out += msg
self.is_connected = False
- def send_tcp(self, messages, channel='default'):
+ def send_tcp(self, messages, callback):
"""return the ids of the requests that we sent"""
out = ''
ids = []
for m in messages:
method, params = m
request = json.dumps( { 'id':self.message_id, 'method':method, 'params':params } )
- self.unanswered_requests[self.message_id] = method, params, channel
+ self.unanswered_requests[self.message_id] = method, params, callback
ids.append(self.message_id)
# uncomment to debug
# print "-->", request
def __init__(self, config=None):
- self.server = random.choice(filter_protocol(DEFAULT_SERVERS, 's'))
+ #self.server = random.choice(filter_protocol(DEFAULT_SERVERS, 's'))
self.proxy = None
if config is None:
self.connect_event = threading.Event()
self.subscriptions = {}
- self.responses = {}
- self.responses['default'] = Queue.Queue()
-
self.lock = threading.Lock()
self.servers = {} # actual list from IRC
raise BaseException('Unknown protocol: %s'%protocol)
- def send(self, messages, channel='default'):
+ def send(self, messages, callback):
sub = []
for message in messages:
if sub:
with self.lock:
- if self.subscriptions.get(channel) is None:
- self.subscriptions[channel] = []
+ if self.subscriptions.get(callback) is None:
+ self.subscriptions[callback] = []
for message in sub:
- if message not in self.subscriptions[channel]:
- self.subscriptions[channel].append(message)
+ if message not in self.subscriptions[callback]:
+ self.subscriptions[callback].append(message)
if not self.is_connected:
return
if self.protocol in 'st':
with self.lock:
- out = self.send_tcp(messages, channel)
+ out = self.send_tcp(messages, callback)
else:
# do not use lock, http is synchronous
- out = self.send_http(messages, channel)
+ out = self.send_http(messages, callback)
return out
def set_server(self, server, proxy=None):
+ "todo: remove this"
# raise an error if the format isnt correct
a,b,c = server.split(':')
b = int(b)
self.is_connected = False # this exits the polling loop
self.trigger_callback('disconnecting') # for actively disconnecting
+
def stop(self):
if self.is_connected and self.protocol in 'st' and self.s:
self.s.shutdown(socket.SHUT_RDWR)
self.s.close()
- def get_servers(self):
- if not self.servers:
- return DEFAULT_SERVERS
- else:
- return self.servers
-
-
- def is_empty(self, channel):
- q = self.responses.get(channel)
- if q:
- return q.empty()
- else:
- return True
-
-
- def get_pending_requests(self, channel):
- result = []
- with self.lock:
- for k, v in self.unanswered_requests.items():
- a, b, c = v
- if c == channel: result.append(k)
- return result
-
- def is_up_to_date(self, channel):
- return self.is_empty(channel) and not self.get_pending_requests(channel)
+ def is_up_to_date(self):
+ return self.unanswered_requests == {}
def synchronous_get(self, requests, timeout=100000000):
# todo: use generators, unanswered_requests should be a list of arrays...
- ids = self.send(requests)
+ q = Queue.Queue()
+ ids = self.send(requests, lambda i,r: queue.put(r))
id2 = ids[:]
res = {}
while ids:
- r = self.responses['default'].get(True, timeout)
+ r = queue.get(True, timeout)
_id = r.get('id')
if _id in ids:
ids.remove(_id)
threading.Thread.start(self)
-
def run(self):
self.init_interface()
if self.is_connected:
- self.send([('server.version', [ELECTRUM_VERSION, PROTOCOL_VERSION])])
+ self.send([('server.version', [ELECTRUM_VERSION, PROTOCOL_VERSION])], self.on_version)
self.change_status()
self.run_tcp() if self.protocol in 'st' else self.run_http()
self.change_status()
+
def change_status(self):
#print "change status", self.server, self.is_connected
self.queue.put(self)
-
-
-
-
import interface
from blockchain import Blockchain
+DEFAULT_PORTS = {'t':'50001', 's':'50002', 'h':'8081', 'g':'8082'}
+
+DEFAULT_SERVERS = {
+ 'the9ull.homelinux.org': {'h': '8082', 't': '50001'},
+ 'electrum.coinwallet.me': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'},
+ 'electrum.dynaloop.net': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'},
+ 'electrum.koh.ms': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'},
+ 'electrum.novit.ro': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'},
+ 'electrum.stepkrav.pw': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'},
+ 'ecdsa.org': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'},
+ 'electrum.mooo.com': {'h': '8081', 't': '50001'},
+ 'electrum.bitcoins.sk': {'h': '8081', 's': '50002', 't': '50001', 'g': '8'},
+ 'electrum.no-ip.org': {'h': '80', 's': '50002', 't': '50001', 'g': '443'},
+ 'electrum.drollette.com': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'},
+ 'btc.it-zone.org': {'h': '80', 's': '110', 't': '50001', 'g': '443'},
+ 'electrum.yacoin.com': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'},
+ 'electrum.be': {'h': '8081', 's': '50002', 't': '50001', 'g': '8082'}
+}
+
+
+
+def filter_protocol(servers, p):
+ l = []
+ for k, protocols in servers.items():
+ if p in protocols:
+ l.append( ':'.join([k, protocols[p], p]) )
+ return l
+
+
class Network(threading.Thread):
self.interfaces = {}
self.queue = Queue.Queue()
self.default_server = self.config.get('server')
- self.servers_list = interface.filter_protocol(interface.DEFAULT_SERVERS,'s')
+ self.servers_list = filter_protocol(DEFAULT_SERVERS,'s')
self.callbacks = {}
+ #banner
+ self.banner = ''
def register_callback(self, event, callback):
return server
+ def get_servers(self):
+ if not self.servers:
+ return DEFAULT_SERVERS
+ else:
+ return self.servers
+
+
def start_interface(self, server):
if server in self.interfaces.keys():
return
i = interface.Interface({'server':server})
- i.network = self # fixme
self.interfaces[server] = i
i.start(self.queue)
i = self.queue.get()
if i.is_connected:
- i.register_channel('verifier', self.blockchain.queue)
- i.register_channel('get_header')
- i.send([ ('blockchain.headers.subscribe',[])], 'verifier')
-
+ i.send([ ('blockchain.headers.subscribe',[])], self.on_header)
if i == self.interface:
- i.send([('server.banner',[])])
- i.send([('server.peers.subscribe',[])])
+ i.send([('server.banner',[])], self.on_banner)
+ i.send([('server.peers.subscribe',[])], self.on_peers)
else:
self.servers_list.remove(i.server)
self.interfaces.pop(i.server)
else:
self.trigger_callback('disconnected')
+ def on_header(self, i, result):
+ self.blockchain.queue.put((i,result))
- def on_peers(self, result):
- # populate servers list here
- pass
+ def on_peers(self, i, r):
+ self.servers = self.parse_servers(r.get('result'))
+ self.trigger_callback('peers')
- def on_banner(self, result):
- pass
+ def on_banner(self, i, r):
+ self.banner = r.get('result')
+ self.trigger_callback('banner')
def stop(self):
with self.lock: self.running = False
with self.lock: return self.running
+ def parse_servers(self, result):
+ """ parse servers list into dict format"""
+ from version import PROTOCOL_VERSION
+ servers = {}
+ for item in result:
+ host = item[1]
+ out = {}
+ version = None
+ pruning_level = '-'
+ if len(item) > 2:
+ for v in item[2]:
+ if re.match("[stgh]\d*", v):
+ protocol, port = v[0], v[1:]
+ if port == '': port = DEFAULT_PORTS[protocol]
+ out[protocol] = port
+ elif re.match("v(.?)+", v):
+ version = v[1:]
+ elif re.match("p\d*", v):
+ pruning_level = v[1:]
+ if pruning_level == '': pruning_level = '0'
+ try:
+ is_recent = float(version)>=float(PROTOCOL_VERSION)
+ except:
+ is_recent = False
+
+ if out and is_recent:
+ out['pruning'] = pruning_level
+ servers[host] = out
+
+ return servers
+
+
def resend_subscriptions(self, subscriptions):
for channel, messages in subscriptions.items():
if messages:
if __name__ == "__main__":
import simple_config
- config = simple_config.SimpleConfig({'verbose':True})
+ config = simple_config.SimpleConfig({'verbose':True, 'server':'ecdsa.org:50002:s'})
network = Network(config)
network.start()
self.blockchain = network.blockchain
self.interface = network.interface
self.transactions = {} # requested verifications (with height sent by the requestor)
- self.interface.register_channel('txverifier')
+ #self.interface.register_channel('txverifier')
self.verified_tx = storage.get('verified_tx3',{}) # height, timestamp of verified transactions
self.merkle_roots = storage.get('merkle_roots',{}) # hashed by me
self.lock = threading.Lock()
self.running = False
+ self.queue = Queue.Queue()
def get_confirmations(self, tx):
if tx_hash not in self.verified_tx:
if self.merkle_roots.get(tx_hash) is None and tx_hash not in requested_merkle:
print_error('requesting merkle', tx_hash)
- self.interface.send([ ('blockchain.transaction.get_merkle',[tx_hash, tx_height]) ], 'txverifier')
+ self.interface.send([ ('blockchain.transaction.get_merkle',[tx_hash, tx_height]) ], lambda i,r: self.queue.put(r))
requested_merkle.append(tx_hash)
try:
- r = self.interface.get_response('txverifier',timeout=1)
+ r = self.queue.get(timeout=1)
except Queue.Empty:
continue
+
if not r: continue
if r.get('error'):
def set_up_to_date(self,b):
with self.lock: self.up_to_date = b
+
def is_up_to_date(self):
with self.lock: return self.up_to_date
+
def update(self):
self.up_to_date = False
- self.interface.poke('synchronizer')
- while not self.is_up_to_date(): time.sleep(0.1)
+ #self.interface.poke('synchronizer')
+ while not self.is_up_to_date():
+ time.sleep(0.1)
+
def import_key(self, sec, password):
# check password
if value >= self.gap_limit:
self.gap_limit = value
self.storage.put('gap_limit', self.gap_limit, True)
- self.interface.poke('synchronizer')
+ #self.interface.poke('synchronizer')
return True
elif value >= self.min_acceptable_gap():
def send_tx(self, tx):
# asynchronous
self.tx_event.clear()
- self.interface.send([('blockchain.transaction.broadcast', [str(tx)])], 'synchronizer')
+ self.interface.send([('blockchain.transaction.broadcast', [str(tx)])], self.on_broadcast)
return tx.hash()
+ def on_broadcast(self, i, result):
+ self.tx_result = result
+ self.tx_event.set()
+
def receive_tx(self,tx_hash):
out = self.tx_result
if out != tx_hash:
self.wallet = wallet
wallet.synchronizer = self
self.interface = self.wallet.interface
- self.interface.register_channel('synchronizer')
#self.wallet.network.register_callback('connected', lambda: self.wallet.set_up_to_date(False))
self.was_updated = True
self.running = False
self.lock = threading.Lock()
+ self.queue = Queue.Queue()
def stop(self):
with self.lock: self.running = False
- self.interface.poke('synchronizer')
def is_running(self):
with self.lock: return self.running
messages = []
for addr in addresses:
messages.append(('blockchain.address.subscribe', [addr]))
- self.interface.send( messages, 'synchronizer')
+ self.interface.send( messages, lambda i,r: self.queue.put(r))
def run(self):
# request missing transactions
for tx_hash, tx_height in missing_tx:
if (tx_hash, tx_height) not in requested_tx:
- self.interface.send([ ('blockchain.transaction.get',[tx_hash, tx_height]) ], 'synchronizer')
+ self.interface.send([ ('blockchain.transaction.get',[tx_hash, tx_height]) ], lambda i,r: self.queue.put(r))
requested_tx.append( (tx_hash, tx_height) )
missing_tx = []
# detect if situation has changed
- if not self.interface.is_up_to_date('synchronizer'):
- if self.wallet.is_up_to_date():
- self.wallet.set_up_to_date(False)
- self.was_updated = True
- else:
+ if self.interface.is_up_to_date() and self.queue.empty():
if not self.wallet.is_up_to_date():
self.wallet.set_up_to_date(True)
self.was_updated = True
+ else:
+ if self.wallet.is_up_to_date():
+ self.wallet.set_up_to_date(False)
+ self.was_updated = True
if self.was_updated:
- self.interface.network.trigger_callback('updated')
+ self.wallet.network.trigger_callback('updated')
self.was_updated = False
# 2. get a response
- r = self.interface.get_response('synchronizer')
+ r = self.queue.get(block=True, timeout=10000000000)
# poke sends None. (needed during stop)
if not r: continue
addr = params[0]
if self.wallet.get_status(self.wallet.get_history(addr)) != result:
if requested_histories.get(addr) is None:
- self.interface.send([('blockchain.address.get_history', [addr])], 'synchronizer')
+ self.interface.send([('blockchain.address.get_history', [addr])], lambda i,r:self.queue.put(r))
requested_histories[addr] = result
elif method == 'blockchain.address.get_history':
requested_tx.remove( (tx_hash, tx_height) )
print_error("received tx:", tx_hash, len(tx.raw))
- elif method == 'blockchain.transaction.broadcast':
- self.wallet.tx_result = result
- self.wallet.tx_event.set()
-
else:
print_error("Error: Unknown message:" + method + ", " + repr(params) + ", " + repr(result) )
if self.was_updated and not requested_tx:
- self.interface.network.trigger_callback('updated')
- self.interface.network.trigger_callback("new_transaction") # Updated gets called too many times from other places as well; if we use that signal we get the notification three times
+ self.wallet.network.trigger_callback('updated')
+ self.wallet.network.trigger_callback("new_transaction") # Updated gets called too many times from other places as well; if we use that signal we get the notification three times
self.was_updated = False
git://git.novaco.in / electrum-nvc.git / commitdiff