示例#1
0
    def __init__(self, net, peer_addr, contents, skip_momentum=False):
        self.net = net
        self.peer_addr = peer_addr
        self.contents = contents
        
        self.min_header = contents['min_header']
        self.share_info = contents['share_info']
        self.hash_link = contents['hash_link']
        self.merkle_link = contents['merkle_link']
        
        if not (2 <= len(self.share_info['share_data']['coinbase']) <= 100):
            raise ValueError('''bad coinbase size! %i bytes''' % (len(self.share_info['share_data']['coinbase']),))
        
        if len(self.merkle_link['branch']) > 16:
            raise ValueError('merkle branch too long!')
        
        assert not self.hash_link['extra_data'], repr(self.hash_link['extra_data'])
        
        self.share_data = self.share_info['share_data']
        self.max_target = self.share_info['max_bits'].target
        self.target = self.share_info['bits'].target
        self.timestamp = self.share_info['timestamp']
        self.previous_hash = self.share_data['previous_share_hash']
        self.new_script = bitcoin_data.pubkey_hash_to_script2(self.share_data['pubkey_hash'])
        self.desired_version = self.share_data['desired_version']
        self.absheight = self.share_info['absheight']
        self.abswork = self.share_info['abswork']
        
        n = set()
        for share_count, tx_count in self.iter_transaction_hash_refs():
            assert share_count < 110
            if share_count == 0:
                n.add(tx_count)
        assert n == set(range(len(self.share_info['new_transaction_hashes'])))
        
        self.gentx_hash = check_hash_link(
            self.hash_link,
            self.get_ref_hash(net, self.share_info, contents['ref_merkle_link']) + pack.IntType(64).pack(self.contents['last_txout_nonce']) + pack.IntType(32).pack(0),
            self.gentx_before_refhash,
        )
        merkle_root = bitcoin_data.check_merkle_link(self.gentx_hash, self.merkle_link)
        self.header = dict(self.min_header, merkle_root=merkle_root)
        self.pow_hash = net.PARENT.POW_FUNC(bitcoin_data.block_header_type.pack(self.header))
        self.hash = self.header_hash = bitcoin_data.hash256(bitcoin_data.block_header_type.pack(self.header))
        
        midhash = hashlib.sha256(hashlib.sha256(bitcoin_data.block_header_type.pack(self.header)[:80]).digest()).digest()
		
        #print 'MIDHASH: {0}'.format(midhash.encode('hex'))
        #print 'A: {0}'.format(self.header['birthdayA'])
        #print 'B: {0}'.format(self.header['birthdayB'])
        
        if self.target > net.MAX_TARGET:
            from p2pool import p2p
            raise p2p.PeerMisbehavingError('share target invalid')
        
        if self.pow_hash > self.target:
            from p2pool import p2p
            raise p2p.PeerMisbehavingError('share PoW invalid')
        if not skip_momentum:
            if memorycoin_momentum.checkMomentum(midhash, self.header['birthdayA'], self.header['birthdayB']) == False:
                from p2pool import p2p
                raise p2p.PeerMisbehavingError('share momentum invalid')
        
        self.new_transaction_hashes = self.share_info['new_transaction_hashes']
        
        # XXX eww
        self.time_seen = time.time()
示例#2
0
 def got_response(header, user, coinbase_nonce):
     assert len(coinbase_nonce) == self.COINBASE_NONCE_LENGTH
     new_packed_gentx = packed_gentx[:-self.COINBASE_NONCE_LENGTH-4] + coinbase_nonce + packed_gentx[-4:] if coinbase_nonce != '\0'*self.COINBASE_NONCE_LENGTH else packed_gentx
     new_gentx = bitcoin_data.tx_type.unpack(new_packed_gentx) if coinbase_nonce != '\0'*self.COINBASE_NONCE_LENGTH else gentx
     
     header_hash = bitcoin_data.hash256(bitcoin_data.block_header_type.pack(header))
     pow_hash = self.node.net.PARENT.POW_FUNC(bitcoin_data.block_header_type.pack(header))
     try:
         if pow_hash <= header['bits'].target or p2pool.DEBUG:
             helper.submit_block(dict(header=header, txs=[new_gentx] + other_transactions), False, self.node.factory, self.node.bitcoind, self.node.bitcoind_work, self.node.net)
             if pow_hash <= header['bits'].target:
                 print
                 print 'GOT BLOCK FROM MINER! Passing to bitcoind! %s%064x' % (self.node.net.PARENT.BLOCK_EXPLORER_URL_PREFIX, header_hash)
                 print
     except:
         log.err(None, 'Error while processing potential block:')
     
     user, _, _, _ = self.get_user_details(user)
     assert header['previous_block'] == ba['previous_block']
     assert header['merkle_root'] == bitcoin_data.check_merkle_link(bitcoin_data.hash256(new_packed_gentx), merkle_link)
     assert header['bits'] == ba['bits']
     # Check momentum using midhash (who knows why it is called that) and birthday values
     midhash = hashlib.sha256(hashlib.sha256(bitcoin_data.block_header_type.pack(header)[:80]).digest()).digest()
     #print 'MIDHASH: {0}'.format(midhash.encode('hex'))
     #print 'A: {0}'.format(header['birthdayA'])
     #print 'B: {0}'.format(header['birthdayB'])
     momentumc = memorycoin_momentum.checkMomentum(midhash, header['birthdayA'], header['birthdayB'])
     #print momentumc
     if momentumc == False:
         print 'Invalid Momentum from Client!'
         return False
     
     on_time = self.new_work_event.times == lp_count
     
     for aux_work, index, hashes in mm_later:
         try:
             if pow_hash <= aux_work['target'] or p2pool.DEBUG:
                 df = deferral.retry('Error submitting merged block: (will retry)', 10, 10)(aux_work['merged_proxy'].rpc_getauxblock)(
                     pack.IntType(256, 'big').pack(aux_work['hash']).encode('hex'),
                     bitcoin_data.aux_pow_type.pack(dict(
                         merkle_tx=dict(
                             tx=new_gentx,
                             block_hash=header_hash,
                             merkle_link=merkle_link,
                         ),
                         merkle_link=bitcoin_data.calculate_merkle_link(hashes, index),
                         parent_block_header=header,
                     )).encode('hex'),
                 )
                 @df.addCallback
                 def _(result, aux_work=aux_work):
                     if result != (pow_hash <= aux_work['target']):
                         print >>sys.stderr, 'Merged block submittal result: %s Expected: %s' % (result, pow_hash <= aux_work['target'])
                     else:
                         print 'Merged block submittal result: %s' % (result,)
                 @df.addErrback
                 def _(err):
                     log.err(err, 'Error submitting merged block:')
         except:
             log.err(None, 'Error while processing merged mining POW:')
     
     if pow_hash <= share_info['bits'].target and header_hash not in received_header_hashes:
         last_txout_nonce = pack.IntType(8*self.COINBASE_NONCE_LENGTH).unpack(coinbase_nonce)
         share = get_share(header, last_txout_nonce)
         
         print 'GOT SHARE! %s %s prev %s age %.2fs%s' % (
             user,
             p2pool_data.format_hash(share.hash),
             p2pool_data.format_hash(share.previous_hash),
             time.time() - getwork_time,
             ' DEAD ON ARRIVAL' if not on_time else '',
         )
         self.my_share_hashes.add(share.hash)
         if not on_time:
             self.my_doa_share_hashes.add(share.hash)
         
         self.node.tracker.add(share)
         self.node.set_best_share()
         
         try:
             if (pow_hash <= header['bits'].target or p2pool.DEBUG) and self.node.p2p_node is not None:
                 self.node.p2p_node.broadcast_share(share.hash)
         except:
             log.err(None, 'Error forwarding block solution:')
         
         self.share_received.happened(bitcoin_data.target_to_average_attempts(share.target), not on_time, share.hash)
     
     if pow_hash > target:
         print 'Worker %s submitted share with hash > target:' % (user,)
         print '    Hash:   %56x' % (pow_hash,)
         print '    Target: %56x' % (target,)
     elif header_hash in received_header_hashes:
         print >>sys.stderr, 'Worker %s submitted share more than once!' % (user,)
     else:
         received_header_hashes.add(header_hash)
         
         self.pseudoshare_received.happened(bitcoin_data.target_to_average_attempts(target), not on_time, user)
         self.recent_shares_ts_work.append((time.time(), bitcoin_data.target_to_average_attempts(target)))
         while len(self.recent_shares_ts_work) > 50:
             self.recent_shares_ts_work.pop(0)
         self.local_rate_monitor.add_datum(dict(work=bitcoin_data.target_to_average_attempts(target), dead=not on_time, user=user, share_target=share_info['bits'].target))
         self.local_addr_rate_monitor.add_datum(dict(work=bitcoin_data.target_to_average_attempts(target), pubkey_hash=pubkey_hash))
     
     return on_time