1 from __future__ import division
7 from p2pool.util import math
8 from p2pool.bitcoin import data as bitcoin_data
10 class CompressedList(bitcoin_data.Type):
11 def __init__(self, inner):
15 values, file = bitcoin_data.ListType(self.inner).read(file)
16 if values != sorted(set(values)):
17 raise ValueError("invalid values")
18 references, file = bitcoin_data.ListType(bitcoin_data.VarIntType()).read(file)
19 return [values[reference] for reference in references], file
21 def write(self, file, item):
22 values = sorted(set(item))
23 values_map = dict((value, i) for i, value in enumerate(values))
24 file = bitcoin_data.ListType(self.inner).write(file, values)
25 return bitcoin_data.ListType(bitcoin_data.VarIntType()).write(file, [values_map[subitem] for subitem in item])
28 merkle_branch_type = bitcoin_data.ListType(bitcoin_data.ComposedType([
29 ('side', bitcoin_data.StructType('<B')), # enum?
30 ('hash', bitcoin_data.HashType()),
34 share_data_type = bitcoin_data.ComposedType([
35 ('previous_share_hash', bitcoin_data.PossiblyNone(0, bitcoin_data.HashType())),
36 ('previous_shares_hash', bitcoin_data.HashType()),
37 ('target2', bitcoin_data.FloatingIntegerType()),
38 ('nonce', bitcoin_data.VarStrType()),
42 coinbase_type = bitcoin_data.ComposedType([
43 ('identifier', bitcoin_data.FixedStrType(8)),
44 ('share_data', share_data_type),
47 share_info_type = bitcoin_data.ComposedType([
48 ('share_data', share_data_type),
49 ('new_script', bitcoin_data.VarStrType()),
50 ('subsidy', bitcoin_data.StructType('<Q')),
54 share1a_type = bitcoin_data.ComposedType([
55 ('header', bitcoin_data.block_header_type), # merkle_header not completely needed
56 ('share_info', share_info_type),
57 ('merkle_branch', merkle_branch_type),
60 share1b_type = bitcoin_data.ComposedType([
61 ('header', bitcoin_data.block_header_type),
62 ('share_info', share_info_type),
63 ('other_txs', bitcoin_data.ListType(bitcoin_data.tx_type)),
66 shares_type = CompressedList(bitcoin_data.VarStrType())
68 def calculate_merkle_branch(txs, index):
69 hash_list = [(bitcoin_data.tx_type.hash256(tx), i == index, []) for i, tx in enumerate(txs)]
71 while len(hash_list) > 1:
74 bitcoin_data.merkle_record_type.hash256(dict(left=left, right=right)),
76 (left_l if left_f else right_l) + [dict(side=1, hash=right) if left_f else dict(side=0, hash=left)],
78 for (left, left_f, left_l), (right, right_f, right_l) in
79 zip(hash_list[::2], hash_list[1::2] + [hash_list[::2][-1]])
82 assert hash_list[0][1]
83 assert check_merkle_branch(txs[index], hash_list[0][2]) == hash_list[0][0]
85 return hash_list[0][2]
87 def check_merkle_branch(tx, branch):
88 hash_ = bitcoin_data.tx_type.hash256(tx)
91 hash_ = bitcoin_data.merkle_record_type.hash256(dict(left=step['hash'], right=hash_))
93 hash_ = bitcoin_data.merkle_record_type.hash256(dict(left=hash_, right=step['hash']))
96 def gentx_to_share_info(gentx):
98 share_data=coinbase_type.unpack(gentx['tx_ins'][0]['script'])['share_data'],
99 subsidy=sum(tx_out['value'] for tx_out in gentx['tx_outs']),
100 new_script=gentx['tx_outs'][-1]['script'],
103 def share_info_to_gentx(share_info, block_target, tracker, net):
104 return generate_transaction(
106 previous_share_hash=share_info['share_data']['previous_share_hash'],
107 new_script=share_info['new_script'],
108 subsidy=share_info['subsidy'],
109 nonce=share_info['share_data']['nonce'],
110 block_target=block_target,
118 def from_block(cls, block):
119 return cls(block['header'], gentx_to_share_info(block['txs'][0]), other_txs=block['txs'][1:])
122 def from_share1a(cls, share1a):
123 return cls(**share1a)
126 def from_share1b(cls, share1b):
127 return cls(**share1b)
129 def __init__(self, header, share_info, merkle_branch=None, other_txs=None):
130 if merkle_branch is None and other_txs is None:
131 raise ValueError('need either merkle_branch or other_txs')
132 if other_txs is not None:
133 new_merkle_branch = calculate_merkle_branch([dict(version=0, tx_ins=[], tx_outs=[], lock_time=0)] + other_txs, 0)
134 if merkle_branch is not None:
135 if merke_branch != new_merkle_branch:
136 raise ValueError('invalid merkle_branch and other_txs')
137 merkle_branch = new_merkle_branch
140 self.share_info = share_info
141 self.merkle_branch = merkle_branch
142 self.other_txs = other_txs
144 self.timestamp = self.header['timestamp']
146 self.share_data = self.share_info['share_data']
147 self.new_script = self.share_info['new_script']
148 self.subsidy = self.share_info['subsidy']
150 self.previous_hash = self.previous_share_hash = self.share_data['previous_share_hash']
151 self.previous_shares_hash = self.share_data['previous_shares_hash']
152 self.target2 = self.share_data['target2']
154 self.hash = bitcoin_data.block_header_type.hash256(header)
156 if self.hash > self.target2:
157 print "hash", hex(self.hash)
158 print "targ", hex(self.target2)
159 raise ValueError('not enough work!')
166 raise ValueError('share does not contain all txs')
168 return dict(header=self.header, txs=self.txs)
170 def as_share1a(self):
171 return dict(header=self.header, share_info=self.share_info, merkle_branch=self.merkle_branch)
173 def as_share1b(self):
174 return dict(header=self.header, share_info=self.share_info, other_txs=self.other_txs)
176 def check(self, tracker, net):
178 if self.previous_share_hash is not None:
179 if self.header['timestamp'] <= math.median((s.timestamp for s in itertools.islice(tracker.get_chain_to_root(self.previous_share_hash), 11)), use_float=False):
180 raise ValueError('share from too far in the past!')
182 if self.header['timestamp'] > time.time() + 2*60*60:
183 raise ValueError('share from too far in the future!')
185 gentx = share_info_to_gentx(self.share_info, self.header['target'], tracker, net)
187 if self.merkle_branch is not None:
188 if check_merkle_branch(gentx, self.merkle_branch) != self.header['merkle_root']:
189 raise ValueError("gentx doesn't match header via merkle_branch")
191 if self.other_txs is not None:
192 if bitcoin_data.merkle_hash([gentx] + self.other_txs) != self.header['merkle_root']:
193 raise ValueError("gentx doesn't match header via other_txs")
197 def flag_shared(self):
201 return '<Share %s>' % (' '.join('%s=%r' % (k, v) for k, v in self.__dict__.iteritems()),)
203 class Share2(object):
204 '''Share with associated data'''
206 def __init__(self, share):
211 def flag_shared(self):
214 def generate_transaction(tracker, previous_share_hash, new_script, subsidy, nonce, block_target, net):
215 previous_share2 = tracker.shares[previous_share_hash] if previous_share_hash is not None else None
216 #previous_share2 = chain.shares
219 #shares = (previous_share2.shares if previous_share2 is not None else [net.SCRIPT]*net.SPREAD)[1:-1] + [new_script, new_script]
222 chain = list(itertools.islice(tracker.get_chain_to_root(previous_share_hash), lookbehind))
223 if len(chain) < lookbehind:
224 target2 = bitcoin_data.FloatingIntegerType().truncate_to(2**256//2**16 - 1)
226 attempts = sum(bitcoin_data.target_to_average_attempts(share.target2) for share in chain[:-1])
227 time = chain[0].timestamp - chain[-1].timestamp
230 attempts_per_second = attempts//time
231 pre_target = 2**256//(net.SHARE_PERIOD*attempts_per_second) - 1
232 pre_target2 = math.clip(pre_target, (previous_share2.target2*9//10, previous_share2.target2*11//10))
233 pre_target3 = math.clip(pre_target2, (0, 2**256//2**16 - 1))
234 target2 = bitcoin_data.FloatingIntegerType().truncate_to(pre_target3)
235 print attempts_per_second//1000, "KHASH"
236 #print "TARGET", 2**256//target2, 2**256/pre_target
237 #print "ATT", bitcoin_data.target_to_average_attempts(target2)//1000
240 attempts_to_block = bitcoin_data.target_to_average_attempts(block_target)
241 max_weight = net.SPREAD * attempts_to_block
244 class fake_share(object):
246 share = dict(target=target2)
249 for i, share in enumerate(itertools.chain([fake_share], itertools.islice(tracker.get_chain_to_root(previous_share_hash), net.CHAIN_LENGTH))):
250 weight = bitcoin_data.target_to_average_attempts(share.share['target'])
251 weight = max(weight, max_weight - total_weight)
253 dest_weights[share.script] = dest_weights.get(share.script, 0) + weight
254 total_weight += weight
256 if total_weight == max_weight:
259 amounts = dict((script, subsidy*(199*weight)//(200*total_weight)) for (script, weight) in dest_weights.iteritems())
260 amounts[net.SCRIPT] = amounts.get(net.SCRIPT, 0) + subsidy*1//200
261 amounts[net.SCRIPT] = amounts.get(net.SCRIPT, 0) + subsidy - sum(amounts.itervalues()) # collect any extra
263 dests = sorted(amounts.iterkeys(), key=lambda script: (script == new_script, script))
264 assert dests[-1] == new_script
266 previous_shares = [] # XXX
271 previous_output=None,
273 script=coinbase_type.pack(dict(
274 identifier=net.IDENTIFIER,
276 previous_share_hash=previous_share_hash,
277 previous_shares_hash=shares_type.hash256(previous_shares),
283 tx_outs=[dict(value=amounts[script], script=script) for script in dests if amounts[script]],
290 if __name__ == '__main__':
291 class FakeShare(object):
292 def __init__(self, hash, previous_share_hash):
294 self.previous_share_hash = previous_share_hash
298 t.add_share(FakeShare(1, 2))
299 print t.heads, t.tails
300 t.add_share(FakeShare(4, 0))
301 print t.heads, t.tails
302 t.add_share(FakeShare(3, 4))
303 print t.heads, t.tails
304 t.add_share(FakeShare(5, 0))
305 print t.heads, t.tails
306 t.add_share(FakeShare(0, 1))
307 print t.heads, t.tails
309 for share_hash in t.shares:
310 print share_hash, t.get_height_and_last(share_hash)
312 class OkayTracker(bitcoin_data.Tracker):
313 def __init__(self, net):
314 bitcoin_data.Tracker.__init__(self)
316 self.verified = bitcoin_data.Tracker()
318 self.okay_cache = {} # hash -> height
320 def is_okay(self, start, _height_after=0):
323 {'result': 'okay', verified_height: ...} # if share has an okay parent or if share has CHAIN_LENGTH children and CHAIN_LENTH parents that it verified with
324 {'result': 'needs_share', 'share_hash': ...} # if share doesn't have CHAIN_LENGTH parents
325 #{'result': 'needs_share_shares', 'share_hash': ...} # if share has CHAIN_LENGTH children and needs its shares to
326 {'result': 'not_okay'} # if the share has a not okay parent or if the share has an okay parent and failed validation
329 if start in self.okay_cache:
330 return dict(result='okay', verified_height=self.okay_cache['start'])
332 share = self.shares[start]
333 if start not in self.shares:
334 return dict(result='needs_share', share_hash=start)
338 for share in itertools.islice(self.get_chain(start), self.net.CHAIN_LENGTH):
339 if share in self.okay_cache:
340 return validate(share, to_end_rev[::-1])
341 to_end_rev.append(share)
342 # picking up last share from for loop, ew
343 self.okay_cache.add(share)
344 return validate(share, to_end_rev[::-1])
346 def attempt_verify(self, share):
347 if share.hash in self.verified.shares:
350 share.check(self, self.net)
353 print "Share check failed:"
354 traceback.print_exc()
358 self.verified.add(share)
363 # for each overall head, attempt verification
364 # if it fails, attempt on parent, and repeat
365 # if no successful verification because of lack of parents, request parent
366 for head in self.heads:
367 head_height, last = self.get_height_and_last(head)
368 if head_height < self.net.CHAIN_LENGTH and last is not None:
371 desired.add((self.shares[random.choice(list(self.reverse_shares[last]))].peer, last))
374 for share in itertools.islice(self.get_chain_known(head), None if last is None else head_height - self.net.CHAIN_LENGTH):
375 if self.attempt_verify(share):
378 # try to get at least CHAIN_LENGTH height for each verified head, requesting parents if needed
379 for head in self.verified.heads:
380 head_height, last = self.verified.get_height_and_last(head)
381 last_height, last_last = self.get_height_and_last(last)
382 for share in itertools.islice(self.get_chain_known(last), max(0, min(self.net.CHAIN_LENGTH - head_height, last_height - 1 - self.net.CHAIN_LENGTH))):
383 if not self.attempt_verify(share):
385 if head_height < self.net.CHAIN_LENGTH and last_last is not None:
386 desired.add((self.verified.shares[random.choice(list(self.verified.reverse_shares[last]))].peer, last_last))
388 # decide best verified head
389 def score(share_hash):
390 share = self.verified.shares[share_hash]
391 head_height, last = self.verified.get_height_and_last(share)
393 return (min(head_height, self.net.CHAIN_LENGTH), RECENTNESS)
394 best = max(self.verified.heads, key=score) if self.verified.heads else None
399 class Mainnet(bitcoin_data.Mainnet):
400 SHARE_PERIOD = 5 # seconds
401 CHAIN_LENGTH = 24*60*60//5 # shares
403 SCRIPT = '4104ffd03de44a6e11b9917f3a29f9443283d9871c9d743ef30d5eddcd37094b64d1b3d8090496b53256786bf5c82932ec23c3b74d9f05a6f95a8b5529352656664bac'.decode('hex')
404 IDENTIFIER = '7452839666e1f8f8'.decode('hex')
405 PREFIX = '2d4224bf18c87b87'.decode('hex')
406 ADDRS_TABLE = 'addrs'
409 class Testnet(bitcoin_data.Testnet):
410 SHARE_PERIOD = 5 # seconds
411 CHAIN_LENGTH = 24*60*60//5 # shares
413 SCRIPT = '410403ad3dee8ab3d8a9ce5dd2abfbe7364ccd9413df1d279bf1a207849310465b0956e5904b1155ecd17574778f9949589ebfd4fb33ce837c241474a225cf08d85dac'.decode('hex')
414 IDENTIFIER = '1ae3479e4eb6700a'.decode('hex')
415 PREFIX = 'd19778c812754854'.decode('hex')
416 ADDRS_TABLE = 'addrs_testnet'