def _prepare(self):
self.access = jsonrpc.ServiceProxy(self.UpstreamURI)
self.currentBlock = (None, None, None)
self.currentMerkleTree = None
self.merkleRoots = deque(maxlen=self.WorkQueueSizeRegular[1])
self.LowestMerkleRoots = self.WorkQueueSizeRegular[1]
if not hasattr(self, 'WorkQueueSizeClear'):
self.WorkQueueSizeClear = self.WorkQueueSizeLongpoll
self._MaxClearSize = max(self.WorkQueueSizeClear[1],
self.WorkQueueSizeLongpoll[1])
self.clearMerkleTree = MerkleTree([self.clearCoinbaseTxn])
self.clearMerkleRoots = Queue(self._MaxClearSize)
self.LowestClearMerkleRoots = self.WorkQueueSizeClear[1]
self.nextMerkleRoots = Queue(self._MaxClearSize)
if not hasattr(self, 'WarningDelay'):
self.WarningDelay = max(15, self.MinimumTxnUpdateWait * 2)
if not hasattr(self, 'WarningDelayTxnLongpoll'):
self.WarningDelayTxnLongpoll = self.WarningDelay
if not hasattr(self, 'WarningDelayMerkleUpdate'):
self.WarningDelayMerkleUpdate = self.WarningDelay
self.lastMerkleUpdate = 0
self.nextMerkleUpdate = 0
global now
now = time()
self.updateMerkleTree()
def merkle_test():
m = MerkleChain()
b1 = [
"Hey!", "Hi!", "How are ya?", "Not bad!", "Cool!", "School good?",
"Yes!", "Aight Imma head out"
]
b2 = [
"My life is a lie", "The void grows bigger.", "I smell pennies",
"Hmmm yes", "Enslaved water?", "Yes indeed", "Big yums", "Lovely"
]
b3 = [
"Oof", "No", "Ah yes", "Ahhh no", "Big oofs", "No oofs here", "Stop",
"go"
]
blocks = [b1, b2, b3]
for i in range(0, len(blocks)):
## cons nonce
prev_hash = m.get_latest_block_hash()
root = MerkleTree(blocks[i]).get_merkle_root()
nonce = generate_hash(prev_hash, root, 3)
## add entry
m.insert(blocks[i], nonce)
assert m.latest_block_idx == i + 1
print(m.get_latest_block_hash())
## run some test cases against blocks
assert m.verify("Hey!", 1, 0)
assert not m.verify("Ah yes", 3, 1)
assert m.verify("Ah yes", 3, 2)
assert m.verify("The void grows bigger.", 2, 1)
assert m.verify("Aight Imma head out", 1, 7)
assert not m.verify("Oofie", 3, 0)
def validate(self):
boolean = True
for i in range(1, len(self.transactions)):
transaction = self.transactions[i]
boolean = transaction.validate()
if not boolean:
return boolean
return self.header['tree_root'] == MerkleTree(self.transactions).get_root()
def createClearMerkleTree(self, height):
subsidy = self.SubsidyAlgo(height)
cbtxn = self.makeCoinbaseTxn(subsidy, False)
cbtxn.assemble()
MT = MerkleTree([cbtxn])
if self.currentMerkleTree:
self.UpdateClearMerkleTree(MT, self.currentMerkleTree.MP)
return MT
def build_tree(self):
mt = MerkleTree(self.txnlist)
buildtree = mt.build()
merkleroot = mt.get_root()
self.merkle_root = merkleroot
return merkleroot
def test2():
m = MerkleTree(data[0:2])
merkle_hashes = m.get_hashes()
assert merkle_hashes[0][0] == sha256(hashes[0] + hashes[1]).digest()
assert merkle_hashes[1][0] == hashes[0]
assert merkle_hashes[1][1] == hashes[1]
for h in merkle_hashes[2]:
assert h == None
def do_test_pathless_unbound(self, hashtype):
"""
Test basic characteristics of very simple MerkleTrees created
using a specific SHA hash type.
"""
(dir_name1, dir_name2) = self.get_two_unique_directory_names()
check_hashtype(hashtype)
tree1 = MerkleTree(dir_name1, hashtype)
self.assertEqual(dir_name1, tree1.name)
if hashtype == HashTypes.SHA1:
self.assertEqual(SHA1_HEX_NONE, tree1.hex_hash)
elif hashtype == HashTypes.SHA2:
self.assertEqual(SHA2_HEX_NONE, tree1.hex_hash)
elif hashtype == HashTypes.SHA3:
self.assertEqual(SHA3_HEX_NONE, tree1.hex_hash)
elif hashtype == HashTypes.BLAKE2B_256:
self.assertEqual(BLAKE2B_256_HEX_NONE, tree1.hex_hash)
else:
raise NotImplementedError
tree2 = MerkleTree(dir_name2, hashtype)
self.assertEqual(dir_name2, tree2.name)
# these tests remain skimpy
self.assertFalse(tree1 is None)
self.assertTrue(tree1 == tree1)
self.assertFalse(tree1 == tree2)
tree1_str = tree1.to_string(0)
# there should be no indent on the first line
self.assertFalse(tree1_str[0] == ' ')
# no extra lines should be added
lines = tree1_str.split('\n')
# this split generates an extra blank line, because the serialization
# ends with CR-LF
if lines[-1] == '':
lines = lines[:-1]
self.assertEqual(1, len(lines))
tree1_rebuilt = MerkleTree.create_from_serialization(
tree1_str, hashtype)
self.assertTrue(tree1 == tree1_rebuilt)
def append_chain():
conn = sqlite3.connect("message.db")
c = conn.cursor()
res = c.execute("SELECT merkle_idx FROM messages " +
"WHERE blk_index = -1 ORDER BY merkle_idx DESC")
msgs = [r[i] for r in res]
root = MerkleTree(msgs).get_merkle_root()
prev_hash = MerkleChainClientHandler.chain.get_latest_block_hash()
nonce = generate_hash(prev_hash, root, 3)
return MerkleChainClientHandler.chain.insert(msgs, nonce)
def createClearMerkleTree(self, height): subsidy = self.SubsidyAlgo(height) cbtxn = self.makeCoinbaseTxn(subsidy, False, witness_commitment=None) cbtxn.setCoinbase(b'\0\0') # necessary to avoid triggering segwit marker+flags cbtxn.assemble() MT = MerkleTree([cbtxn]) if self.currentMerkleTree: self.UpdateClearMerkleTree(MT, self.currentMerkleTree.MP) MT.witness_commitment = None return MT
def test3():
m = MerkleTree(data[0:3])
merkle_hashes = m.get_hashes()
assert merkle_hashes[0][0] == hash_abc
assert merkle_hashes[1][0] == hash_ab
assert merkle_hashes[1][1] == hashes[2]
assert merkle_hashes[2][0] == hashes[0]
assert merkle_hashes[2][1] == hashes[1]
assert merkle_hashes[2][2] == None
assert merkle_hashes[2][3] == None
def __init__(self, transactions=None, prev_header=None, header=None):
self.transactions = transactions
if header is None:
self.header = {
'prev_header': prev_header,
'tree_root': MerkleTree(transactions).get_root(),
'timestamp': int(time.time()),
'nonce': uuid.uuid4().hex
}
else:
self.header = header
def CalculateWitnessCommitment(txnobjs, nonce, force=False): gentx_withash = nonce withashes = (gentx_withash,) + tuple(a.get_witness_hash() for a in txnobjs[1:]) if not force: txids = (gentx_withash,) + tuple(a.txid for a in txnobjs[1:]) if withashes == txids: # Unnecessary return None wmr = MerkleTree(data=withashes).merkleRoot() commitment = util.dblsha(wmr + nonce) return commitment
def get_merklepath(self, txn):
# Get Tree information from minernode
proof = None
for block in self.blockchain.blockchain:
if txn in block[0].txnlist:
merkletree = MerkleTree(block[0].txnlist)
merkletree.build()
arrayTree = merkletree.tree
# Get merkle path
proof = merkletree.get_proof(txn)
return proof
def test4():
m = MerkleTree(data[0:4])
merkle_hashes = m.get_hashes()
assert merkle_hashes[0][0] == hash_abcd
assert merkle_hashes[1][0] == hash_ab
assert merkle_hashes[1][1] == hash_cd
assert merkle_hashes[2][0] == hashes[0]
assert merkle_hashes[2][1] == hashes[1]
assert merkle_hashes[2][2] == hashes[2]
assert merkle_hashes[2][3] == hashes[3]
for n in merkle_hashes[3]:
assert n == None
def _ProcessGBT(self, MP, TS=None):
oMP = MP
MP = deepcopy(MP)
prevBlock = bytes.fromhex(MP['previousblockhash'])[::-1]
if 'height' not in MP:
MP['height'] = TS['access'].getinfo()['blocks'] + 1
height = MP['height']
bits = bytes.fromhex(MP['bits'])[::-1]
(MP['_bits'], MP['_prevBlock']) = (bits, prevBlock)
if (prevBlock, height, bits) != self.currentBlock and (
self.currentBlock[1] is None or height > self.currentBlock[1]):
self.updateBlock(prevBlock,
height,
bits,
_HBH=(MP['previousblockhash'], MP['bits']))
txnlist = MP['transactions']
if len(txnlist) and isinstance(txnlist[0], dict):
txninfo = txnlist
txnlist = tuple(a['data'] for a in txnlist)
elif 'transactionfees' in MP:
# Backward compatibility with pre-BIP22 gmp_fees branch
txninfo = [{'fee': a} for a in MP['transactionfees']]
else:
# Backward compatibility with pre-BIP22 hex-only (bitcoind <0.7, Eloipool <future)
txninfo = [{}] * len(txnlist)
# TODO: cache Txn or at least txid from previous merkle roots?
txnlist = [a for a in map(bytes.fromhex, txnlist)]
self._makeBlockSafe(MP, txnlist, txninfo)
cbtxn = self.makeCoinbaseTxn(MP['coinbasevalue'],
prevBlockHex=MP['previousblockhash'])
cbtxn.setCoinbase(b'\0\0')
cbtxn.assemble()
txnlist.insert(0, cbtxn.data)
txninfo.insert(0, {})
txnlist = [a for a in map(Txn, txnlist[1:])]
txnlist.insert(0, cbtxn)
txnlist = list(txnlist)
newMerkleTree = MerkleTree(txnlist)
newMerkleTree.POTInfo = MP.get('POTInfo')
newMerkleTree.MP = MP
newMerkleTree.oMP = oMP
return newMerkleTree
def test5():
m = MerkleTree(data[0:5])
merkle_hashes = m.get_hashes()
assert merkle_hashes[0][0] == hash_abcde
assert merkle_hashes[1][0] == hash_abcd
assert merkle_hashes[1][1] == hashes[4]
assert merkle_hashes[2][0] == hash_ab
assert merkle_hashes[2][1] == hash_cd
assert merkle_hashes[2][2] == None
assert merkle_hashes[2][3] == None
assert merkle_hashes[3][0] == hashes[0]
assert merkle_hashes[3][1] == hashes[1]
assert merkle_hashes[3][2] == hashes[2]
assert merkle_hashes[3][3] == hashes[3]
def createClearMerkleTree(self, height): subsidy = self.SubsidyAlgo(height) blockInfo = (None, None) if hasattr(self, 'Rootstock') and self.Rootstock is not None: blockInfo = self.Rootstock.getBlockInfo() cbtxn = self.makeCoinbaseTxn(subsidy, False, witness_commitment=None) cbtxn.setCoinbase(b'\0\0') # necessary to avoid triggering segwit marker+flags cbtxn.assemble() MT = MerkleTree([cbtxn]) self.merkleTreeLock.acquire() if self.currentMerkleTree: self.UpdateClearMerkleTree(MT, self.currentMerkleTree.MP) self.merkleTreeLock.release() MT.witness_commitment = None if blockInfo[0] is not None: MT.rootstockBlockInfo = blockInfo return MT
def createClearMerkleTree(self, height, bits):
basenBits = 0x1E00FFFF
nShift = ((basenBits >> 24) & 0xff) - ((bits >> 24) & 0xff)
dDiff = float(basenBits & 0x007fffff) / float(bits & 0x007fffff)
while (nShift > 0):
dDiff *= 256.0
nShift -= 1
while (nShift < 0):
dDiff /= 256.0
nShift += 1
nSubsidy1 = int(sqrt(dDiff * height))
subsidy = nSubsidy1 + 2500000000
cbtxn = self.makeCoinbaseTxn(subsidy, False)
cbtxn.assemble()
return MerkleTree([cbtxn])
def test6():
m = MerkleTree(data[0:6])
merkle_hashes = m.get_hashes()
assert merkle_hashes[0][0] == hash_abcdef
assert merkle_hashes[1][0] == hash_abcd
assert merkle_hashes[1][1] == hash_ef
assert merkle_hashes[2][0] == hash_ab
assert merkle_hashes[2][1] == hash_cd
assert merkle_hashes[2][2] == hashes[4]
assert merkle_hashes[2][3] == hashes[5]
assert merkle_hashes[3][0] == hashes[0]
assert merkle_hashes[3][1] == hashes[1]
assert merkle_hashes[3][2] == hashes[2]
assert merkle_hashes[3][3] == hashes[3]
assert merkle_hashes[3][4] == None
assert merkle_hashes[3][5] == None
assert merkle_hashes[3][6] == None
assert merkle_hashes[3][7] == None
def get_header_from_templete(t, cb_tx, nonce):
version = t['version']
previous_block_hash = hex_to_bin(t['previousblockhash'])
cb_hash = double_sha256_digest(cb_tx) #[::-1]
# cb_hash = hex_to_bin(t['coinbasetxn']['hash'])[::-1]
hashes = [
cb_hash,
] + txs_hashes(get_txs_from_template(t))
hash_merkle_root = MerkleTree(hashes).tree_digest()
time = t['curtime']
bits = t['bits']
return ''.join((
struct.pack("<i", version),
previous_block_hash[::-1],
hash_merkle_root,
'\x00' * 32,
struct.pack("<I", time),
hex_to_bin(bits)[::-1],
nonce,
))
def update_auxs(self):
# create merkle leaves with arbitrary initial value
merkle_leaves = [('0' * 62) + ("%02x" % x)
for x in range(self.merkle_size)]
# ask each aux chain for a block
for chain in range(len(self.auxs)):
aux_block = (yield self.auxs[chain].rpc_getauxblock())
aux_block_hash = aux_block['hash']
self.chain_ids[chain] = aux_block['chainid']
chain_merkle_index = self.calc_merkle_index(chain)
merkle_leaves[chain_merkle_index] = aux_block_hash
self.aux_targets[chain] = reverse_chunks(aux_block['target'],
2) # fix endian
# create merkle tree
if len(merkle_leaves) > 1:
merkle_tree = map(
lambda s: b2a_hex(s[::-1]),
MerkleTree(map(lambda s: a2b_hex(s)[::-1], merkle_leaves),
detailed=True).detail)
else:
merkle_tree = merkle_leaves
merkle_root = merkle_tree[-1]
if not self.merkle_trees.has_key(merkle_root):
# Tell bitcoind the new merkle root
MMAux = merkle_root + ("%02x000000" %
self.merkle_size) + "00000000"
MMAux = 'fabe6d6d' + MMAux
for p in self.parent:
p.rpc_setworkaux('MM', MMAux)
# remember new tree
self.merkle_trees[merkle_root] = merkle_tree
self.merkle_tree_queue.append(merkle_root)
if len(self.merkle_tree_queue) > MERKLE_TREES_TO_KEEP:
# forget one tree
old_root = self.merkle_tree_queue.pop(0)
del self.merkle_trees[old_root]
def __init__(self, messages, prev_hash, nonce):
self.tree = MerkleTree(messages)
self.prev_hash = prev_hash
self.nonce = nonce
self.nxt = None
def updateMerkleTree(self):
global now
self.logger.debug('Polling bitcoind for memorypool')
self.nextMerkleUpdate = now + self.TxnUpdateRetryWait
try:
# First, try BIP 22 standard getblocktemplate :)
MP = self.access.getblocktemplate(self.GBTReq)
self.OldGMP = False
except:
try:
# Failing that, give BIP 22 draft (2012-02 through 2012-07) getmemorypool a chance
MP = self.access.getmemorypool(self.GMPReq)
except:
try:
# Finally, fall back to bitcoind 0.5/0.6 getmemorypool
MP = self.access.getmemorypool()
except:
MP = False
if MP is False:
# This way, we get the error from the BIP22 call if the old one fails too
raise
# Pre-BIP22 server (bitcoind <0.7 or Eloipool <20120513)
if not self.OldGMP:
self.OldGMP = True
self.logger.warning('Upstream server is not BIP 22 compatible')
oMP = deepcopy(MP)
prevBlock = bytes.fromhex(MP['previousblockhash'])[::-1]
if 'height' in MP:
height = MP['height']
else:
height = self.access.getinfo()['blocks'] + 1
bits = bytes.fromhex(MP['bits'])[::-1]
if (prevBlock, height, bits) != self.currentBlock:
self.updateBlock(prevBlock,
height,
bits,
_HBH=(MP['previousblockhash'], MP['bits']))
txnlist = MP['transactions']
if len(txnlist) and isinstance(txnlist[0], dict):
txninfo = txnlist
txnlist = tuple(a['data'] for a in txnlist)
txninfo.insert(0, {})
elif 'transactionfees' in MP:
# Backward compatibility with pre-BIP22 gmp_fees branch
txninfo = [{'fee': a} for a in MP['transactionfees']]
else:
# Backward compatibility with pre-BIP22 hex-only (bitcoind <0.7, Eloipool <future)
txninfo = [{}] * len(txnlist)
# TODO: cache Txn or at least txid from previous merkle roots?
txnlist = [a for a in map(bytes.fromhex, txnlist)]
self._makeBlockSafe(MP, txnlist, txninfo)
cbtxn = self.makeCoinbaseTxn(MP['coinbasevalue'])
cbtxn.setCoinbase(b'\0\0')
cbtxn.assemble()
txnlist.insert(0, cbtxn.data)
txnlist = [a for a in map(Txn, txnlist[1:])]
txnlist.insert(0, cbtxn)
txnlist = list(txnlist)
newMerkleTree = MerkleTree(txnlist)
if newMerkleTree.merkleRoot() != self.currentMerkleTree.merkleRoot():
newMerkleTree.POTInfo = MP.get('POTInfo')
newMerkleTree.oMP = oMP
if (not self.OldGMP) and 'proposal' in MP.get('capabilities', ()):
(prevBlock, height, bits) = self.currentBlock
coinbase = self.makeCoinbase(height=height)
cbtxn.setCoinbase(coinbase)
cbtxn.assemble()
merkleRoot = newMerkleTree.merkleRoot()
MRD = (merkleRoot, newMerkleTree, coinbase, prevBlock, bits)
blkhdr = MakeBlockHeader(MRD)
data = assembleBlock(blkhdr, txnlist)
propose = self.access.getblocktemplate({
"mode":
"proposal",
"data":
b2a_hex(data).decode('utf8'),
})
if propose is None:
self.logger.debug(
'Updating merkle tree (upstream accepted proposal)')
self.currentMerkleTree = newMerkleTree
else:
self.RejectedProposal = (newMerkleTree, propose)
try:
propose = propose['reject-reason']
except:
pass
self.logger.error('Upstream rejected proposed block: %s' %
(propose, ))
else:
self.logger.debug('Updating merkle tree (no proposal support)')
self.currentMerkleTree = newMerkleTree
self.lastMerkleUpdate = now
self.nextMerkleUpdate = now + self.MinimumTxnUpdateWait
if self.needMerkle == 2:
self.needMerkle = 1
self.needMerkleSince = now
def createClearMerkleTree(self, height):
subsidy = SubsidyAlgo(height)
cbtxn = self.makeCoinbaseTxn(subsidy, False)
cbtxn.assemble()
return MerkleTree([cbtxn])
def merkle_root(self):
return MerkleTree(self.tx_list)
def createClearMerkleTree(self, height):
subsidy = self.access.getblocktemplate()['coinbasevalue']
cbtxn = self.makeCoinbaseTxn(subsidy, False)
cbtxn.assemble()
return MerkleTree([cbtxn])
def get_transaction_proof(self, transaction):
for block in self.blockchains[self.true_blockchain]:
if transaction in block.transactions:
mt = MerkleTree(block.transactions)
return (mt.get_proof(transaction), mt.get_root())
def mine_block(self, q0, q1, q2):
while True:
TARGET = "0000" + "f" * 60
# Get the last block
last_blk = self.blockchain.last_blk
while not q0.empty():
print("---------------there is a new block-------------")
blk = q0.get()
print("new block {}\n".format(blk.to_json))
self.blockchain.add(blk)
if blk.header[
'hash_of_previous_header'] == self.blockchain.last_blk.generate_header_hash(
):
self.blockchain.last_blk = blk
else:
if len(self.blockchain.get_longest_chain(blk)) > len(
self.blockchain.get_longest_chain(
self.blockchain.last_blk)):
self.blockchain.last_blk = blk
while not q1.empty():
# validate and add txn to the pool
trans_json = q1.get()
#print(trans_json)
self.add_transaction(trans_json)
while not q2.empty():
# validate and add txn to the pool
msg = q2.get()
receiver, amt = list(msg.keys())[0], list(msg.values())[0]
self.create_transaction(receiver, int(amt), '')
if self.transaction_pool == []:
hash_of_previous_header = last_blk.generate_header_hash()
tx0 = self.create_tx_0()
root = MerkleTree([tx0.to_json()]).get_root()
timestamp = int(round(time.time() * 1000))
nonce = random.getrandbits(32)
mined_blk = Block(hash_of_previous_header, root, timestamp,
nonce, [tx0.to_json()])
header_hash = mined_blk.generate_header_hash()
while header_hash >= TARGET:
nonce = random.getrandbits(32)
mined_blk = Block(hash_of_previous_header, root, timestamp,
nonce, [tx0.to_json()])
header_hash = mined_blk.generate_header_hash()
else:
print("Pool is not empty! ")
hash_of_previous_header = last_blk.header[
'hash_of_previous_header']
timestamp = int(round(time.time() * 1000))
nonce = random.getrandbits(32)
temp_txn = copy.deepcopy(self.transaction_pool)
print("temp_txn:", temp_txn)
self.transaction_pool = list(
set(self.transaction_pool) - set(temp_txn))
root = MerkleTree(temp_txn).get_root()
mined_blk = Block(hash_of_previous_header, root, timestamp,
nonce, temp_txn)
header_hash = mined_blk.generate_header_hash()
while header_hash >= TARGET:
nonce = random.getrandbits(32)
mined_blk = Block(hash_of_previous_header, root, timestamp,
nonce, temp_txn)
header_hash = mined_blk.generate_header_hash()
print("POW Done")
block_json = mined_blk.to_json()
# Add new block to the blockchain
try:
self.blockchain.add(mined_blk)
self.blockchain.last_blk = mined_blk
print("Successfully added block")
time.sleep(3)
except Exception as e:
print("BLK_ADD_FAIL: {}".format(repr(e)))
else:
# Block successfully added to blockchain
print("mined_blk:", mined_blk.to_json())
self.compute_balance(mined_blk)
print("Miner {0} balance: {1}".format(self.pubkey[:6],
self.balance))
self.broadcast_block(block_json)
def _ProcessGBT(self, MP, TS = None):
oMP = MP
MP = deepcopy(MP)
if MP['version'] & 0xe0000000 != 0x20000000:
self.logger.error('Template from \'%s\' has non-BIP9 block version (%x)' % (TS['name'], MP['version']))
return None
ISupportAllRules = True
for ruleflag in MP['rules']:
(MandatoryRule, rule) = SplitRuleFlag(ruleflag)
if rule not in SupportedRules:
ISupportAllRules = False
if MandatoryRule:
self.logger.error('Template from \'%s\' strictly requires unsupported rule \'%s\'', TS['name'], rule)
return None
else:
self.logger.warning('Template from \'%s\' loosely requires unsupported rule \'%s\'', TS['name'], rule)
MP['_filtered_vbavailable'] = {}
for ruleflag in MP['vbavailable']:
rulebit = MP['vbavailable'][ruleflag]
rulemask = (1 << rulebit)
if MP['version'] & rulemask:
MP['_filtered_vbavailable'][ruleflag] = rulebit
prevBlock = bytes.fromhex(MP['previousblockhash'])[::-1]
if 'height' not in MP:
MP['height'] = TS['access'].getinfo()['blocks'] + 1
height = MP['height']
bits = bytes.fromhex(MP['bits'])[::-1]
(MP['_bits'], MP['_prevBlock']) = (bits, prevBlock)
MP['_BlockVersionBytes'] = struct.pack('<L', MP['version'])
if (prevBlock, height, bits) != self.currentBlock and (self.currentBlock[1] is None or height > self.currentBlock[1]):
self.updateBlock(prevBlock, height, bits, _HBH=(MP['previousblockhash'], MP['bits']))
txnlist = MP['transactions']
if len(txnlist) and isinstance(txnlist[0], dict):
txninfo = txnlist
txnlist = tuple(a['data'] for a in txnlist)
elif 'transactionfees' in MP:
# Backward compatibility with pre-BIP22 gmp_fees branch
txninfo = [{'fee':a} for a in MP['transactionfees']]
else:
# Backward compatibility with pre-BIP22 hex-only (bitcoind <0.7, Eloipool <future)
txninfo = [{}] * len(txnlist)
# TODO: cache Txn or at least txid from previous merkle roots?
txnlist = [a for a in map(bytes.fromhex, txnlist)]
self._makeBlockSafe(MP, txnlist, txninfo)
if len(MP['transactions']) != len(txnlist) and not ISupportAllRules:
self.logger.error('Template from \'%s\' should be trimmed, but requires unsupported rule(s)', TS['name'])
return None
txnobjs = [None]
for i in range(len(txnlist)):
iinfo = txninfo[i]
ka = {}
if 'txid' in iinfo:
ka['txid'] = bytes.fromhex(iinfo['txid'])[::-1]
txnobjs.append(Txn(data=txnlist[i], **ka))
witness_commitment = CalculateWitnessCommitment(txnobjs, self.WitnessNonce, force=self.ForceWitnessCommitment)
cbtxn = self.makeCoinbaseTxn(MP['coinbasevalue'], prevBlockHex = MP['previousblockhash'], witness_commitment=witness_commitment)
cbtxn.setCoinbase(b'\0\0')
cbtxn.assemble()
txnobjs[0] = cbtxn
txnobjs = list(txnobjs)
newMerkleTree = MerkleTree(txnobjs)
newMerkleTree.POTInfo = MP.get('POTInfo')
newMerkleTree.MP = MP
newMerkleTree.oMP = oMP
newMerkleTree.witness_commitment = witness_commitment
return newMerkleTree
def createClearMerkleTree(self, height):
subsidy = 5000000000 >> (height // 210000)
cbtxn = self.makeCoinbaseTxn(subsidy, False)
cbtxn.assemble()
return MerkleTree([cbtxn])
