def getHashShieldedSpends(tx): digest = blake2b(digest_size=32, person=b'ZcashSSpendsHash') for desc in tx.shieldedSpends: # We don't pass in serialized form of desc as spendAuthSig is not part of the hash digest.update(ser_uint256(desc.cv)) digest.update(ser_uint256(desc.anchor)) digest.update(ser_uint256(desc.nullifier)) digest.update(ser_uint256(desc.rk)) digest.update(desc.proof) return digest.digest()
def SignatureHashForkId(script, txTo, inIdx, hashtype, amount): hashPrevouts = 0 hashSequence = 0 hashOutputs = 0 if not (hashtype & SIGHASH_ANYONECANPAY): serialize_prevouts = bytes() for i in txTo.vin: serialize_prevouts += i.prevout.serialize() hashPrevouts = uint256_from_str(hash256(serialize_prevouts)) if (not (hashtype & SIGHASH_ANYONECANPAY) and (hashtype & 0x1f) != SIGHASH_SINGLE and (hashtype & 0x1f) != SIGHASH_NONE): serialize_sequence = bytes() for i in txTo.vin: serialize_sequence += struct.pack("<I", i.nSequence) hashSequence = uint256_from_str(hash256(serialize_sequence)) if ((hashtype & 0x1f) != SIGHASH_SINGLE and (hashtype & 0x1f) != SIGHASH_NONE): serialize_outputs = bytes() for o in txTo.vout: serialize_outputs += o.serialize() hashOutputs = uint256_from_str(hash256(serialize_outputs)) elif ((hashtype & 0x1f) == SIGHASH_SINGLE and inIdx < len(txTo.vout)): serialize_outputs = txTo.vout[inIdx].serialize() hashOutputs = uint256_from_str(hash256(serialize_outputs)) ss = bytes() ss += struct.pack("<i", txTo.nVersion) ss += ser_uint256(hashPrevouts) ss += ser_uint256(hashSequence) ss += txTo.vin[inIdx].prevout.serialize() ss += ser_string(script) ss += struct.pack("<q", amount) ss += struct.pack("<I", txTo.vin[inIdx].nSequence) ss += ser_uint256(hashOutputs) ss += struct.pack("<i", txTo.nLockTime) ss += struct.pack("<I", hashtype) return hash256(ss)
def test_compactblock_reconstruction_multiple_peers( self, node, stalling_peer, delivery_peer): assert (len(self.utxos)) def announce_cmpct_block(node_data, peer): utxo = self.utxos.pop(0) block_data = self.build_block_with_transactions(node_data, utxo, 5) cmpct_block_data = HeaderAndShortIDs() cmpct_block_data.initialize_from_block(block_data) msg_data = MsgCmpctBlock(cmpct_block_data.to_p2p()) peer.send_and_ping(msg_data) with mininode_lock: assert "getblocktxn" in peer.last_message return block_data, cmpct_block_data block, cmpct_block = announce_cmpct_block(node, stalling_peer) for tx in block.vtx[1:]: delivery_peer.send_message(MsgTx(tx)) delivery_peer.sync_with_ping() mempool = node.getrawmempool() for tx in block.vtx[1:]: assert (tx.hash in mempool) delivery_peer.send_and_ping(MsgCmpctBlock(cmpct_block.to_p2p())) assert_equal(int(node.getbestblockhash(), 16), block.sha256) self.utxos.append( [block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue]) # Now test that delivering an invalid compact block won't break relay block, cmpct_block = announce_cmpct_block(node, stalling_peer) for tx in block.vtx[1:]: delivery_peer.send_message(MsgTx(tx)) delivery_peer.sync_with_ping() cmpct_block.prefilled_txn[0].tx.wit.vtxinwit = [CTxInWitness()] cmpct_block.prefilled_txn[0].tx.wit.vtxinwit[0].scriptWitness.stack = [ ser_uint256(0) ] cmpct_block.use_witness = True delivery_peer.send_and_ping(MsgCmpctBlock(cmpct_block.to_p2p())) assert (int(node.getbestblockhash(), 16) != block.sha256) msg = MsgBlockTxn() msg.block_transactions.blockhash = block.sha256 msg.block_transactions.transactions = block.vtx[1:] stalling_peer.send_and_ping(msg) assert_equal(int(node.getbestblockhash(), 16), block.sha256)
coinbase.vin[0].scriptSig = hex_str_to_bytes(script_sig) previous_blockhash = '000000000758eb8a22332a2c32c671e0489d56262bf659774421f37d58f6550c' coinbase.rehash() block = create_block(int(previous_blockhash, 16), coinbase) block.hashMerkleRoot = block.calc_merkle_root() block.rehash() # Get the difficulty on the BStash chain hex_bits = aux['bits'] nBits = struct.unpack(">I", hex_str_to_bytes(hex_bits))[0] target = uint256_from_compact(nBits) # Construct BCash block block_ser = b"" block_ser += struct.pack("<i", block.nVersion) block_ser += ser_uint256(block.hashPrevBlock) block_ser += ser_uint256(block.hashMerkleRoot) block_ser += struct.pack("<I", block.nTime) block_ser += struct.pack("<I", block.nBits) block_ser_final = block_ser + struct.pack("<I", block.nNonce) hash_result = uint256_from_str(hash256(block_ser_final)) print("Starting mining, difficulty:{}".format(hex_bits)) i = 0 start_time = time.time() maxnonce = 2**32 block.nNonce = 0 nNonce = 0 while hash_result > target: nNonce += 1 if nNonce >= maxnonce: