class WalletVerifier(threading.Thread):
+ """ Simple Payment Verification """
- def __init__(self, wallet, config):
+ def __init__(self, interface, config):
threading.Thread.__init__(self)
self.daemon = True
self.config = config
- self.wallet = wallet
- self.interface = self.wallet.interface
+ self.interface = interface
+ self.transactions = [] # monitored transactions
self.interface.register_channel('verifier')
- self.verified_tx = config.get('verified_tx',[])
+ self.verified_tx = config.get('verified_tx',{})
self.merkle_roots = config.get('merkle_roots',{}) # hashed by me
self.targets = config.get('targets',{}) # compute targets
self.lock = threading.Lock()
+ self.pending_headers = [] # headers that have not been verified
+ self.height = 0
+ self.local_height = 0
+ self.set_local_height()
- #self.config.set_key('verified_tx', [], True)
- #for i in range(70): self.get_target(i)
- #sys.exit()
+ def get_confirmations(self, tx):
+ """ return the number of confirmations of a monitored transaction. """
+ with self.lock:
+ assert tx in self.transactions
+ return (self.local_height - self.verified_tx[tx] + 1) if tx in self.verified_tx else 0
-
+ def add(self, tx):
+ """ add a transaction to the list of monitored transactions. """
+ with self.lock:
+ if tx not in self.transactions:
+ self.transactions.append(tx)
def run(self):
requested_merkle = []
requested_chunks = []
+ requested_headers = []
+ all_chunks = False
+
+ # subscribe to block headers
+ self.interface.send([ ('blockchain.headers.subscribe',[])], 'verifier')
while True:
# request missing chunks
- max_index = self.wallet.blocks/2016
- if not requested_chunks:
+ max_index = (self.height+1)/2016
+ if not all_chunks and self.height and not requested_chunks:
for i in range(0, max_index + 1):
# test if we can read the first header of the chunk
if self.read_header(i*2016): continue
- print "requesting chunk", i
+ # print "requesting chunk", i
self.interface.send([ ('blockchain.block.get_chunk',[i])], 'verifier')
requested_chunks.append(i)
break
-
- # todo: request missing blocks too
+ else:
+ all_chunks = True
+ print "all chunks"
# request missing tx merkle
- txlist = self.wallet.get_tx_hashes()
- for tx in txlist:
+ for tx in self.transactions:
if tx not in self.verified_tx:
if tx not in requested_merkle:
requested_merkle.append(tx)
self.request_merkle(tx)
+ #break
+
+
+ # process pending headers
+ if self.pending_headers and all_chunks:
+ done = []
+ for header in self.pending_headers:
+ if self.verify_header(header):
+ done.append(header)
+ else:
+ # request previous header
+ i = header.get('block_height') - 1
+ if i not in requested_headers:
+ print "requesting header", i
+ self.interface.send([ ('blockchain.block.get_header',[i])], 'verifier')
+ requested_headers.append(i)
+ # no point continuing
break
+ for header in done: self.pending_headers.remove(header)
+ self.interface.trigger_callback('updated')
try:
r = self.interface.get_response('verifier',timeout=1)
self.verify_chunk(index, result)
requested_chunks.remove(index)
- elif method == 'blockchain.block.get_header':
- self.verify_header(result)
+ elif method in ['blockchain.headers.subscribe', 'blockchain.block.get_header']:
+
+ self.pending_headers.append(result)
+ if method == 'blockchain.block.get_header':
+ requested_headers.remove(result.get('block_height'))
+ else:
+ self.height = result.get('block_height')
+
+ self.pending_headers.sort(key=lambda x: x.get('block_height'))
+ # print "pending headers", map(lambda x: x.get('block_height'), self.pending_headers)
+
+
+
+ self.interface.trigger_callback('updated')
def request_merkle(self, tx_hash):
def verify_merkle(self, tx_hash, result):
tx_height = result.get('block_height')
- self.merkle_roots[tx_hash] = self.hash_merkle_root(result['merkle'], tx_hash)
+ self.merkle_roots[tx_hash] = self.hash_merkle_root(result['merkle'], tx_hash, result.get('pos'))
header = self.read_header(tx_height)
if header:
assert header.get('merkle_root') == self.merkle_roots[tx_hash]
- self.verified_tx.append(tx_hash)
+ self.verified_tx[tx_hash] = tx_height
print "verified", tx_hash
self.config.set_key('verified_tx', self.verified_tx, True)
def verify_chunk(self, index, hexdata):
data = hexdata.decode('hex')
height = index*2016
- numblocks = len(data)/80
- print "validate_chunk", index, numblocks
+ num = len(data)/80
+ print "validating headers", height, num
if index == 0:
previous_hash = ("0"*64)
bits, target = self.get_target(index)
- for i in range(numblocks):
+ for i in range(num):
height = index*2016 + i
raw_header = data[i*80:(i+1)*80]
header = self.header_from_string(raw_header)
_hash = self.hash_header(header)
assert previous_hash == header.get('prev_block_hash')
- try:
- assert bits == header.get('bits')
- except:
- print index, hex(bits), hex(header.get('bits'))
-
- try:
- assert eval('0x'+_hash) < target
- except:
- print _hash, hex(target)
+ assert bits == header.get('bits')
+ assert eval('0x'+_hash) < target
previous_header = header
previous_hash = _hash
self.save_chunk(index, data)
- def validate_header(self, header):
- """ if there is a previous or a next block in the list, check the hash"""
+ def verify_header(self, header):
+ # add header to the blockchain file
+ # if there is a reorg, push it in a stack
+
height = header.get('block_height')
- with self.lock:
- self.headers[height] = header # detect conflicts
- prev_header = next_header = None
- if height-1 in self.headers:
- prev_header = self.headers[height-1]
- if height+1 in self.headers:
- next_header = self.headers[height+1]
-
- if prev_header:
- prev_hash = self.hash_header(prev_header)
+
+ prev_header = self.read_header(height -1)
+ if not prev_header:
+ print "no previous header", height
+ return False
+
+ #prev_hash = prev_header.get('block_height')
+ prev_hash = self.hash_header(prev_header)
+ bits, target = self.get_target(height/2016)
+ _hash = self.hash_header(header)
+ try:
assert prev_hash == header.get('prev_block_hash')
- self.save_header(header)
- if next_header:
- _hash = self.hash_header(header)
- assert _hash == next_header.get('prev_block_hash')
+ assert bits == header.get('bits')
+ assert eval('0x'+_hash) < target
+ except:
+ print "verify header failed", header
+ # this can be caused by a reorg. returning False will request the previous header.
+ return False
+
+ self.save_header(header)
+ print "verify header: ok", height
+ return True
+
+
def header_to_string(self, res):
h['nonce'] = hex_to_int(s[76:80])
return h
-
def hash_header(self, header):
return rev_hex(Hash(self.header_to_string(header).decode('hex')).encode('hex'))
-
- def hash_merkle_root(self, merkle_s, target_hash):
+ def hash_merkle_root(self, merkle_s, target_hash, pos):
h = hash_decode(target_hash)
- for item in merkle_s:
- is_left = item[0] == 'L'
- h = Hash( h + hash_decode(item[1:]) ) if is_left else Hash( hash_decode(item[1:]) + h )
+ for i in range(len(merkle_s)):
+ item = merkle_s[i]
+ h = Hash( hash_decode(item) + h ) if ((pos >> i) & 1) else Hash( h + hash_decode(item) )
return hash_encode(h)
+ def path(self):
+ wdir = user_dir()
+ if not os.path.exists( wdir ):
+ wdir = os.path.dirname(self.config.path)
+ return os.path.join( wdir, 'blockchain_headers')
def save_chunk(self, index, chunk):
- name = os.path.join( user_dir(), 'blockchain_headers')
- if os.path.exists(name):
- f = open(name,'rw+')
+ filename = self.path()
+ if os.path.exists(filename):
+ f = open(filename,'rw+')
else:
- f = open(name,'w+')
-
+ print "creating file", filename
+ f = open(filename,'w+')
f.seek(index*2016*80)
h = f.write(chunk)
f.close()
+ self.set_local_height()
+
+ def save_header(self, header):
+ # todo: invalidate tx verifications if we rewind
+ data = self.header_to_string(header).decode('hex')
+ assert len(data) == 80
+ height = header.get('block_height')
+ filename = self.path()
+ f = open(filename,'rw+')
+ f.seek(height*80)
+ h = f.write(data)
+ f.close()
+ self.set_local_height()
+
+
+ def set_local_height(self):
+ name = self.path()
+ if os.path.exists(name):
+ h = os.path.getsize(name)/80 - 1
+ if self.local_height != h:
+ self.local_height = h
def read_header(self, block_height):
- name = os.path.join( user_dir(), 'blockchain_headers')
+ name = self.path()
if os.path.exists(name):
f = open(name,'rb')
f.seek(block_height*80)
git://git.novaco.in / electrum-nvc.git / blobdiff