3 # Electrum - lightweight Bitcoin client
4 # Copyright (C) 2012 thomasv@ecdsa.org
6 # This program is free software: you can redistribute it and/or modify
7 # it under the terms of the GNU General Public License as published by
8 # the Free Software Foundation, either version 3 of the License, or
9 # (at your option) any later version.
11 # This program is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 # GNU General Public License for more details.
16 # You should have received a copy of the GNU General Public License
17 # along with this program. If not, see <http://www.gnu.org/licenses/>.
20 import threading, time, Queue, os, sys
21 from util import user_dir
27 class WalletVerifier(threading.Thread):
29 def __init__(self, wallet, config):
30 threading.Thread.__init__(self)
34 self.interface = self.wallet.interface
35 self.interface.register_channel('verifier')
36 self.verified_tx = config.get('verified_tx',[])
37 self.merkle_roots = config.get('merkle_roots',{}) # hashed by me
38 self.targets = config.get('targets',{}) # compute targets
39 self.lock = threading.Lock()
41 #self.config.set_key('verified_tx', [], True)
42 #for i in range(70): self.get_target(i)
52 # request missing chunks
53 max_index = self.wallet.blocks/2016
54 if not requested_chunks:
55 for i in range(0, max_index + 1):
56 # test if we can read the first header of the chunk
57 if self.read_header(i*2016): continue
58 print "requesting chunk", i
59 self.interface.send([ ('blockchain.block.get_chunk',[i])], 'verifier')
60 requested_chunks.append(i)
63 # todo: request missing blocks too
65 # request missing tx merkle
66 txlist = self.wallet.get_tx_hashes()
68 if tx not in self.verified_tx:
69 if tx not in requested_merkle:
70 requested_merkle.append(tx)
71 self.request_merkle(tx)
75 r = self.interface.get_response('verifier',timeout=1)
85 if method == 'blockchain.transaction.get_merkle':
87 self.verify_merkle(tx_hash, result)
88 requested_merkle.remove(tx_hash)
90 elif method == 'blockchain.block.get_chunk':
92 self.verify_chunk(index, result)
93 requested_chunks.remove(index)
95 elif method == 'blockchain.block.get_header':
96 self.verify_header(result)
99 def request_merkle(self, tx_hash):
100 self.interface.send([ ('blockchain.transaction.get_merkle',[tx_hash]) ], 'verifier')
103 def verify_merkle(self, tx_hash, result):
104 tx_height = result.get('block_height')
105 self.merkle_roots[tx_hash] = self.hash_merkle_root(result['merkle'], tx_hash)
106 header = self.read_header(tx_height)
108 assert header.get('merkle_root') == self.merkle_roots[tx_hash]
109 self.verified_tx.append(tx_hash)
110 print "verified", tx_hash
111 self.config.set_key('verified_tx', self.verified_tx, True)
114 def verify_chunk(self, index, hexdata):
115 data = hexdata.decode('hex')
117 numblocks = len(data)/80
118 print "validate_chunk", index, numblocks
121 previous_hash = ("0"*64)
123 prev_header = self.read_header(index*2016-1)
124 if prev_header is None: raise
125 previous_hash = self.hash_header(prev_header)
127 bits, target = self.get_target(index)
129 for i in range(numblocks):
130 height = index*2016 + i
131 raw_header = data[i*80:(i+1)*80]
132 header = self.header_from_string(raw_header)
133 _hash = self.hash_header(header)
134 assert previous_hash == header.get('prev_block_hash')
135 assert bits == header.get('bits')
136 assert eval('0x'+_hash) < target
138 previous_header = header
139 previous_hash = _hash
141 self.save_chunk(index, data)
144 def validate_header(self, header):
145 """ if there is a previous or a next block in the list, check the hash"""
146 height = header.get('block_height')
148 self.headers[height] = header # detect conflicts
149 prev_header = next_header = None
150 if height-1 in self.headers:
151 prev_header = self.headers[height-1]
152 if height+1 in self.headers:
153 next_header = self.headers[height+1]
156 prev_hash = self.hash_header(prev_header)
157 assert prev_hash == header.get('prev_block_hash')
158 self.save_header(header)
160 _hash = self.hash_header(header)
161 assert _hash == next_header.get('prev_block_hash')
164 def header_to_string(self, res):
165 s = int_to_hex(res.get('version'),4) \
166 + rev_hex(res.get('prev_block_hash')) \
167 + rev_hex(res.get('merkle_root')) \
168 + int_to_hex(int(res.get('timestamp')),4) \
169 + int_to_hex(int(res.get('bits')),4) \
170 + int_to_hex(int(res.get('nonce')),4)
174 def header_from_string(self, s):
175 hex_to_int = lambda s: eval('0x' + s[::-1].encode('hex'))
177 h['version'] = hex_to_int(s[0:4])
178 h['prev_block_hash'] = hash_encode(s[4:36])
179 h['merkle_root'] = hash_encode(s[36:68])
180 h['timestamp'] = hex_to_int(s[68:72])
181 h['bits'] = hex_to_int(s[72:76])
182 h['nonce'] = hex_to_int(s[76:80])
186 def hash_header(self, header):
187 return rev_hex(Hash(self.header_to_string(header).decode('hex')).encode('hex'))
190 def hash_merkle_root(self, merkle_s, target_hash):
191 h = hash_decode(target_hash)
192 for item in merkle_s:
193 is_left = item[0] == 'L'
194 h = Hash( h + hash_decode(item[1:]) ) if is_left else Hash( hash_decode(item[1:]) + h )
195 return hash_encode(h)
200 if not os.path.exists( wdir ):
201 wdir = os.path.dirname(self.config.path)
202 return os.path.join( wdir, 'blockchain_headers')
205 def save_chunk(self, index, chunk):
206 filename = self.path()
207 if os.path.exists(filename):
208 f = open(filename,'rw+')
210 print "creating file", filename
211 f = open(filename,'w+')
212 f.seek(index*2016*80)
217 def read_header(self, block_height):
219 if os.path.exists(name):
221 f.seek(block_height*80)
225 h = self.header_from_string(h)
229 def get_target(self, index):
231 max_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
232 if index == 0: return 0x1d00ffff, max_target
234 first = self.read_header((index-1)*2016)
235 last = self.read_header(index*2016-1)
237 nActualTimespan = last.get('timestamp') - first.get('timestamp')
238 nTargetTimespan = 14*24*60*60
239 nActualTimespan = max(nActualTimespan, nTargetTimespan/4)
240 nActualTimespan = min(nActualTimespan, nTargetTimespan*4)
242 bits = last.get('bits')
248 target = (a) * pow(2, 8 * (bits/MM - 3))
251 new_target = min( max_target, (target * nActualTimespan)/nTargetTimespan )
254 c = ("%064X"%new_target)[2:]
260 c = eval('0x'+c[0:6])
265 new_bits = c + MM * i
266 # print "%3d"%index, "%8x"%bits, "%64X"%new_target, hex(c)[2:].upper(), hex(new_bits)
267 return new_bits, new_target