def run_test(self):
'''
Create a few SCs specifying related configurations for the custom fields that a cert must set; during
this phase, different versions of cmd for SC creation are tested.
Send some certificate with custom fields configured accordingly to the SC they refer.
Along the test execution, some negative test is also performed.
JSON representation of scinfo as well as tx/cert are checked for expected contents too.
'''
# network topology: (0)--(1)
# Read the huge bit vector from file
with open(
os.path.dirname(os.path.abspath(__file__)) +
"/../zen/test_data/16_GB_bitvector.bz2", "rb") as f:
BIT_VECTOR_BUF_HUGE = binascii.hexlify(f.read())
mark_logs("Node 1 generates 2 block", self.nodes, DEBUG_MODE)
self.nodes[1].generate(2)
self.sync_all()
mark_logs("Node 0 generates {} block".format(MINIMAL_SC_HEIGHT),
self.nodes, DEBUG_MODE)
self.nodes[0].generate(MINIMAL_SC_HEIGHT)
self.sync_all()
#generate wCertVk and constant
mcTest = CertTestUtils(self.options.tmpdir, self.options.srcdir)
vk = mcTest.generate_params('sc1')
constant1 = generate_random_field_element_hex()
amount = Decimal("1.0")
fee = 0.000025
#-------------------------------------------------------
bad_obj = {"a": 1, "b": 2}
cmdInput = {
'version': 0,
'withdrawalEpochLength': EPOCH_LENGTH,
'vFieldElementCertificateFieldConfig': bad_obj,
'toaddress': "abcd",
'amount': amount,
'fee': fee,
'wCertVk': vk
}
mark_logs(
"\nNode 1 create SC with wrong vFieldElementCertificateFieldConfig obj in input (expecting failure...)",
self.nodes, DEBUG_MODE)
try:
self.nodes[1].sc_create(cmdInput)
assert_true(False)
except JSONRPCException, e:
errorString = e.error['message']
mark_logs(errorString, self.nodes, DEBUG_MODE)
assert_true("not an array" in errorString)
self.nodes[0].generate(1)
self.sync_all()
block = self.nodes[0].getblock('423')
self.verify_roots(block)
#Test getblockmerkleroots with a sc-creation
print("######## Test getblockmerkleroots with a sc-creation ########")
self.nodes[0].generate(108)
self.sync_all()
#generate wCertVk and constant
mcTest = CertTestUtils(self.options.tmpdir, self.options.srcdir)
vk = mcTest.generate_params("sc1")
constant = generate_random_field_element_hex()
cmdInput = {
'version': 0,
'withdrawalEpochLength': 123,
'toaddress': "dada",
'amount': 3.0,
'wCertVk': vk,
'customData': "bb" * 1024,
'constant': constant
}
ret = self.nodes[0].sc_create(cmdInput)
scid = ret['scid']
self.sync_all()
self.nodes[0].sendtoaddress(tAddr, 1.0)
self.nodes[0].generate(1)
class SCStaleFtAndMbtrTest(BitcoinTestFramework):
alert_filename = None
def setup_chain(self, split=False):
print("Initializing test directory " + self.options.tmpdir)
initialize_chain_clean(self.options.tmpdir, NUMB_OF_NODES)
self.alert_filename = os.path.join(self.options.tmpdir, "alert.txt")
with open(self.alert_filename, 'w'):
pass # Just open then close to create zero-length file
def setup_network(self, split=False):
self.nodes = []
extra_args=[
['-scproofqueuesize=0', '-logtimemicros=1',
'-debug=sc', '-debug=py', '-debug=mempool', '-debug=net', '-debug=bench',
'-blockprioritysize=100',
'-blockmaxsize=%d'%BLK_MAX_SZ,
'-blocksforscfeecheck=%d'%NUM_BLOCK_FOR_SC_FEE_CHECK]
] * NUMB_OF_NODES
# override options for 4th miner node, no limits on sizes so it can mine all tx that are in mempool, no matter
# what fee or prios they have
extra_args[NUMB_OF_NODES-1]=['-scproofqueuesize=0', '-logtimemicros=1',
'-debug=sc', '-debug=py', '-debug=mempool', '-debug=net', '-debug=bench',
'-blockminsize=%d'%BLK_MIN_SZ,
'-blocksforscfeecheck=%d'%NUM_BLOCK_FOR_SC_FEE_CHECK]
self.nodes = start_nodes(NUMB_OF_NODES, self.options.tmpdir, extra_args)
connect_nodes_bi(self.nodes, 0, 1)
connect_nodes_bi(self.nodes, 1, 2)
connect_nodes_bi(self.nodes, 2, 3)
self.is_network_split = split
self.sync_all()
def run_test(self):
def flood_mempool():
mark_logs("Creating many txes...", self.nodes, DEBUG_MODE)
tot_num_tx = 0
tot_tx_sz = 0
taddr_node1 = self.nodes[0].getnewaddress()
fee = Decimal('0.001')
# there are a few coinbase utxo now matured
listunspent = self.nodes[0].listunspent()
print "num of utxo: ", len(listunspent)
while True:
if len(listunspent) <= tot_num_tx:
# all utxo have been spent
self.sync_all()
break
utxo = listunspent[tot_num_tx]
change = utxo['amount'] - Decimal(fee)
raw_inputs = [ {'txid' : utxo['txid'], 'vout' : utxo['vout']}]
raw_outs = { taddr_node1: change }
try:
raw_tx = self.nodes[0].createrawtransaction(raw_inputs, raw_outs)
signed_tx = self.nodes[0].signrawtransaction(raw_tx)
tx = self.nodes[0].sendrawtransaction(signed_tx['hex'])
except JSONRPCException, e:
errorString = e.error['message']
print "Send raw tx failed with reason {}".format(errorString)
assert(False)
tot_num_tx += 1
hexTx = self.nodes[0].getrawtransaction(tx)
sz = len(hexTx)//2
tot_tx_sz += sz
if tot_tx_sz > 5*EPOCH_LENGTH*BLK_MAX_SZ:
self.sync_all()
break
print "tot tx = {}, tot sz = {} ".format(tot_num_tx, tot_tx_sz)
def get_sc_fee_min_max_value(scFeesList):
m_min = Decimal('1000000000.0')
f_min = Decimal('1000000000.0')
m_max = Decimal('0.0')
f_max = Decimal('0.0')
for i in scFeesList:
f_min = min(f_min, i['forwardTxScFee'])
m_min = min(m_min, i['mbtrTxScFee'])
f_max = max(f_max, i['forwardTxScFee'])
m_max = max(m_max, i['mbtrTxScFee'])
return f_min, m_min, f_max, m_max
'''
This test checks that FT and McBTR txes are not evicted from mempool until the numbers of blocks
set by the constant defined in the base code (and overriden here by the -blocksforscfeecheck zend option)
are connected to the active chain.
In order to verify it, two null-fee and low-prio txes are sent to the mempool with a FT and a Mbtr, a large number
of high-fee/high prio txes are added too, and the miners have a small block capacity, so that the former pair is never
mined, while SC epochs increase evolving active certificates.
After a node restart, this pattern is repeated but this time the txes are mined before they are evicted from the mempool.
'''
FT_SC_FEES=[Decimal('0.001'), # creation of the SC
Decimal('0.002'), # fwd tx amount
Decimal('0.003'), # cert ep=0, q=1
Decimal('0.004'), # cert ep=0, q=2
Decimal('0.005'), # cert ep=1
Decimal('0.006'), # cert ep=2
Decimal('0.007'), # cert ep=3
Decimal('0.008')] # cert ep=4
MBTR_SC_FEES=[Decimal('0.011'), # creation of the SC
Decimal('0.011'), # mbtr tx sc fee, we can also have the same value of creation
Decimal('0.033'), # cert ep=0, q=1
Decimal('0.044'), # cert ep=0, q=2
Decimal('0.055'), # cert ep=1
Decimal('0.066'), # cert ep=2
Decimal('0.077'), # cert ep=3
Decimal('0.088')] # cert ep=4
# This is a hack for having certs always selected first by miner
# via the rpc cmd prioritisetransaction
prio_delta = Decimal(1.0E16)
fee_delta = 0 # in zats
# network topology: (0)--(1)--(2)--(3)
mark_logs("Node 0 generates 310 blocks", self.nodes, DEBUG_MODE)
blocks = self.nodes[0].generate(310)
self.sync_all()
mark_logs("Node 1 generates 110 blocks", self.nodes, DEBUG_MODE)
blocks = self.nodes[1].generate(110)
self.sync_all()
# Sidechain parameters
withdrawalEpochLength = EPOCH_LENGTH
address = "dada"
creation_amount = Decimal("5.0")
custom_data = ""
mbtrRequestDataLength = 1
mcTest = CertTestUtils(self.options.tmpdir, self.options.srcdir)
vk_tag = "sc1"
vk = mcTest.generate_params(vk_tag)
constant = generate_random_field_element_hex()
cswVk = ""
feCfg = []
bvCfg = []
# ---------------------------------------------------------------------------------------
# Node 1 - Create a valid sidechain
mark_logs("\nNode 1 creates a new sidechain", self.nodes, DEBUG_MODE)
errorString = ""
ftScFee = FT_SC_FEES[0]
mbtrScFee = MBTR_SC_FEES[0]
cmdInput = {
"version": 0,
"withdrawalEpochLength": withdrawalEpochLength,
"toaddress": address,
"amount": creation_amount,
"wCertVk": vk,
"constant": constant,
'customData': custom_data,
'wCeasedVk': cswVk,
'vFieldElementCertificateFieldConfig': feCfg,
'vBitVectorCertificateFieldConfig': bvCfg,
'forwardTransferScFee': ftScFee,
'mainchainBackwardTransferScFee': mbtrScFee,
'mainchainBackwardTransferRequestDataLength': mbtrRequestDataLength
}
try:
ret = self.nodes[1].sc_create(cmdInput)
except JSONRPCException, e:
errorString = e.error['message']
mark_logs(errorString,self.nodes,DEBUG_MODE)
assert_true(False)
try:
txFT = self.nodes[2].sc_send(forwardTransferOuts, { "fee": 0.0})
except JSONRPCException, e:
errorString = e.error['message']
mark_logs(errorString,self.nodes,DEBUG_MODE)
assert_true(False)
self.sync_all()
mark_logs("txFT={}, scFee={}".format(txFT, ftScFee), self.nodes, DEBUG_MODE)
assert_true(txFT in self.nodes[0].getrawmempool())
# ---------------------------------------------------------------------------------------
mark_logs("\nNode 3 creates a tx with an MBTR output", self.nodes, DEBUG_MODE)
errorString = ""
fe1 = generate_random_field_element_hex()
mc_dest_addr1 = self.nodes[3].getnewaddress()
mbtrOuts = [{'vScRequestData':[fe1], 'scFee':Decimal(mbtrScFee), 'scid':scid, 'mcDestinationAddress':mc_dest_addr1}]
try:
txMbtr = self.nodes[3].sc_request_transfer(mbtrOuts, { "fee": 0.0})
except JSONRPCException, e:
errorString = e.error['message']
mark_logs(errorString,self.nodes,DEBUG_MODE)
assert_true(False)
self.sync_all()
mark_logs("txMbtr={}, scFee={}".format(txMbtr, mbtrScFee), self.nodes, DEBUG_MODE)
assert_true(txMbtr in self.nodes[0].getrawmempool())
# ---------------------------------------------------------------------------------------
def run_test(self):
'''
Verify that the async proof verifier for sidechain proofs works as expected.
'''
# Prepare some coins
self.nodes[0].generate(MINIMAL_SC_HEIGHT / 2 + 1)
self.sync_all()
# Generate some coins on node 2
self.nodes[2].generate(MINIMAL_SC_HEIGHT / 2 + 1)
self.sync_all()
sc_address = "0000000000000000000000000000000000000000000000000000000000000abc"
sc_epoch_len = EPOCH_LENGTH
sc_cr_amount = Decimal('12.00000000')
cert_mc_test = CertTestUtils(self.options.tmpdir, self.options.srcdir)
csw_mc_test = CSWTestUtils(self.options.tmpdir, self.options.srcdir)
# generate wCertVk and constant
vk = cert_mc_test.generate_params("sc")
csw_vk = csw_mc_test.generate_params("sc")
constant = generate_random_field_element_hex()
sc_cr = []
sc_cr.append({
"version": 0,
"epoch_length": sc_epoch_len,
"amount": sc_cr_amount,
"address": sc_address,
"wCertVk": vk,
"wCeasedVk": csw_vk,
"constant": constant
})
rawtx = self.nodes[0].createrawtransaction([], {}, [], sc_cr)
funded_tx = self.nodes[0].fundrawtransaction(rawtx)
sig_raw_tx = self.nodes[0].signrawtransaction(funded_tx['hex'])
final_raw_tx = self.nodes[0].sendrawtransaction(sig_raw_tx['hex'])
self.sync_all()
decoded_tx = self.nodes[1].getrawtransaction(final_raw_tx, 1)
scid = decoded_tx['vsc_ccout'][0]['scid']
scid_swapped = swap_bytes(scid)
mark_logs("created SC id: {}".format(scid), self.nodes, DEBUG_MODE)
# Advance one epoch
mark_logs("\nLet 1 epoch pass by...", self.nodes, DEBUG_MODE)
cert1, epoch_number = advance_epoch(cert_mc_test, self.nodes[0],
self.sync_all, scid, "sc",
constant, sc_epoch_len)
mark_logs(
"\n==> certificate for SC epoch {} {}".format(epoch_number, cert1),
self.nodes, DEBUG_MODE)
# Check that the certificate is in the mempool
mark_logs("Check certificate is in mempool...", self.nodes, DEBUG_MODE)
assert_true(cert1 in self.nodes[0].getrawmempool())
assert_true(cert1 in self.nodes[1].getrawmempool())
# Generate blocks to reach the next epoch
mark_logs("\nLet another epoch pass by...", self.nodes, DEBUG_MODE)
self.nodes[0].generate(sc_epoch_len)
self.sync_all()
# Check that the certificate is not in the mempool anymore
mark_logs("Check certificate is not in mempool anymore...", self.nodes,
DEBUG_MODE)
assert_false(cert1 in self.nodes[0].getrawmempool())
assert_false(cert1 in self.nodes[1].getrawmempool())
epoch_number, epoch_cum_tree_hash = get_epoch_data(
scid, self.nodes[0], sc_epoch_len)
cert_quality = 1
cert_fee = Decimal("0.00001")
ft_fee = 0
mbtr_fee = 0
# Manually create a certificate with invalid proof to test the ban mechanism
# mark_logs("\nTest the node ban mechanism by sending a certificate with invalid proof", self.nodes, DEBUG_MODE)
# Create an invalid proof by providing the wrong epoch_number
proof = cert_mc_test.create_test_proof("sc", scid_swapped,
epoch_number + 1, cert_quality,
mbtr_fee, ft_fee,
epoch_cum_tree_hash, constant,
[], [])
try:
# The send_certificate call must be ok since the proof verification is disabled on node 2
invalid_cert = self.nodes[2].sc_send_certificate(
scid, epoch_number, cert_quality, epoch_cum_tree_hash, proof,
[], ft_fee, mbtr_fee, cert_fee)
except JSONRPCException, e:
error_string = e.error['message']
print "Send certificate failed with reason {}".format(error_string)
assert (False)
def run_test(self):
'''
Create 2 SCs and let them cease after 2 epochs. Create a tx with 5 csw inputs for each of the SCs and send it over the network.
Verify that it is accepted in the mempool and that another tx with a further csw input is not accepted due to mempool limit reached.
Mine a block that includes the tx in the mempool and verify that resending the previously rejected tx this time is succesful.
Mine another block and then disconnect both last blocks from active chain in all nodes.
Verify that only the last tx is included in the mempool, not the first (big) one.
'''
# network topology: (0)--(1)--(2)
mark_logs("Node 0 generates 310 blocks", self.nodes, DEBUG_MODE)
blocks = self.nodes[0].generate(310)
self.sync_all()
mark_logs("Node 1 generates 110 blocks", self.nodes, DEBUG_MODE)
blocks = self.nodes[1].generate(110)
self.sync_all()
# Sidechain parameters
withdrawalEpochLength = EPOCH_LENGTH
address = "dada"
creation_amount = Decimal("50.0")
custom_data = ""
mbtrRequestDataLength = 1
certMcTest = CertTestUtils(self.options.tmpdir, self.options.srcdir)
cswMcTest = CSWTestUtils(self.options.tmpdir, self.options.srcdir)
# generate wCertVk and constant
certVk1 = certMcTest.generate_params("sc1")
certVk2 = certMcTest.generate_params("sc2")
cswVk1 = cswMcTest.generate_params("sc1")
cswVk2 = cswMcTest.generate_params("sc2")
constant1 = generate_random_field_element_hex()
constant2 = generate_random_field_element_hex()
feCfg = []
bvCfg = []
ftScFee = Decimal('0.01')
mbtrScFee = Decimal('0.02')
# ---------------------------------------------------------------------------------------
# Node 1 - Create a valid sidechain
mark_logs("\nNode 0 creates 2 sidechains", self.nodes, DEBUG_MODE)
cmdInput = {
"version": 0,
"withdrawalEpochLength": withdrawalEpochLength,
"toaddress": address,
"amount": creation_amount,
"wCertVk": certVk1,
"constant": constant1,
'customData': custom_data,
'wCeasedVk': cswVk1,
'vFieldElementCertificateFieldConfig': feCfg,
'vBitVectorCertificateFieldConfig': bvCfg,
'forwardTransferScFee': ftScFee,
'mainchainBackwardTransferScFee': mbtrScFee,
'mainchainBackwardTransferRequestDataLength': mbtrRequestDataLength
}
try:
ret = self.nodes[0].sc_create(cmdInput)
except JSONRPCException, e:
errorString = e.error['message']
mark_logs(errorString, self.nodes, DEBUG_MODE)
assert_true(False)
def run_test(self):
'''
Create a SC, advance two epochs, move to the limit of the safe guard and then split the network.
One network part sends a certificate to keep the sidechain alive and then generates two blocks.
The other network part generates one block, theny sends a CSW.
When the network is joined, verify that the SC is alive and that the CSW transaction has been
removed from mempool.
'''
# prepare some coins
self.nodes[3].generate(1)
self.sync_all()
self.nodes[2].generate(1)
self.sync_all()
self.nodes[1].generate(1)
self.sync_all()
self.nodes[0].generate(MINIMAL_SC_HEIGHT - 3)
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
print "Node0 Chain h = ", self.nodes[0].getblockcount()
sc_address = "0000000000000000000000000000000000000000000000000000000000000abc"
sc_epoch_len = EPOCH_LENGTH
sc_cr_amount = Decimal('12.00000000')
certMcTest = CertTestUtils(self.options.tmpdir, self.options.srcdir)
cswMcTest = CSWTestUtils(self.options.tmpdir, self.options.srcdir)
# generate wCertVk and constant
vk = certMcTest.generate_params("sc1")
cswVk = cswMcTest.generate_params("csw1")
constant = generate_random_field_element_hex()
cmdInput = {
'version': 0,
'withdrawalEpochLength': sc_epoch_len,
'amount': sc_cr_amount,
'toaddress': sc_address,
'wCertVk': vk,
'wCeasedVk': cswVk,
'constant': constant,
'mainchainBackwardTransferRequestDataLength': 1
}
res = self.nodes[0].sc_create(cmdInput)
tx = res['txid']
scid = res['scid']
self.sync_all()
mark_logs("tx {} created SC {}".format(tx, scid), self.nodes,
DEBUG_MODE)
# advance two epochs
mark_logs("\nLet 2 epochs pass by...", self.nodes, DEBUG_MODE)
cert, epoch_number = advance_epoch(certMcTest, self.nodes[0],
self.sync_all, scid, "sc1",
constant, sc_epoch_len)
mark_logs(
"\n==> certificate for epoch {} {}".format(epoch_number, cert),
self.nodes, DEBUG_MODE)
cert, epoch_number = advance_epoch(certMcTest, self.nodes[0],
self.sync_all, scid, "sc1",
constant, sc_epoch_len)
mark_logs(
"\n==> certificate for epoch {} {}l".format(epoch_number, cert),
self.nodes, DEBUG_MODE)
ceas_height = self.nodes[0].getscinfo(
scid, False, False)['items'][0]['ceasingHeight']
numbBlocks = ceas_height - self.nodes[0].getblockcount(
) + sc_epoch_len - 1
print "Node0 Chain h = ", self.nodes[0].getblockcount()
mark_logs(
"\nNode0 generates {} block reaching the sg for the next epoch".
format(numbBlocks), self.nodes, DEBUG_MODE)
self.nodes[0].generate(numbBlocks)
self.sync_all()
print "Node0 Chain h = ", self.nodes[0].getblockcount()
#============================================================================================
mark_logs("\nSplit network", self.nodes, DEBUG_MODE)
self.split_network()
mark_logs("The network is split: 0-1-2 .. 3", self.nodes, DEBUG_MODE)
# Network part 0-1-2
print "------------------"
mark_logs("\nNTW part 1) Node2 sends a certificate", self.nodes,
DEBUG_MODE)
epoch_number, epoch_cum_tree_hash = get_epoch_data(
scid, self.nodes[2], sc_epoch_len)
bt_amount = Decimal("5.0")
addr_node1 = self.nodes[1].getnewaddress()
quality = 10
scid_swapped = str(swap_bytes(scid))
proof = certMcTest.create_test_proof("sc1", scid_swapped, epoch_number,
quality, MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash, constant,
[addr_node1], [bt_amount])
amount_cert = [{"address": addr_node1, "amount": bt_amount}]
try:
cert_bad = self.nodes[2].sc_send_certificate(
scid, epoch_number, quality, epoch_cum_tree_hash, proof,
amount_cert, 0, 0, 0.01)
except JSONRPCException, e:
errorString = e.error['message']
print "Send certificate failed with reason {}".format(errorString)
assert (False)
def run_test(self):
'''
Test that a backward transfer amount under its dust threshold is not accepted in the mempool.
Since this dust threshold depends on minrelaytxfee and this is an optional zend flag, test that
a node with a different value set behaves correctly and the network is not affected (no forks happen)
'''
mark_logs("Node 1 generates 2 block",self.nodes,DEBUG_MODE)
self.nodes[1].generate(2)
self.sync_all()
mark_logs("Node 0 generates {} block".format(MINIMAL_SC_HEIGHT-2),self.nodes,DEBUG_MODE)
self.nodes[0].generate(MINIMAL_SC_HEIGHT-2)
self.sync_all()
#generate wCertVk and constant
mc_test = CertTestUtils(self.options.tmpdir, self.options.srcdir)
vk = mc_test.generate_params('sc1')
constant = generate_random_field_element_hex()
# create SC
#------------------------------------------------------------------------------------------------------------
cmd_input = {
'version': 0,
'toaddress': "abcd",
'amount': 1.0,
'wCertVk': vk,
'withdrawalEpochLength': EPOCH_LENGTH,
'constant': constant
}
mark_logs("\nNode 1 create SC", self.nodes, DEBUG_MODE)
try:
res = self.nodes[1].sc_create(cmd_input)
scid = res['scid']
pprint.pprint(res)
self.sync_all()
except JSONRPCException as e:
error_string = e.error['message']
mark_logs(error_string,self.nodes,DEBUG_MODE)
assert_true(False)
mark_logs("\nNode 0 generates 1 block", self.nodes, DEBUG_MODE)
self.nodes[0].generate(1)
self.sync_all()
scid_swapped = str(swap_bytes(scid))
addr_node2 = self.nodes[2].getnewaddress()
# this amount is next to the border of the dust (54 zat, according to mintxrelayfee default value) but it is sufficiently big not to be refused
bwt_amount = Decimal('0.00000060')
bwt_cert = [{"address": addr_node2, "amount": bwt_amount}, {"address": addr_node2, "amount": bwt_amount}]
bwt_amount_array = [bwt_amount, bwt_amount]
addr_array = [addr_node2, addr_node2]
q = 10
bl_list = []
# advance some epoch and send a small backward transfer via a certificate for any epoch
for i in range(3):
if i == 1:
# On the second loop, connect a fourth node from scratch with a greater mintxrelayfee, which would make the
# node mempool reject the cert, and check this option does not prevent the chain update anyway
mark_logs("Connecting a new Node3 with a greater -mintxrelayfee", self.nodes, DEBUG_MODE)
self.nodes.append(start_node(
3, self.options.tmpdir , extra_args=[
'-logtimemicros=1', '-debug=cert', '-debug=sc', '-debug=py', '-debug=mempool',
'-allowdustoutput=0', '-minrelaytxfee='+str(CUSTOM_FEE_RATE_ZEN_PER_KBYTE)]))
connect_nodes_bi(self.nodes, 2, 3)
self.sync_all()
mark_logs("\nAdvance epoch...", self.nodes, DEBUG_MODE)
self.nodes[0].generate(EPOCH_LENGTH - 1)
self.sync_all()
epoch_number, epoch_cum_tree_hash = get_epoch_data(scid, self.nodes[0], EPOCH_LENGTH)
mark_logs("Node 1 sends a cert with a bwd transfers of {} coins to Node2".format(bwt_amount), self.nodes, DEBUG_MODE)
#==============================================================
proof = mc_test.create_test_proof(
"sc1", scid_swapped, epoch_number, q, MBTR_SC_FEE, FT_SC_FEE, epoch_cum_tree_hash,
constant, addr_array, bwt_amount_array)
try:
cert = self.nodes[1].sc_send_certificate(scid, epoch_number, q,
epoch_cum_tree_hash, proof, bwt_cert, FT_SC_FEE, MBTR_SC_FEE)
except JSONRPCException as e:
error_string = e.error['message']
print ("Send certificate failed with reason {}".format(error_string))
assert_true(False)
sync_blocks(self.nodes[0:2])
sync_mempools(self.nodes[0:2])
mark_logs("cert = {}".format(cert), self.nodes, DEBUG_MODE)
if i == 1:
# check that the certificate has ben accepted by Node0 but not by Node3 wich has a greater mintxrelayfee
mp0 = self.nodes[0].getrawmempool()
mp3 = self.nodes[3].getrawmempool()
assert_true(cert in mp0)
assert_false(cert in mp3)
mark_logs("\nNode 0 generates 1 block", self.nodes, DEBUG_MODE)
bl_last = self.nodes[0].generate(1)[-1]
bl_list.append(bl_last)
self.sync_all()
# dust amont for a cert backward transfer is 54 Zat using the 100 Zat/Kbyte default mintxrelayfee rate
# check that no certificates with dust amount can be sent via any command type
dust_amount = Decimal("0.00000053")
bwt_cert = [{"address": addr_node2, "amount": dust_amount}]
bwt_amount_array = [dust_amount]
addr_array = [addr_node2]
quality = 0
proof = mc_test.create_test_proof(
"sc1", scid_swapped, epoch_number, quality, MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash, constant, addr_array, bwt_amount_array)
utx, change = get_spendable(self.nodes[0], CERT_FEE)
raw_inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']}]
raw_outs = { self.nodes[0].getnewaddress() : change }
raw_bwt_outs = {addr_node2: dust_amount}
raw_params = {
"scid": scid,
"quality": quality,
"endEpochCumScTxCommTreeRoot": epoch_cum_tree_hash,
"scProof": proof,
"withdrawalEpochNumber": epoch_number
}
raw_cert = []
cert = []
try:
raw_cert = self.nodes[0].createrawcertificate(raw_inputs, raw_outs, raw_bwt_outs, raw_params)
signed_cert = self.nodes[0].signrawtransaction(raw_cert)
mark_logs("Node 0 sends a raw cert with a bwd transfers of {} coins to Node2 ... expecting failure".format(dust_amount), self.nodes, DEBUG_MODE)
cert = self.nodes[0].sendrawtransaction(signed_cert['hex'])
assert False
except JSONRPCException as e:
error_string = e.error['message']
print ("======> " + error_string)
try:
mark_logs("Node 0 sends a cert with a bwd transfers of {} coins to Node2 ... expecting failure".format(dust_amount), self.nodes, DEBUG_MODE)
cert = self.nodes[0].sc_send_certificate(scid, epoch_number, q,
epoch_cum_tree_hash, proof, bwt_cert, FT_SC_FEE, MBTR_SC_FEE)
assert False
except JSONRPCException as e:
error_string = e.error['message']
print ("======> " + error_string)
bal = self.nodes[2].getbalance()
utx = self.nodes[2].listunspent()
print ("Node2 balance = {}".format(bal))
assert_equal(bal, 2*bwt_amount)
# the dust threshold for a bwt (54 Zat) is lower than the one for a standard output due to the replay protection
# extension in the pub script (63 Zat). As a result we can not spend exactly one UTXOs coming from backward transfer
# otherwise we would create a dust output.
mark_logs("Node2 tries to spent one utxo from bwt sending {} coins to Node0 ... expecting failure".format(utx[0]['amount']), self.nodes, DEBUG_MODE)
# try spending one utxo
inputs = [ {'txid' : utx[0]['txid'], 'vout' : utx[0]['vout']}]
outputs = { self.nodes[0].getnewaddress() : utx[0]['amount'] }
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
rawtx = self.nodes[2].signrawtransaction(rawtx)
error_string = ""
try:
rawtx = self.nodes[2].sendrawtransaction(rawtx['hex'])
assert False
except JSONRPCException as e:
error_string = e.error['message']
print (error_string)
# we can spend a pair of them instead
mark_logs("Node2 tries to spent both utxo from bwt sending {} coins to Node0".format(bal), self.nodes, DEBUG_MODE)
# try spending two utxos
inputs = [ {'txid' : utx[0]['txid'], 'vout' : utx[0]['vout']}, {'txid' : utx[1]['txid'], 'vout' : utx[1]['vout']}]
outputs = { self.nodes[0].getnewaddress() : bal }
rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
rawtx = self.nodes[2].signrawtransaction(rawtx)
error_string = ""
try:
rawtx = self.nodes[2].sendrawtransaction(rawtx['hex'])
except JSONRPCException as e:
error_string = e.error['message']
print (error_string)
assert False
print ("tx = {}".format(rawtx))
sync_blocks(self.nodes[0:2])
sync_mempools(self.nodes[0:2])
# just to be sure tx is propagated
time.sleep(2)
mark_logs("Node 2 generates 1 block", self.nodes, DEBUG_MODE)
self.nodes[2].generate(1)
self.sync_all()
mark_logs("\nChecking persistance stopping and restarting nodes", self.nodes, DEBUG_MODE)
stop_nodes(self.nodes)
wait_bitcoinds()
self.setup_network(False)
def run_test(self):
#amounts
creation_amount = Decimal("50")
bwt_amount = Decimal("5")
tAddr1 = self.nodes[1].getnewaddress()
node1Addr = self.nodes[1].validateaddress(tAddr1)['address']
self.nodes[0].generate(MINIMAL_SC_HEIGHT)
self.sync_all()
mark_logs("Node 0 generates {} block".format(MINIMAL_SC_HEIGHT),
self.nodes, DEBUG_MODE)
#generate wCertVk and constant
mcTest = CertTestUtils(self.options.tmpdir, self.options.srcdir)
vk = mcTest.generate_params("sc1")
constant = generate_random_field_element_hex()
cmdInput = {
'version': 0,
'withdrawalEpochLength': EPOCH_LENGTH,
'toaddress': "dada",
'amount': creation_amount,
'wCertVk': vk,
'constant': constant
}
ret = self.nodes[0].sc_create(cmdInput)
creating_tx = ret['txid']
scid = ret['scid']
scid_swapped = str(swap_bytes(scid))
mark_logs(
"Node 1 created the SC spending {} coins via tx {}.".format(
creation_amount, creating_tx), self.nodes, DEBUG_MODE)
self.sync_all()
decoded_tx = self.nodes[0].getrawtransaction(creating_tx, 1)
assert_equal(scid, decoded_tx['vsc_ccout'][0]['scid'])
mark_logs("created SC id: {}".format(scid), self.nodes, DEBUG_MODE)
mark_logs("Node0 confirms Sc creation generating 1 block", self.nodes,
DEBUG_MODE)
sc_creation_block_hash = self.nodes[0].generate(1)[0]
sc_creation_block = self.nodes[0].getblock(sc_creation_block_hash)
self.sync_all()
#Advance for 1 Epoch
mark_logs("Advance for 1 Epoch", self.nodes, DEBUG_MODE)
self.nodes[0].generate(EPOCH_LENGTH)
self.sync_all()
#Mine Certificate 1 with quality = 5
epoch_number, epoch_cum_tree_hash = get_epoch_data(
scid, self.nodes[0], EPOCH_LENGTH)
quality = 5
proof = mcTest.create_test_proof("sc1", scid_swapped, epoch_number,
quality, MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash, constant,
[node1Addr], [bwt_amount])
amount_cert_1 = [{"address": node1Addr, "amount": bwt_amount}]
mark_logs("Mine Certificate 1 with quality = {}...".format(quality),
self.nodes, DEBUG_MODE)
cert1 = self.nodes[0].sc_send_certificate(scid, epoch_number, quality,
epoch_cum_tree_hash, proof,
amount_cert_1, FT_SC_FEE,
MBTR_SC_FEE, CERT_FEE)
self.sync_all()
maturityHeight = sc_creation_block["height"] + (
EPOCH_LENGTH * 2) + EPOCH_LENGTH * 0.2 - 1
####### Test getaddressmempool ########
addressmempool = self.nodes[1].getaddressmempool(
{"addresses": [tAddr1]})
assert_equal(len(addressmempool), 1)
assert_equal(addressmempool[0]['txid'], cert1)
assert_equal(addressmempool[0]['satoshis'], float(bwt_amount) * 1e8)
assert_equal(addressmempool[0]['address'], tAddr1)
assert_equal(addressmempool[0]['outstatus'],
TOP_QUALITY_CERT_BACKWARD_TRANSFER)
self.nodes[0].generate(1)
self.sync_all()
####### Test getaddressmempool ########
addressmempool = self.nodes[1].getaddressmempool(
{"addresses": [tAddr1]})
assert_equal(addressmempool, [])
####### Test getaddresstxids ########
addresstxids = self.nodes[1].getaddresstxids({"addresses": [tAddr1]})
assert_equal(len(addresstxids), 1)
assert_equal(addresstxids[0], cert1)
####### Test getaddressbalance ########
addressbalance = self.nodes[1].getaddressbalance(
{"addresses": [tAddr1]})
addressbalanceWithImmature = self.nodes[1].getaddressbalance(
{"addresses": [tAddr1]}, True)
assert_equal(addressbalance["balance"], 0)
assert_equal(addressbalance["immature"], to_satoshis(bwt_amount))
assert_equal(addressbalance["received"], 0)
assert_equal(addressbalanceWithImmature["balance"],
to_satoshis(bwt_amount))
assert_equal(addressbalanceWithImmature["immature"],
to_satoshis(bwt_amount))
assert_equal(addressbalanceWithImmature["received"],
to_satoshis(bwt_amount))
####### Test getaddressutxo ########
addressutxo = self.nodes[1].getaddressutxos({"addresses": [tAddr1]})
assert_equal(len(addressutxo), 0)
addressutxoWithImmature = self.nodes[1].getaddressutxos(
{"addresses": [tAddr1]}, True)
assert_equal(len(addressutxoWithImmature), 1)
assert_true(addressutxoWithImmature[0]["backwardTransfer"])
assert_false(addressutxoWithImmature[0]["mature"])
assert_equal(addressutxoWithImmature[0]["maturityHeight"],
maturityHeight)
assert_equal(addressutxoWithImmature[0]["satoshis"],
to_satoshis(bwt_amount))
currentHeight = self.nodes[0].getblockcount()
assert_equal(addressutxoWithImmature[0]["blocksToMaturity"],
maturityHeight - currentHeight)
#Add to mempool Certificate 2 with quality = 7
epoch_number, epoch_cum_tree_hash = get_epoch_data(
scid, self.nodes[0], EPOCH_LENGTH)
quality = 7
bwt_amount2 = Decimal("7")
mark_logs(
"Add to mempool Certificate 2 with quality = {}...".format(
quality), self.nodes, DEBUG_MODE)
proof = mcTest.create_test_proof("sc1", scid_swapped, epoch_number,
quality, MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash, constant,
[node1Addr], [bwt_amount2])
amount_cert_2 = [{"address": node1Addr, "amount": bwt_amount2}]
cert2 = self.nodes[0].sc_send_certificate(scid, epoch_number, quality,
epoch_cum_tree_hash, proof,
amount_cert_2, FT_SC_FEE,
MBTR_SC_FEE, CERT_FEE)
self.sync_all()
####### Test getaddressmempool ########
addressmempool = self.nodes[1].getaddressmempool(
{"addresses": [tAddr1]})
assert_equal(len(addressmempool), 1)
assert_equal(addressmempool[0]['txid'], cert2)
assert_equal(addressmempool[0]['satoshis'], float(bwt_amount2) * 1e8)
assert_equal(addressmempool[0]['address'], tAddr1)
assert_equal(addressmempool[0]['outstatus'],
TOP_QUALITY_CERT_BACKWARD_TRANSFER)
quality = 9
bwt_amount3 = Decimal("9")
mark_logs(
"Add to mempool Certificate 3 with quality = {}...".format(
quality), self.nodes, DEBUG_MODE)
proof = mcTest.create_test_proof("sc1", scid_swapped, epoch_number,
quality, MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash, constant,
[node1Addr], [bwt_amount3])
amount_cert_3 = [{"address": node1Addr, "amount": bwt_amount3}]
cert3 = self.nodes[0].sc_send_certificate(scid, epoch_number, quality,
epoch_cum_tree_hash, proof,
amount_cert_3, FT_SC_FEE,
MBTR_SC_FEE, CERT_FEE)
self.sync_all()
####### Test getaddressmempool ########
addressmempool = self.nodes[1].getaddressmempool(
{"addresses": [tAddr1]})
assert_equal(len(addressmempool), 2)
assert_equal(addressmempool[0]['txid'], cert2)
assert_equal(addressmempool[0]['satoshis'], float(bwt_amount2) * 1e8)
assert_equal(addressmempool[0]['address'], tAddr1)
assert_equal(addressmempool[0]['outstatus'],
LOW_QUALITY_CERT_BACKWARD_TRANSFER)
assert_equal(addressmempool[1]['txid'], cert3)
assert_equal(addressmempool[1]['satoshis'], float(bwt_amount3) * 1e8)
assert_equal(addressmempool[1]['address'], tAddr1)
assert_equal(addressmempool[1]['outstatus'],
TOP_QUALITY_CERT_BACKWARD_TRANSFER)
self.nodes[0].generate(1)
self.sync_all()
####### Test getaddresstxids ########
addresstxids = self.nodes[1].getaddresstxids({"addresses": [tAddr1]})
assert_equal(len(addresstxids), 3)
assert_true(cert1 in addresstxids and cert2 in addresstxids
and cert3 in addresstxids)
####### Test getaddressmempool ########
addressmempool = self.nodes[1].getaddressmempool(
{"addresses": [tAddr1]})
assert_equal(len(addressmempool), 0)
####### Test getaddressbalance ########
addressbalance = self.nodes[1].getaddressbalance(
{"addresses": [tAddr1]})
addressbalanceWithImmature = self.nodes[1].getaddressbalance(
{"addresses": [tAddr1]}, True)
assert_equal(addressbalance["balance"], 0)
assert_equal(addressbalance["immature"], to_satoshis(bwt_amount3))
assert_equal(addressbalance["received"], 0)
assert_equal(addressbalanceWithImmature["balance"],
to_satoshis(bwt_amount3))
assert_equal(addressbalanceWithImmature["immature"],
to_satoshis(bwt_amount3))
assert_equal(addressbalanceWithImmature["received"],
to_satoshis(bwt_amount3))
####### Test getaddressutxo ########
addressutxo = self.nodes[1].getaddressutxos({"addresses": [tAddr1]})
addressutxoWithImmature = self.nodes[1].getaddressutxos(
{"addresses": [tAddr1]}, True)
assert_equal(len(addressutxo), 0)
assert_equal(len(addressutxoWithImmature), 1)
assert_true(addressutxoWithImmature[0]["backwardTransfer"])
assert_false(addressutxoWithImmature[0]["mature"])
assert_equal(addressutxoWithImmature[0]["maturityHeight"],
maturityHeight)
assert_equal(addressutxoWithImmature[0]["satoshis"],
to_satoshis(bwt_amount3))
currentHeight = self.nodes[0].getblockcount()
assert_equal(addressutxoWithImmature[0]["blocksToMaturity"],
maturityHeight - currentHeight)
# Split the network: (0) / (1)
mark_logs("\nSplit network", self.nodes, DEBUG_MODE)
self.split_network()
mark_logs("The network is split: 0 / 1", self.nodes, DEBUG_MODE)
#Mine a block with Certificate 4 with quality = 11 and Certificate 5 with quality = 13
epoch_number, epoch_cum_tree_hash = get_epoch_data(
scid, self.nodes[0], EPOCH_LENGTH)
quality = 11
bwt_amount4 = Decimal("11")
mark_logs(
"Create a Certificate 4 with quality = {}...".format(quality),
self.nodes, DEBUG_MODE)
proof = mcTest.create_test_proof("sc1", scid_swapped, epoch_number,
quality, MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash, constant,
[node1Addr], [bwt_amount4])
amount_cert_4 = [{"address": node1Addr, "amount": bwt_amount4}]
cert4 = self.nodes[0].sc_send_certificate(scid, epoch_number, quality,
epoch_cum_tree_hash, proof,
amount_cert_4, FT_SC_FEE,
MBTR_SC_FEE, CERT_FEE)
quality = 13
bwt_amount5 = Decimal("13")
mark_logs("Create a Certificat 5 with quality = {}...".format(quality),
self.nodes, DEBUG_MODE)
proof = mcTest.create_test_proof("sc1", scid_swapped, epoch_number,
quality, MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash, constant,
[node1Addr], [bwt_amount5])
amount_cert_5 = [{"address": node1Addr, "amount": bwt_amount5}]
cert5 = self.nodes[0].sc_send_certificate(scid, epoch_number, quality,
epoch_cum_tree_hash, proof,
amount_cert_5, FT_SC_FEE,
MBTR_SC_FEE, CERT_FEE)
lastBlock = self.nodes[0].generate(1)[0]
# Checking the network chain tips
mark_logs("\nChecking network chain tips...", self.nodes, DEBUG_MODE)
print(self.nodes[0].getblockchaininfo()['blocks'])
print(self.nodes[1].getblockchaininfo()['blocks'])
assert_equal(self.nodes[0].getblockchaininfo()['blocks'], 524)
assert_equal(self.nodes[1].getblockchaininfo()['blocks'], 523)
mark_logs("\nJoining network", self.nodes, DEBUG_MODE)
self.join_network()
mark_logs("\nNetwork joined", self.nodes, DEBUG_MODE)
####### Test getaddresstxids ########
addresstxids = self.nodes[1].getaddresstxids({"addresses": [tAddr1]})
assert_equal(len(addresstxids), 5)
####### Test getaddressmempool ########
addressmempool = self.nodes[1].getaddressmempool(
{"addresses": [tAddr1]})
assert_equal(len(addressmempool), 0)
####### Test getaddressbalance ########
addressbalance = self.nodes[1].getaddressbalance(
{"addresses": [tAddr1]})
addressbalanceWithImmature = self.nodes[1].getaddressbalance(
{"addresses": [tAddr1]}, True)
assert_equal(addressbalance["balance"], 0)
assert_equal(addressbalance["immature"], to_satoshis(bwt_amount5))
assert_equal(addressbalance["received"], 0)
assert_equal(addressbalanceWithImmature["balance"],
to_satoshis(bwt_amount5))
assert_equal(addressbalanceWithImmature["immature"],
to_satoshis(bwt_amount5))
assert_equal(addressbalanceWithImmature["received"],
to_satoshis(bwt_amount5))
####### Test getaddressutxo ########
addressutxo = self.nodes[1].getaddressutxos({"addresses": [tAddr1]})
addressutxoWithImmature = self.nodes[1].getaddressutxos(
{"addresses": [tAddr1]}, True)
assert_equal(len(addressutxo), 0)
assert_equal(len(addressutxoWithImmature), 1)
assert_true(addressutxoWithImmature[0]["backwardTransfer"])
assert_false(addressutxoWithImmature[0]["mature"])
assert_equal(addressutxoWithImmature[0]["maturityHeight"],
maturityHeight)
assert_equal(addressutxoWithImmature[0]["satoshis"],
to_satoshis(bwt_amount5))
currentHeight = self.nodes[0].getblockcount()
assert_equal(addressutxoWithImmature[0]["blocksToMaturity"],
maturityHeight - currentHeight)
# Checking the network chain tips
mark_logs("\nChecking network chain tips...", self.nodes, DEBUG_MODE)
for i in range(0, NUMB_OF_NODES):
assert_equal(self.nodes[i].getblockchaininfo()['blocks'], 524)
mark_logs(
"\nInvalidating the last block and checking RPC call results...",
self.nodes, DEBUG_MODE)
self.nodes[1].invalidateblock(lastBlock)
####### Test getaddressmempool ########
addressmempool = self.nodes[1].getaddressmempool(
{"addresses": [tAddr1]})
assert_equal(len(addressmempool), 2)
for i in range(0, len(addressmempool)):
if (addressmempool[i]['txid'] == cert4):
assert_equal(addressmempool[i]['txid'], cert4)
assert_equal(addressmempool[i]['satoshis'],
float(bwt_amount4) * 1e8)
assert_equal(addressmempool[i]['address'], tAddr1)
assert_equal(addressmempool[i]['outstatus'],
LOW_QUALITY_CERT_BACKWARD_TRANSFER)
else:
assert_equal(addressmempool[i]['txid'], cert5)
assert_equal(addressmempool[i]['satoshis'],
float(bwt_amount5) * 1e8)
assert_equal(addressmempool[i]['address'], tAddr1)
assert_equal(addressmempool[i]['outstatus'],
TOP_QUALITY_CERT_BACKWARD_TRANSFER)
####### Test getaddressbalance ########
addressbalance = self.nodes[1].getaddressbalance(
{"addresses": [tAddr1]})
addressbalanceWithImmature = self.nodes[1].getaddressbalance(
{"addresses": [tAddr1]}, True)
assert_equal(addressbalance["balance"], 0)
assert_equal(addressbalance["immature"], to_satoshis(bwt_amount3))
assert_equal(addressbalance["received"], 0)
assert_equal(addressbalanceWithImmature["balance"],
to_satoshis(bwt_amount3))
assert_equal(addressbalanceWithImmature["immature"],
to_satoshis(bwt_amount3))
assert_equal(addressbalanceWithImmature["received"],
to_satoshis(bwt_amount3))
####### Test getaddressutxo ########
addressutxo = self.nodes[1].getaddressutxos({"addresses": [tAddr1]})
addressutxoWithImmature = self.nodes[1].getaddressutxos(
{"addresses": [tAddr1]}, True)
assert_equal(len(addressutxo), 0)
assert_equal(len(addressutxoWithImmature), 1)
assert_true(addressutxoWithImmature[0]["backwardTransfer"])
assert_false(addressutxoWithImmature[0]["mature"])
assert_equal(addressutxoWithImmature[0]["maturityHeight"],
maturityHeight)
assert_equal(addressutxoWithImmature[0]["satoshis"],
to_satoshis(bwt_amount3))
currentHeight = self.nodes[1].getblockcount()
assert_equal(addressutxoWithImmature[0]["blocksToMaturity"],
maturityHeight - currentHeight)
# Generate blocks to reach maturity height (and also make sidechain cease)
mark_logs("\nGenerating blocks to make the sidechain ceased...",
self.nodes, DEBUG_MODE)
lastBlock = self.nodes[1].generate(int(maturityHeight -
currentHeight))[-1]
self.sync_all()
mark_logs(
"Checking that all the certificates are considered as not mature...",
self.nodes, DEBUG_MODE)
####### Test getaddressbalance ########
addressbalance = self.nodes[1].getaddressbalance(
{"addresses": [tAddr1]})
addressbalanceWithImmature = self.nodes[1].getaddressbalance(
{"addresses": [tAddr1]}, True)
# All the balances should be 0 since the sidechain is ceased and no BT has matured
assert_equal(addressbalance["balance"], 0)
assert_equal(addressbalance["immature"], 0)
assert_equal(addressbalance["received"], 0)
assert_equal(addressbalanceWithImmature["balance"], 0)
assert_equal(addressbalanceWithImmature["immature"], 0)
assert_equal(addressbalanceWithImmature["received"], 0)
####### Test getaddressutxo ########
addressutxo = self.nodes[1].getaddressutxos({"addresses": [tAddr1]})
addressutxoWithImmature = self.nodes[1].getaddressutxos(
{"addresses": [tAddr1]}, True)
assert_equal(len(addressutxo), 0)
assert_equal(len(addressutxoWithImmature), 0)
# Invalidate the last block to recover the sidechain from the "ceased" state and make
# it "alive" again.
mark_logs(
"\nInvalidating the last block to make the sidechain alive again...",
self.nodes, DEBUG_MODE)
self.nodes[1].invalidateblock(lastBlock)
mark_logs(
"Checking that the certificates are restored as they were before the block revert...",
self.nodes, DEBUG_MODE)
####### Test getaddressbalance ########
addressbalance = self.nodes[1].getaddressbalance(
{"addresses": [tAddr1]})
addressbalanceWithImmature = self.nodes[1].getaddressbalance(
{"addresses": [tAddr1]}, True)
assert_equal(addressbalance["balance"], 0)
assert_equal(addressbalance["immature"], to_satoshis(bwt_amount5))
assert_equal(addressbalance["received"], 0)
assert_equal(addressbalanceWithImmature["balance"],
to_satoshis(bwt_amount5))
assert_equal(addressbalanceWithImmature["immature"],
to_satoshis(bwt_amount5))
assert_equal(addressbalanceWithImmature["received"],
to_satoshis(bwt_amount5))
####### Test getaddressutxo ########
addressutxo = self.nodes[1].getaddressutxos({"addresses": [tAddr1]})
addressutxoWithImmature = self.nodes[1].getaddressutxos(
{"addresses": [tAddr1]}, True)
assert_equal(len(addressutxo), 0)
assert_equal(len(addressutxoWithImmature), 1)
assert_true(addressutxoWithImmature[0]["backwardTransfer"])
assert_false(addressutxoWithImmature[0]["mature"])
assert_equal(addressutxoWithImmature[0]["maturityHeight"],
maturityHeight)
assert_equal(addressutxoWithImmature[0]["satoshis"],
to_satoshis(bwt_amount5))
currentHeight = self.nodes[1].getblockcount()
assert_equal(addressutxoWithImmature[0]["blocksToMaturity"],
maturityHeight - currentHeight)
ret = self.nodes[1].verifychain(4, 0)
assert_equal(ret, True)
class CertMempoolCleanupSplit(BitcoinTestFramework):
def setup_chain(self):
print("Initializing test directory " + self.options.tmpdir)
initialize_chain_clean(self.options.tmpdir, NUMB_OF_NODES)
def setup_network(self, split=False):
self.nodes = start_nodes(
NUMB_OF_NODES,
self.options.tmpdir,
extra_args=[[
'-logtimemicros=1', '-scproofqueuesize=0', '-debug=sc',
'-debug=py', '-debug=mempool', '-debug=net', '-debug=bench'
]] * NUMB_OF_NODES)
if not split:
# 2 and 3 are joint only if split==false
connect_nodes_bi(self.nodes, 2, 3)
sync_blocks(self.nodes[2:4])
sync_mempools(self.nodes[2:4])
connect_nodes_bi(self.nodes, 0, 1)
connect_nodes_bi(self.nodes, 1, 2)
self.is_network_split = split
self.sync_all()
def split_network(self):
# Split the network of three nodes into nodes 0-1-2 and 3.
assert not self.is_network_split
disconnect_nodes(self.nodes[2], 3)
disconnect_nodes(self.nodes[3], 2)
self.is_network_split = True
def join_network(self):
# Join the (previously split) network pieces together: 0-1-2-3
assert self.is_network_split
connect_nodes_bi(self.nodes, 2, 3)
connect_nodes_bi(self.nodes, 3, 2)
time.sleep(2)
self.is_network_split = False
def run_test(self):
'''
Create a SC, advance two epochs, move to the limit of the safe guard and then split the network.
One network part sends a certificate to keep the sidechain alive and then generates two blocks.
The other network part generates one block, theny sends a CSW.
When the network is joined, verify that the SC is alive and that the CSW transaction has been
removed from mempool.
'''
# prepare some coins
self.nodes[3].generate(1)
self.sync_all()
self.nodes[2].generate(1)
self.sync_all()
self.nodes[1].generate(1)
self.sync_all()
self.nodes[0].generate(MINIMAL_SC_HEIGHT - 3)
self.sync_all()
self.nodes[0].generate(1)
self.sync_all()
print "Node0 Chain h = ", self.nodes[0].getblockcount()
sc_address = "0000000000000000000000000000000000000000000000000000000000000abc"
sc_epoch_len = EPOCH_LENGTH
sc_cr_amount = Decimal('12.00000000')
certMcTest = CertTestUtils(self.options.tmpdir, self.options.srcdir)
cswMcTest = CSWTestUtils(self.options.tmpdir, self.options.srcdir)
# generate wCertVk and constant
vk = certMcTest.generate_params("sc1")
cswVk = cswMcTest.generate_params("csw1")
constant = generate_random_field_element_hex()
cmdInput = {
'version': 0,
'withdrawalEpochLength': sc_epoch_len,
'amount': sc_cr_amount,
'toaddress': sc_address,
'wCertVk': vk,
'wCeasedVk': cswVk,
'constant': constant,
'mainchainBackwardTransferRequestDataLength': 1
}
res = self.nodes[0].sc_create(cmdInput)
tx = res['txid']
scid = res['scid']
self.sync_all()
mark_logs("tx {} created SC {}".format(tx, scid), self.nodes,
DEBUG_MODE)
# advance two epochs
mark_logs("\nLet 2 epochs pass by...", self.nodes, DEBUG_MODE)
cert, epoch_number = advance_epoch(certMcTest, self.nodes[0],
self.sync_all, scid, "sc1",
constant, sc_epoch_len)
mark_logs(
"\n==> certificate for epoch {} {}".format(epoch_number, cert),
self.nodes, DEBUG_MODE)
cert, epoch_number = advance_epoch(certMcTest, self.nodes[0],
self.sync_all, scid, "sc1",
constant, sc_epoch_len)
mark_logs(
"\n==> certificate for epoch {} {}l".format(epoch_number, cert),
self.nodes, DEBUG_MODE)
ceas_height = self.nodes[0].getscinfo(
scid, False, False)['items'][0]['ceasingHeight']
numbBlocks = ceas_height - self.nodes[0].getblockcount(
) + sc_epoch_len - 1
print "Node0 Chain h = ", self.nodes[0].getblockcount()
mark_logs(
"\nNode0 generates {} block reaching the sg for the next epoch".
format(numbBlocks), self.nodes, DEBUG_MODE)
self.nodes[0].generate(numbBlocks)
self.sync_all()
print "Node0 Chain h = ", self.nodes[0].getblockcount()
#============================================================================================
mark_logs("\nSplit network", self.nodes, DEBUG_MODE)
self.split_network()
mark_logs("The network is split: 0-1-2 .. 3", self.nodes, DEBUG_MODE)
# Network part 0-1-2
print "------------------"
mark_logs("\nNTW part 1) Node2 sends a certificate", self.nodes,
DEBUG_MODE)
epoch_number, epoch_cum_tree_hash = get_epoch_data(
scid, self.nodes[2], sc_epoch_len)
bt_amount = Decimal("5.0")
addr_node1 = self.nodes[1].getnewaddress()
quality = 10
scid_swapped = str(swap_bytes(scid))
proof = certMcTest.create_test_proof("sc1", scid_swapped, epoch_number,
quality, MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash, constant,
[addr_node1], [bt_amount])
amount_cert = [{"address": addr_node1, "amount": bt_amount}]
try:
cert_bad = self.nodes[2].sc_send_certificate(
scid, epoch_number, quality, epoch_cum_tree_hash, proof,
amount_cert, 0, 0, 0.01)
except JSONRPCException, e:
errorString = e.error['message']
print "Send certificate failed with reason {}".format(errorString)
assert (False)
sync_mempools(self.nodes[0:3])
mark_logs("Check cert {} is in mempool".format(cert_bad), self.nodes,
DEBUG_MODE)
assert_true(cert_bad in self.nodes[0].getrawmempool())
mark_logs(
"Generates two blocks to make the chain longer than sub-network 2",
self.nodes, DEBUG_MODE)
self.nodes[0].generate(2)
print "Node0 Chain h = ", self.nodes[0].getblockcount()
# Network part 2
#------------------
mark_logs(
"\nNTW part 2) Node3 generates one block to cease the sidechain",
self.nodes, DEBUG_MODE)
self.nodes[3].generate(1)
mark_logs("Check that the sidechain is ceased from node 3 perspective",
self.nodes, DEBUG_MODE)
ret = self.nodes[3].getscinfo(scid, False, False)['items'][0]
assert_equal(ret['state'], "CEASED")
sc_bal = ret['balance']
mark_logs("Node 3 creates a CSW transaction", self.nodes, DEBUG_MODE)
csw_mc_address = self.nodes[3].getnewaddress()
taddr = self.nodes[3].getnewaddress()
sc_csw_amount = sc_bal
null = generate_random_field_element_hex()
actCertData = self.nodes[3].getactivecertdatahash(scid)['certDataHash']
ceasingCumScTxCommTree = self.nodes[3].getceasingcumsccommtreehash(
scid)['ceasingCumScTxCommTree']
csw_proof = cswMcTest.create_test_proof("csw1", sc_csw_amount,
str(scid_swapped), null,
csw_mc_address,
ceasingCumScTxCommTree,
actCertData, constant)
sc_csws = [{
"amount": sc_csw_amount,
"senderAddress": csw_mc_address,
"scId": scid,
"epoch": 0,
"nullifier": null,
"activeCertData": actCertData,
"ceasingCumScTxCommTree": ceasingCumScTxCommTree,
"scProof": csw_proof
}]
out_amount = sc_csw_amount / Decimal("2.0")
sc_csw_tx_outs = {taddr: out_amount}
rawtx = self.nodes[3].createrawtransaction([], sc_csw_tx_outs, sc_csws)
funded_tx = self.nodes[3].fundrawtransaction(rawtx)
sigRawtx = self.nodes[3].signrawtransaction(funded_tx['hex'])
try:
csw_bad = self.nodes[3].sendrawtransaction(sigRawtx['hex'])
pprint.pprint(self.nodes[3].getrawtransaction(tx, 1))
assert (False)
except JSONRPCException, e:
errorString = e.error['message']
mark_logs("Send csw failed with reason {}".format(errorString),
self.nodes, DEBUG_MODE)
def run_test(self):
'''
Test that the JSON result of the rpc command listsinceblock includes a matured certificate backward transfer even when:
1) the input block range specified does not contain the block where such certificate has been mined.
2) The certificate matures in one of the blocks of the specified range
'''
mark_logs("Node 1 generates 2 block", self.nodes, DEBUG_MODE)
self.nodes[1].generate(2)
self.sync_all()
mark_logs("Node 0 generates {} block".format(MINIMAL_SC_HEIGHT - 2),
self.nodes, DEBUG_MODE)
self.nodes[0].generate(MINIMAL_SC_HEIGHT - 2)
self.sync_all()
#generate wCertVk and constant
mcTest = CertTestUtils(self.options.tmpdir, self.options.srcdir)
vk = mcTest.generate_params('sc1')
constant = generate_random_field_element_hex()
# create SC
#------------------------------------------------------------------------------------------------------------
cmdInput = {
'version': 0,
'toaddress': "abcd",
'amount': 20.0,
'wCertVk': vk,
'withdrawalEpochLength': EPOCH_LENGTH,
'constant': constant
}
mark_logs("\nNode 1 create SC", self.nodes, DEBUG_MODE)
try:
res = self.nodes[1].sc_create(cmdInput)
tx = res['txid']
scid = res['scid']
pprint.pprint(res)
self.sync_all()
except JSONRPCException as e:
errorString = e.error['message']
mark_logs(errorString, self.nodes, DEBUG_MODE)
assert_true(False)
mark_logs("\nNode 0 generates 1 block", self.nodes, DEBUG_MODE)
bl = self.nodes[0].generate(1)[-1]
self.sync_all()
item = self.nodes[0].getscinfo(scid)['items'][0]
elen = item['withdrawalEpochLength']
wlen = item['certSubmissionWindowLength']
ch = item['createdAtBlockHeight']
scid_swapped = str(swap_bytes(scid))
q = 10
blocks_d = {}
block_heights_d = {}
certs_d = {}
mat_height_d = {}
taddr1 = self.nodes[1].getnewaddress()
taddr2 = self.nodes[2].getnewaddress()
# advance some epochs and send a certificate for any of them
for i in range(3):
am_bwt1 = Decimal(i + 1) + Decimal('0.01')
am_bwt2 = Decimal(i + 1) + Decimal('0.02')
am_out = Decimal('0.001') * (i + 1)
mark_logs("Advance epoch...", self.nodes, DEBUG_MODE)
self.nodes[0].generate(EPOCH_LENGTH - 1)
self.sync_all()
epoch_number, epoch_cum_tree_hash = get_epoch_data(
scid, self.nodes[0], EPOCH_LENGTH)
mark_logs("Node 1 sends a cert", self.nodes, DEBUG_MODE)
#==============================================================
pkh_arr = []
am_bwt_arr = []
raw_bwt_outs = [{
"address": taddr1,
"amount": am_bwt1
}, {
"address": taddr2,
"amount": am_bwt2
}]
for entry in raw_bwt_outs:
pkh_arr.append(entry["address"])
am_bwt_arr.append(entry["amount"])
proof = mcTest.create_test_proof("sc1", scid_swapped, epoch_number,
q, MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash, constant,
pkh_arr, am_bwt_arr)
utx, change = get_spendable(self.nodes[1], CERT_FEE + am_out)
raw_inputs = [{'txid': utx['txid'], 'vout': utx['vout']}]
raw_outs = {taddr1: change, taddr2: am_out}
raw_params = {
"scid": scid,
"quality": q,
"endEpochCumScTxCommTreeRoot": epoch_cum_tree_hash,
"scProof": proof,
"withdrawalEpochNumber": epoch_number
}
# use the raw version of the command for having more than one standard output
# -------------------------------------
# vout 1: standard output (taddr1) - change
# vout 2: standard output (taddr2)
# vout 3: bwt (taddr1)
# vout 3: bwt (taddr2)
try:
raw_cert = self.nodes[1].createrawcertificate(
raw_inputs, raw_outs, raw_bwt_outs, raw_params)
signed_cert = self.nodes[1].signrawtransaction(raw_cert)
certs_d[i] = self.nodes[1].sendrawtransaction(
signed_cert['hex'])
except JSONRPCException as e:
errorString = e.error['message']
print("\n======> ", errorString)
assert_true(False)
self.sync_all()
mark_logs("cert = {}".format(certs_d[i]), self.nodes, DEBUG_MODE)
mat_height_d[i] = ch - 1 + (i + 2) * elen + wlen
print("mat height = {}".format(mat_height_d[i]))
mark_logs("Node 0 generates 1 block", self.nodes, DEBUG_MODE)
bl = self.nodes[0].generate(1)[-1]
self.sync_all()
c = self.nodes[0].getblockcount()
blocks_d[i] = bl
block_heights_d[i] = c
# the first of the 3 certificates has reached maturity and Node2 has a consistent balance
bal = self.nodes[2].getbalance()
print("Node2 balance = {}".format(bal))
assert_equal(
bal,
Decimal('1.02') + Decimal('0.001') + Decimal('0.002') +
Decimal('0.003'))
mark_logs("Calling listsinceblock on Node2 for all transactions",
self.nodes, DEBUG_MODE)
ret = self.nodes[2].listsinceblock("", 1, False, True)
# pprint.pprint(ret)
mat_block_hash = self.nodes[2].getblockhash(mat_height_d[0])
# first cert is there and its backward transfer to Node2 is mature
# we also have one ordinary output from this cert, and we should have no maturity info
cert = certs_d[0]
found_bwt = False
found_out = False
for x in ret['transactions']:
if x['txid'] == cert:
assert_equal(x['category'], 'receive')
assert_equal(x['blockhash'], blocks_d[0])
if 'isBackwardTransfer' in x:
assert_equal(x['amount'], Decimal('1.02'))
assert_equal(x['isBackwardTransfer'], True)
assert_equal(x['maturityblockhash'], mat_block_hash)
found_bwt = True
else:
assert_false('maturityblockhash' in x)
assert_equal(x['amount'], Decimal('0.001'))
found_out = True
assert_true(found_bwt)
assert_true(found_out)
# cert 2 is there and is immature
# we also have one ordinary output from this cert
cert = certs_d[1]
found_bwt = False
found_out = False
for x in ret['transactions']:
if x['txid'] == cert:
assert_equal(x['blockhash'], blocks_d[1])
if 'isBackwardTransfer' in x:
assert_equal(x['category'], 'immature')
assert_equal(x['amount'], Decimal('2.02'))
assert_equal(x['isBackwardTransfer'], True)
found_bwt = True
else:
assert_equal(x['category'], 'receive')
assert_equal(x['amount'], Decimal('0.002'))
found_out = True
assert_true(found_bwt)
assert_true(found_out)
# last cert is there and is immature
# we also have one ordinary output from this cert
cert = certs_d[2]
found_bwt = False
found_out = False
for x in ret['transactions']:
if x['txid'] == cert:
assert_equal(x['blockhash'], blocks_d[2])
if 'isBackwardTransfer' in x:
assert_equal(x['category'], 'immature')
assert_equal(x['amount'], Decimal('3.02'))
assert_equal(x['isBackwardTransfer'], True)
found_bwt = True
else:
assert_equal(x['category'], 'receive')
assert_equal(x['amount'], Decimal('0.003'))
found_out = True
assert_true(found_bwt)
assert_true(found_out)
# calling the cmd targeting the block where the second certificate has been mined
mark_logs(
"Calling listsinceblock on Node2 for h={}, hash={}".format(
block_heights_d[1], blocks_d[1]), self.nodes, DEBUG_MODE)
ret = self.nodes[2].listsinceblock(blocks_d[1], 1, False, True)
pprint.pprint(ret)
cert = certs_d[0]
# first cert is there, it is mature and it refers to the block where it matured
# we should not see the standard output anymore
mat_block_hash = self.nodes[2].getblockhash(mat_height_d[0])
found = False
for x in ret['transactions']:
if x['txid'] == cert:
found = True
assert_equal(x['amount'], Decimal('1.02'))
assert_equal(x['category'], 'receive')
assert_equal(x['blockhash'], blocks_d[0])
assert_equal(x['maturityblockhash'], mat_block_hash)
assert_equal(x['isBackwardTransfer'], True)
assert_true(found)
# cert 2 is not there (since-block is not part of the range)
cert = certs_d[1]
found = False
for x in ret['transactions']:
if x['txid'] == cert:
found = True
assert_false(found)
# last cert is there and is immature, we have also standard output
cert = certs_d[2]
found_bwt = False
found_out = False
for x in ret['transactions']:
if x['txid'] == cert:
assert_equal(x['blockhash'], blocks_d[2])
if 'isBackwardTransfer' in x:
assert_equal(x['category'], 'immature')
assert_equal(x['amount'], Decimal('3.02'))
assert_equal(x['isBackwardTransfer'], True)
found_bwt = True
else:
assert_equal(x['category'], 'receive')
assert_equal(x['amount'], Decimal('0.003'))
found_out = True
assert_true(found_bwt)
assert_true(found_out)
# calling the cmd targeting the block where the last certificate has been mined
# There must be no certificates at all, since none of them is contained or matures in this block range
mark_logs(
"Calling listsinceblock on Node2 for h={}, hash={}".format(
block_heights_d[2], blocks_d[2]), self.nodes, DEBUG_MODE)
ret = self.nodes[2].listsinceblock(blocks_d[2], 1, False, True)
assert_true(len(ret['transactions']) == 0)
# reach the height of the second certificate and re-issue the command
c = self.nodes[0].getblockcount()
mark_logs("Node 0 generates {} block".format(mat_height_d[1] - c),
self.nodes, DEBUG_MODE)
self.nodes[0].generate(mat_height_d[1] - c)
self.sync_all()
print("chain height = {}".format(self.nodes[0].getblockcount()))
mark_logs(
"Calling listsinceblock on Node2 for h={}, hash={}".format(
block_heights_d[2], blocks_d[2]), self.nodes, DEBUG_MODE)
ret = self.nodes[2].listsinceblock(blocks_d[2], 1, False, True)
cert = certs_d[0]
# first cert is not there
found = False
for x in ret['transactions']:
if x['txid'] == cert:
found = True
assert_false(found)
cert = certs_d[1]
# second cert is there, it is mature and it refers to the block where it matured
found = False
mat_block_hash = self.nodes[2].getblockhash(mat_height_d[1])
for x in ret['transactions']:
if x['txid'] == cert:
found = True
assert_equal(x['amount'], Decimal('2.02'))
assert_equal(x['category'], 'receive')
assert_equal(x['blockhash'], blocks_d[1])
assert_equal(x['maturityblockhash'], mat_block_hash)
assert_equal(x['isBackwardTransfer'], True)
assert_true(found)
cert = certs_d[2]
# last cert is not there
found = False
for x in ret['transactions']:
if x['txid'] == cert:
found = True
assert_false(found)
# get the block before the one containing the last certificate
h = block_heights_d[2] - 1
bl = self.nodes[0].getblockhash(h)
mark_logs(
"Calling listsinceblock on Node2 for h={}, hash={}".format(h, bl),
self.nodes, DEBUG_MODE)
ret = self.nodes[2].listsinceblock(bl, 1, False, True)
# last cert is there and is immature
# we also have one ordinary output from this cert
cert = certs_d[2]
found_bwt = False
found_out = False
for x in ret['transactions']:
if x['txid'] == cert:
assert_equal(x['blockhash'], blocks_d[2])
if 'isBackwardTransfer' in x:
assert_equal(x['category'], 'immature')
assert_equal(x['amount'], Decimal('3.02'))
assert_equal(x['isBackwardTransfer'], True)
found_bwt = True
else:
assert_equal(x['category'], 'receive')
assert_equal(x['amount'], Decimal('0.003'))
found_out = True
assert_true(found_bwt)
assert_true(found_out)
# reach the height of the third certificate, that will make the SC cease, and re-issue the command
c = self.nodes[0].getblockcount()
mark_logs("Node 0 generates {} block".format(mat_height_d[2] - c),
self.nodes, DEBUG_MODE)
self.nodes[0].generate(mat_height_d[2] - c)
self.sync_all()
print("chain height = {}".format(self.nodes[0].getblockcount()))
ret = self.nodes[0].getscinfo(scid, False, False)['items'][0]
assert_equal(ret['ceasingHeight'], mat_height_d[2])
assert_equal(ret['state'], "CEASED")
mark_logs(
"Calling listsinceblock on Node2 for h={}, hash={}".format(h, bl),
self.nodes, DEBUG_MODE)
ret = self.nodes[2].listsinceblock(bl, 1, False, True)
# last cert bwt is not there anymore as expected
# but we still have one ordinary output from this cert
cert = certs_d[2]
found = False
for x in ret['transactions']:
if x['txid'] == cert:
found = True
assert_false('isBackwardTransfer' in x)
assert_equal(x['blockhash'], blocks_d[2])
assert_equal(x['category'], 'receive')
assert_equal(x['amount'], Decimal('0.003'))
assert_true(found)
def run_test(self):
#amounts
creation_amount = Decimal("50")
bwt_amount = Decimal("5")
tAddr1 = self.nodes[1].getnewaddress()
node1Addr = self.nodes[1].validateaddress(tAddr1)['address']
self.nodes[0].generate(MINIMAL_SC_HEIGHT)
self.sync_all()
########### Create the sidechain ##################
print("########### Create the sidechain ##################")
mcTest = CertTestUtils(self.options.tmpdir, self.options.srcdir)
vk = mcTest.generate_params("sc1")
constant = generate_random_field_element_hex()
cmdInput = {
"version": 0,
'withdrawalEpochLength': EPOCH_LENGTH,
'toaddress': "dada",
'amount': creation_amount,
'wCertVk': vk,
'constant': constant
}
ret = self.nodes[0].sc_create(cmdInput)
creating_tx = ret['txid']
scid = ret['scid']
scid_swapped = str(swap_bytes(scid))
self.sync_all()
decoded_tx = self.nodes[0].getrawtransaction(creating_tx, 1)
assert_equal(scid, decoded_tx['vsc_ccout'][0]['scid'])
sc_creation_block_hash = self.nodes[0].generate(1)[0]
sc_creation_block = self.nodes[0].getblock(sc_creation_block_hash)
self.sync_all()
#Advance for 1 Epoch
self.nodes[0].generate(EPOCH_LENGTH)
self.sync_all()
########### Mine Certificate 1 with quality = 5 ##################
print(
"########### Mine Certificate 1 with quality = 5 ##################"
)
epoch_number, epoch_cum_tree_hash = get_epoch_data(
scid, self.nodes[0], EPOCH_LENGTH)
quality = 5
proof = mcTest.create_test_proof("sc1", scid_swapped, epoch_number,
quality, MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash, constant,
[node1Addr], [bwt_amount])
amount_cert_1 = [{"address": node1Addr, "amount": bwt_amount}]
self.nodes[0].sc_send_certificate(scid, epoch_number, quality,
epoch_cum_tree_hash, proof,
amount_cert_1, FT_SC_FEE,
MBTR_SC_FEE, CERT_FEE)
self.sync_all()
maturityHeight = sc_creation_block["height"] + (
EPOCH_LENGTH * 2) + EPOCH_LENGTH * 0.2 - 1
#Add to mempool Certificate 2 with quality = 7
print(
"########### Add to mempool Certificate 2 with quality = 7 ##################"
)
quality = 7
bwt_amount2 = Decimal("7")
proof = mcTest.create_test_proof("sc1", scid_swapped, epoch_number,
quality, MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash, constant,
[node1Addr], [bwt_amount2])
amount_cert_2 = [{"address": node1Addr, "amount": bwt_amount2}]
self.nodes[0].sc_send_certificate(scid, epoch_number, quality,
epoch_cum_tree_hash, proof,
amount_cert_2, FT_SC_FEE,
MBTR_SC_FEE, CERT_FEE)
self.sync_all()
#Mine a block
self.nodes[0].generate(1)
self.sync_all()
#Mine a block with a new Certificate 3 with quality = 8
print(
"########### Mine a block with a new Certificate 3 with quality = 8 ##################"
)
quality = 8
bwt_amount3 = Decimal("7")
proof = mcTest.create_test_proof("sc1", scid_swapped, epoch_number,
quality, MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash, constant,
[node1Addr], [bwt_amount3])
amount_cert_3 = [{"address": node1Addr, "amount": bwt_amount3}]
cert3 = self.nodes[0].sc_send_certificate(scid, epoch_number, quality,
epoch_cum_tree_hash, proof,
amount_cert_3, FT_SC_FEE,
MBTR_SC_FEE, CERT_FEE)
self.sync_all()
cert3_block = self.nodes[0].generate(1)[0]
self.sync_all()
#Advance of 1 epoch
print("########### Advance of 1 epoch ##################")
self.nodes[0].generate(116)
self.sync_all()
epoch_number, epoch_cum_tree_hash = get_epoch_data(
scid, self.nodes[0], EPOCH_LENGTH)
quality = 9
bwt_amount4 = Decimal("9")
proof = mcTest.create_test_proof("sc1", scid_swapped, epoch_number,
quality, MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash, constant,
[node1Addr], [bwt_amount4])
amount_cert_4 = [{"address": node1Addr, "amount": bwt_amount4}]
self.nodes[0].sc_send_certificate(scid, epoch_number, quality,
epoch_cum_tree_hash, proof,
amount_cert_4, FT_SC_FEE,
MBTR_SC_FEE, CERT_FEE)
cert4_block = self.nodes[0].generate(1)[0]
self.sync_all()
#Enter in the next epoch
new_epoch_block = self.nodes[0].generate(1)[0]
self.sync_all()
rpcCertBlock = self.nodes[0].getblock(cert3_block, 2)
cert_3_json = {}
for cert in rpcCertBlock['cert']:
if (cert['txid'] == cert3):
cert_3_json = cert
assert_true(cert_3_json != {})
tipHeight = self.nodes[0].getblockcount()
#Test that we require -maturityheightindex=1 to run the getblockexpanded
try:
self.nodes[1].getblockexpanded("640")
assert (False)
except JSONRPCException as e:
errorString = e.error['message']
print(errorString)
assert ("maturityHeightIndex option not set: can not retrieve info"
in errorString)
#Test that we see the certificate 3 but non the certificate 2 and 1
for i in range(1, tipHeight + 1):
rpcDataByHeight = self.nodes[0].getblockexpanded(str(i))
rpcDataByHeightVerbosity = self.nodes[0].getblockexpanded(
str(i), 2)
rpcDataByHash = self.nodes[0].getblockexpanded(
rpcDataByHeight['hash'])
rpcDataByHashVerbosity = self.nodes[0].getblockexpanded(
rpcDataByHeight['hash'], 2)
if (rpcDataByHash['height'] >= MINIMAL_SC_HEIGHT):
assert_true('matureCertificate' in rpcDataByHash)
assert_true('matureCertificate' in rpcDataByHeight)
assert_true('matureCertificate' in rpcDataByHashVerbosity)
assert_true('matureCertificate' in rpcDataByHeightVerbosity)
if (rpcDataByHash['height'] == int(maturityHeight)):
assert_equal(len(rpcDataByHash['matureCertificate']), 1)
assert_equal(len(rpcDataByHeight['matureCertificate']), 1)
assert_equal(rpcDataByHash['matureCertificate'][0], cert3)
assert_equal(rpcDataByHeight['matureCertificate'][0],
cert3)
assert_equal(
len(rpcDataByHashVerbosity['matureCertificate']), 1)
assert_equal(
len(rpcDataByHeightVerbosity['matureCertificate']), 1)
assert_equal(
rpcDataByHashVerbosity['matureCertificate'][0],
cert_3_json)
assert_equal(
rpcDataByHeightVerbosity['matureCertificate'][0],
cert_3_json)
else:
assert_equal(len(rpcDataByHash['matureCertificate']), 0)
assert_equal(len(rpcDataByHeight['matureCertificate']), 0)
assert_equal(
len(rpcDataByHashVerbosity['matureCertificate']), 0)
assert_equal(
len(rpcDataByHeightVerbosity['matureCertificate']), 0)
else:
assert_false('matureCertificate' in rpcDataByHash)
assert_false('matureCertificate' in rpcDataByHeight)
assert_false('matureCertificate' in rpcDataByHashVerbosity)
assert_false('matureCertificate' in rpcDataByHeightVerbosity)
self.nodes[0].invalidateblock(new_epoch_block)
self.nodes[0].invalidateblock(cert4_block)
self.nodes[1].invalidateblock(new_epoch_block)
self.nodes[1].invalidateblock(cert4_block)
assert_equal(self.nodes[0].getblockcount(), 639)
assert_equal(self.nodes[1].getblockcount(), 639)
self.nodes[0].clearmempool()
self.nodes[1].clearmempool()
assert_equal(len(self.nodes[0].getrawmempool()), 0)
assert_equal(len(self.nodes[1].getrawmempool()), 0)
self.sync_all()
fake_block = self.nodes[0].generate(1)[0]
self.sync_all()
rpcDataByHeight = self.nodes[0].getblockexpanded("640")
rpcDataByHeightVerbosity = self.nodes[0].getblockexpanded("640", 2)
rpcDataByHash = self.nodes[0].getblockexpanded(rpcDataByHeight['hash'])
rpcDataByHashVerbosity = self.nodes[0].getblockexpanded(
rpcDataByHeight['hash'], 2)
assert_equal(len(rpcDataByHash['matureCertificate']), 0)
assert_equal(len(rpcDataByHeight['matureCertificate']), 0)
assert_equal(len(rpcDataByHashVerbosity['matureCertificate']), 0)
assert_equal(len(rpcDataByHeightVerbosity['matureCertificate']), 0)
self.nodes[0].invalidateblock(fake_block)
self.nodes[1].invalidateblock(fake_block)
self.nodes[0].sc_send_certificate(scid, epoch_number, quality,
epoch_cum_tree_hash, proof,
amount_cert_4, FT_SC_FEE,
MBTR_SC_FEE, CERT_FEE)
self.nodes[0].generate(2)
self.sync_all()
rpcDataByHeight = self.nodes[0].getblockexpanded("640")
rpcDataByHeightVerbosity = self.nodes[0].getblockexpanded("640", 2)
rpcDataByHash = self.nodes[0].getblockexpanded(rpcDataByHeight['hash'])
rpcDataByHashVerbosity = self.nodes[0].getblockexpanded(
rpcDataByHeight['hash'], 2)
assert_equal(len(rpcDataByHash['matureCertificate']), 1)
assert_equal(len(rpcDataByHeight['matureCertificate']), 1)
assert_equal(len(rpcDataByHashVerbosity['matureCertificate']), 1)
assert_equal(len(rpcDataByHeightVerbosity['matureCertificate']), 1)
assert_equal(rpcDataByHashVerbosity['matureCertificate'][0],
cert_3_json)
assert_equal(rpcDataByHeightVerbosity['matureCertificate'][0],
cert_3_json)
assert_equal(self.nodes[0].getscinfo(scid)['items'][0]['state'],
"ALIVE")
#Let the sidechain cease
self.nodes[0].generate(130)
self.sync_all()
assert_equal(self.nodes[0].getscinfo(scid)['items'][0]['state'],
"CEASED")
tipHeightCeased = self.nodes[0].getblockcount()
for i in range(tipHeight, tipHeightCeased + 1):
rpcDataByHeight = self.nodes[0].getblockexpanded(str(i))
rpcDataByHeightVerbosity = self.nodes[0].getblockexpanded(
str(i), 2)
rpcDataByHash = self.nodes[0].getblockexpanded(
rpcDataByHeight['hash'])
rpcDataByHashVerbosity = self.nodes[0].getblockexpanded(
rpcDataByHeight['hash'], 2)
assert_equal(len(rpcDataByHash['matureCertificate']), 0)
assert_equal(len(rpcDataByHeight['matureCertificate']), 0)
assert_equal(len(rpcDataByHashVerbosity['matureCertificate']), 0)
assert_equal(len(rpcDataByHeightVerbosity['matureCertificate']), 0)
class sc_block_partitions(BitcoinTestFramework):
alert_filename = None
def setup_chain(self, split=False):
print("Initializing test directory " + self.options.tmpdir)
initialize_chain_clean(self.options.tmpdir, NUMB_OF_NODES)
self.alert_filename = os.path.join(self.options.tmpdir, "alert.txt")
with open(self.alert_filename, 'w'):
pass # Just open then close to create zero-length file
def setup_network(self, split=False):
self.nodes = start_nodes(
NUMB_OF_NODES,
self.options.tmpdir,
extra_args=[[
'-logtimemicros=1', '-debug=py', '-debug=sc', '-debug=mempool',
'-debug=cert', '-debug=bench',
'-blockmaxsize=%d' % TEST_BLOCK_MAX_SIZE,
'-blocktxpartitionmaxsize=%d' %
TEST_BLOCK_TX_PARTITION_MAX_SIZE,
'-blockprioritysize=%d' % TEST_BLOCK_PRIORITY_SIZE,
'-scproofqueuesize=0'
]] * NUMB_OF_NODES)
connect_nodes_bi(self.nodes, 0, 1)
self.is_network_split = split
self.sync_all()
def run_test(self):
'''
Setup a node with a custom size for block size and tx partition size.
Create a SC, advance epoch and create a bunch of certificates with progressive quality and high fee.
Create also a number of txes with lower fee than certs and whose total size exceeds the tx partition size.
- Check that the block is filled by high-fee certs and only the reminder of free space is taken up by txes
- Check that only reserved block partition is occupied despite a greater block size
'''
def create_sc(cmdInput, node):
try:
res = node.sc_create(cmdInput)
tx = res['txid']
scid = res['scid']
except JSONRPCException, e:
errorString = e.error['message']
mark_logs(errorString, self.nodes, DEBUG_MODE)
assert_true(False)
return tx, scid
# network topology: (0)--(1)
print "Miners have max block size = {}, max tx partition size = {}".format(
TEST_BLOCK_MAX_SIZE, TEST_BLOCK_TX_PARTITION_MAX_SIZE)
mark_logs("Node 1 generates {} block".format(100), self.nodes,
DEBUG_MODE)
self.nodes[1].generate(100)
self.sync_all()
mark_logs("Node 0 generates {} block".format(MINIMAL_SC_HEIGHT - 100),
self.nodes, DEBUG_MODE)
self.nodes[0].generate(MINIMAL_SC_HEIGHT - 100)
self.sync_all()
#generate Vks and constant
certMcTest = CertTestUtils(self.options.tmpdir, self.options.srcdir)
certVk = certMcTest.generate_params('scs')
constant = generate_random_field_element_hex()
amount = 1.0
#-------------------------------------------------------
cmdInput = {
'version': 0,
'withdrawalEpochLength': EPOCH_LENGTH,
'amount': amount,
'fee': 0.0001,
'constant': constant,
'wCertVk': certVk,
'toaddress': "cdcd",
}
tx, scid = create_sc(cmdInput, self.nodes[0])
mark_logs("Created SC with scid={} via tx={}".format(scid, tx),
self.nodes, DEBUG_MODE)
self.sync_all()
# advance epoch
self.nodes[0].generate(EPOCH_LENGTH)
self.sync_all()
epoch_number, epoch_cum_tree_hash = get_epoch_data(
scid, self.nodes[0], EPOCH_LENGTH)
mark_logs("Creating certs...", self.nodes, DEBUG_MODE)
proofs = []
q = 10
tot_num_cert = 0
tot_cert_sz = 0
scid_swapped = str(swap_bytes(scid))
while True:
t0 = time.time()
proof = certMcTest.create_test_proof("scs", scid_swapped,
epoch_number,
(q + tot_num_cert),
MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash, constant,
[], [], [])
assert_true(proof != None)
t1 = time.time()
print "...proof generated: {} secs".format(t1 - t0)
proofs.append(proof)
try:
cert = self.nodes[0].sc_send_certificate(
scid, epoch_number, (q + tot_num_cert),
epoch_cum_tree_hash, proof, [], FT_SC_FEE, MBTR_SC_FEE,
CERT_FEE, "", [], [])
except JSONRPCException, e:
errorString = e.error['message']
print "Send certificate failed with reason {}".format(
errorString)
assert (False)
self.sync_all()
tot_num_cert += 1
#mark_logs("cert={}".format(cert), self.nodes, DEBUG_MODE)
hexCert = self.nodes[0].getrawtransaction(cert)
tot_cert_sz += len(hexCert) // 2
#print "sz=", len(hexCert)//2
if tot_cert_sz > TEST_BLOCK_MAX_SIZE:
break
def run_test(self):
'''
This script is useful for the generation of json outputs to be stored in github:
(https://github.com/HorizenOfficial/zen/tree/master/doc/json-examples)
---
System calls to the zen-cli are used (instead for instance of json.dump()) in order to preserve the exact order
of the JSON keys as the one the user gets when sending rpc commands on the console.
---
In order to enable the writing of the cmds output to a file please set the constant WRITE_OUTPUT_TO_FILE to 'True'
and if needed, set the preferred path where to write to, in the constant JSON_FILES_FOLDER_PATH
'''
WRITE_OUTPUT_TO_FILE = False
JSON_FILES_FOLDER_PATH = "../../doc/json-examples/"
def _get_path_info(nodeid, fileName):
node_data_dir = os.path.join(self.options.tmpdir,
"node" + str(nodeid))
node_conf_dir = os.path.join(node_data_dir, "zen.conf")
file_with_path = os.path.join(JSON_FILES_FOLDER_PATH + fileName)
return node_conf_dir, file_with_path
def dump_json_tx(fileName, tx, nodeid=0):
if WRITE_OUTPUT_TO_FILE == False:
return
node_conf_dir, file_with_path = _get_path_info(nodeid, fileName)
hex_tx = self.nodes[nodeid].getrawtransaction(tx)
cmd_ret = subprocess.check_output([
os.getenv("BITCOINCLI", "zen-cli"), "-conf=" + node_conf_dir,
"-rpcwait", "decoderawtransaction",
str(hex_tx).rstrip()
])
with open(file_with_path, 'w') as f:
f.write(cmd_ret)
def dump_json_block(fileName, blockhash, verbose=2, nodeid=0):
if WRITE_OUTPUT_TO_FILE == False:
return
node_conf_dir, file_with_path = _get_path_info(nodeid, fileName)
cmd_ret = subprocess.check_output([
os.getenv("BITCOINCLI", "zen-cli"), "-conf=" + node_conf_dir,
"-rpcwait", "getblock", blockhash,
str(verbose)
])
with open(file_with_path, 'w') as f:
f.write(cmd_ret)
def dump_json_getscinfo(fileName, nodeid=0):
if WRITE_OUTPUT_TO_FILE == False:
return
node_conf_dir, file_with_path = _get_path_info(nodeid, fileName)
cmd_ret = subprocess.check_output([
os.getenv("BITCOINCLI", "zen-cli"), "-conf=" + node_conf_dir,
"-rpcwait", "getscinfo", "*"
])
with open(file_with_path, 'w') as f:
f.write(cmd_ret)
def dump_json_getblocktemplate(fileName, nodeid=0):
if WRITE_OUTPUT_TO_FILE == False:
return
node_conf_dir, file_with_path = _get_path_info(nodeid, fileName)
cmd_ret = subprocess.check_output([
os.getenv("BITCOINCLI", "zen-cli"), "-conf=" + node_conf_dir,
"-rpcwait", "getblocktemplate"
])
with open(file_with_path, 'w') as f:
f.write(cmd_ret)
# network topology: (0)--(1)
mark_logs("Node 1 generates 2 block", self.nodes, DEBUG_MODE)
self.nodes[1].generate(2)
self.sync_all()
mark_logs("Node 0 generates {} block".format(MINIMAL_SC_HEIGHT),
self.nodes, DEBUG_MODE)
self.nodes[0].generate(MINIMAL_SC_HEIGHT)
self.sync_all()
#generate wCertVk and constant
certMcTest = CertTestUtils(self.options.tmpdir, self.options.srcdir)
cswMcTest = CSWTestUtils(self.options.tmpdir, self.options.srcdir)
vk = certMcTest.generate_params('sc1')
cswVk = cswMcTest.generate_params("sc1")
constant1 = generate_random_field_element_hex()
amount = Decimal('10.0')
fee = Decimal('0.000025')
feCfg = []
cmtCfg = []
# all certs must have custom FieldElements with exactly those values as size in bits
feCfg.append([31, 48, 16])
# one custom bv element with:
# - as many bits in the uncompressed form (must be divisible by 254 and 8)
# - a compressed size that allows the usage of BIT_VECTOR_BUF
cmtCfg.append([[254 * 4, len(BIT_VECTOR_BUF) / 2]])
# ascii chars, just for storing a text string
customData = "746869732069732061207465737420737472696e67"
cmdInput = {
'version': 0,
'withdrawalEpochLength': EPOCH_LENGTH,
'amount': amount,
'fee': fee,
'constant': constant1,
'wCertVk': vk,
'toaddress': "cdcd",
'wCeasedVk': cswVk,
'customData': customData,
'vFieldElementCertificateFieldConfig': feCfg[0],
'vBitVectorCertificateFieldConfig': cmtCfg[0],
'forwardTransferScFee': Decimal('0.001'),
'mainchainBackwardTransferScFee': Decimal('0.002'),
'mainchainBackwardTransferRequestDataLength': 2
}
mark_logs(
"\nNode 1 create SC1 with valid vFieldElementCertificateFieldConfig / vBitVectorCertificateFieldConfig pair",
self.nodes, DEBUG_MODE)
try:
res = self.nodes[1].sc_create(cmdInput)
tx = res['txid']
scid1 = res['scid']
scid1_swapped = str(swap_bytes(scid1))
except JSONRPCException as e:
errorString = e.error['message']
mark_logs(errorString, self.nodes, DEBUG_MODE)
assert_true(False)
self.sync_all()
print("tx = {}".format(tx))
dump_json_tx('sidechain-creation-output.json', tx)
# two more SC creations
#-------------------------------------------------------
vk = certMcTest.generate_params("sc2")
constant2 = generate_random_field_element_hex()
customData = "c0ffee"
cswVk = ""
feCfg.append([16])
cmtCfg.append([])
cmdInput = {
'version': 0,
'withdrawalEpochLength': EPOCH_LENGTH,
'toaddress': "dada",
'amount': amount,
'wCertVk': vk,
'customData': customData,
'constant': constant2,
'wCeasedVk': cswVk,
'vFieldElementCertificateFieldConfig': feCfg[1],
'vBitVectorCertificateFieldConfig': cmtCfg[1],
'forwardTransferScFee': 0,
'mainchainBackwardTransferScFee': 0,
'mainchainBackwardTransferRequestDataLength': 1
}
mark_logs(
"\nNode 1 create SC2 with valid vFieldElementCertificateFieldConfig / vBitVectorCertificateFieldConfig pair",
self.nodes, DEBUG_MODE)
try:
ret = self.nodes[1].sc_create(cmdInput)
except JSONRPCException as e:
errorString = e.error['message']
mark_logs(errorString, self.nodes, DEBUG_MODE)
assert_true(False)
self.sync_all()
creating_tx = ret['txid']
scid2 = ret['scid']
scid2_swapped = str(swap_bytes(scid2))
print("tx = {}".format(creating_tx))
decoded_tx = self.nodes[1].getrawtransaction(creating_tx, 1)
dec_sc_id = decoded_tx['vsc_ccout'][0]['scid']
#-------------------------------------------------------
vk = certMcTest.generate_params("sc3")
constant3 = generate_random_field_element_hex()
customData = "badc0ffee"
feCfg.append([])
cmtCfg.append([[254 * 8 * 4, 1967]])
sc_cr = [{
"version": 0,
"epoch_length": EPOCH_LENGTH,
"amount": amount,
"address": "ddaa",
"wCertVk": vk,
"constant": constant3,
"vFieldElementCertificateFieldConfig": feCfg[2],
"vBitVectorCertificateFieldConfig": cmtCfg[2]
}]
mark_logs(
"\nNode 0 create SC3 with valid vFieldElementCertificateFieldConfig / vBitVectorCertificateFieldConfig pair",
self.nodes, DEBUG_MODE)
try:
rawtx = self.nodes[0].createrawtransaction([], {}, [], sc_cr)
funded_tx = self.nodes[0].fundrawtransaction(rawtx)
sigRawtx = self.nodes[0].signrawtransaction(funded_tx['hex'])
creating_tx = self.nodes[0].sendrawtransaction(sigRawtx['hex'])
except JSONRPCException as e:
errorString = e.error['message']
mark_logs(errorString, self.nodes, DEBUG_MODE)
assert_true(False)
self.sync_all()
decoded_tx = self.nodes[0].getrawtransaction(creating_tx, 1)
scid3 = decoded_tx['vsc_ccout'][0]['scid']
print("tx = {}".format(creating_tx))
#-------------------------------------------------------
mark_logs("\nNode 0 generates 1 block confirming SC creations",
self.nodes, DEBUG_MODE)
self.nodes[0].generate(1)
self.sync_all()
# send funds to SC1
amounts = []
fwt_amount_1 = Decimal("2.0")
fwt_amount_2 = Decimal("10.0")
fwt_amount_3 = Decimal("3.0")
fwt_amount_many = fwt_amount_1 + fwt_amount_2 + fwt_amount_3
mark_logs(
"\nNode 0 sends 3 amounts to SC 1 (tot: " + str(fwt_amount_many) +
")", self.nodes, DEBUG_MODE)
mc_return_address1 = self.nodes[0].getnewaddress()
mc_return_address2 = self.nodes[0].getnewaddress()
mc_return_address3 = self.nodes[0].getnewaddress()
amounts.append({
"toaddress": "add1",
"amount": fwt_amount_1,
"scid": scid1,
"mcReturnAddress": mc_return_address1
})
amounts.append({
"toaddress": "add2",
"amount": fwt_amount_2,
"scid": scid2,
"mcReturnAddress": mc_return_address2
})
amounts.append({
"toaddress": "add3",
"amount": fwt_amount_3,
"scid": scid3,
"mcReturnAddress": mc_return_address3
})
tx = self.nodes[0].sc_send(amounts)
self.sync_all()
print("tx = {}".format(tx))
dump_json_tx('forward-transfer-output.json', tx)
# request some mainchain backward transfer
mark_logs("\nNode0 creates a tx with a bwt request", self.nodes,
DEBUG_MODE)
fe1 = generate_random_field_element_hex()
fe2 = generate_random_field_element_hex()
fe3 = generate_random_field_element_hex()
mc_dest_addr0 = self.nodes[0].getnewaddress()
mc_dest_addr1 = self.nodes[1].getnewaddress()
outputs = [{
'vScRequestData': [fe1, fe2],
'scFee': Decimal("0.0025"),
'scid': scid1,
'mcDestinationAddress': mc_dest_addr0
}, {
'vScRequestData': [fe3],
'scFee': Decimal("0.0026"),
'scid': scid2,
'mcDestinationAddress': mc_dest_addr1
}]
cmdParms = {"minconf": 0, "changeaddress": mc_dest_addr0}
try:
tx = self.nodes[0].sc_request_transfer(outputs, cmdParms)
except JSONRPCException as e:
errorString = e.error['message']
mark_logs(errorString, self.nodes, DEBUG_MODE)
assert_true(False)
print("tx = {}".format(tx))
dump_json_tx('mainchain-backward-transfer-request.json', tx)
#-------------------------------------------------------
# advance epoch
mark_logs("\nNode 0 generates {} block".format(EPOCH_LENGTH - 1),
self.nodes, DEBUG_MODE)
self.nodes[0].generate(EPOCH_LENGTH - 1)
self.sync_all()
epoch_number_1, epoch_cum_tree_hash_1 = get_epoch_data(
scid1, self.nodes[0], EPOCH_LENGTH)
mark_logs(
"epoch_number = {}, epoch_cum_tree_hash = {}".format(
epoch_number_1, epoch_cum_tree_hash_1), self.nodes, DEBUG_MODE)
addr_node1a = self.nodes[1].getnewaddress()
addr_node1b = self.nodes[1].getnewaddress()
addr_node0 = self.nodes[1].getnewaddress()
bwt_amount_1 = Decimal("0.2")
bwt_amount_2 = Decimal("0.15")
# get a UTXO
utx, change = get_spendable(self.nodes[0], CERT_FEE)
inputs = [{'txid': utx['txid'], 'vout': utx['vout']}]
outputs = {addr_node0: change}
bwt_outs = [{
"address": addr_node1a,
"amount": bwt_amount_1
}, {
"address": addr_node1b,
"amount": bwt_amount_2
}]
addresses = []
amounts = []
# preserve order for proof validity
for entry in bwt_outs:
addresses.append(entry["address"])
amounts.append(entry["amount"])
#-------------------------------------------------------
mark_logs(
"\nCreate raw cert with good custom field elements for SC2...",
self.nodes, DEBUG_MODE)
# cfgs for SC2: [16], []
# we must be careful with ending bits for having valid fe.
vCfe = ["0100"]
vCmt = []
# serialized fe for the proof has 32 byte size
fe1 = get_field_element_with_padding("0100", 0)
quality = 72
scProof3 = certMcTest.create_test_proof('sc2', scid2_swapped,
epoch_number_1, quality,
MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash_1,
constant2, addresses, amounts,
[fe1])
params = {
'scid': scid2,
'quality': quality,
'endEpochCumScTxCommTreeRoot': epoch_cum_tree_hash_1,
'scProof': scProof3,
'withdrawalEpochNumber': epoch_number_1,
'vFieldElementCertificateField': vCfe,
'vBitVectorCertificateField': vCmt,
'ftScFee': FT_SC_FEE,
'mbtrScFee': MBTR_SC_FEE
}
try:
rawcert = self.nodes[0].createrawcertificate(
inputs, outputs, bwt_outs, params)
signed_cert = self.nodes[0].signrawtransaction(rawcert)
cert = self.nodes[0].sendrawtransaction(signed_cert['hex'])
except JSONRPCException as e:
errorString = e.error['message']
mark_logs(
"Send certificate failed with reason {}".format(errorString),
self.nodes, DEBUG_MODE)
assert (False)
self.sync_all()
print("cert = {}".format(cert))
#-------------------------------------------------------
# get another UTXO
utx, change = get_spendable(self.nodes[0], CERT_FEE)
inputs = [{'txid': utx['txid'], 'vout': utx['vout']}]
outputs = {self.nodes[0].getnewaddress(): change}
mark_logs(
"\nCreate raw cert with good custom field elements for SC1...",
self.nodes, DEBUG_MODE)
# Any number ending with 0x00 is not over module for being a valid field element, therefore it is OK
vCfe = ["ab000100", "ccccdddd0000", "0100"]
# this is a compressed buffer which will yield a valid field element for the proof (see below)
vCmt = [BIT_VECTOR_BUF]
fe1 = get_field_element_with_padding("ab000100", 0)
fe2 = get_field_element_with_padding("ccccdddd0000", 0)
fe3 = get_field_element_with_padding("0100", 0)
fe4 = BIT_VECTOR_FE
quality = 18
scProof3 = certMcTest.create_test_proof('sc1', scid1_swapped,
epoch_number_1, quality,
MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash_1,
constant1, addresses, amounts,
[fe1, fe2, fe3, fe4])
params = {
'scid': scid1,
'quality': quality,
'endEpochCumScTxCommTreeRoot': epoch_cum_tree_hash_1,
'scProof': scProof3,
'withdrawalEpochNumber': epoch_number_1,
'vFieldElementCertificateField': vCfe,
'vBitVectorCertificateField': vCmt,
'ftScFee': FT_SC_FEE,
'mbtrScFee': MBTR_SC_FEE
}
try:
rawcert = self.nodes[0].createrawcertificate(
inputs, outputs, bwt_outs, params)
signed_cert = self.nodes[0].signrawtransaction(rawcert)
cert = self.nodes[0].sendrawtransaction(signed_cert['hex'])
except JSONRPCException as e:
errorString = e.error['message']
mark_logs(
"Send certificate failed with reason {}".format(errorString),
self.nodes, DEBUG_MODE)
assert (False)
self.sync_all()
print("cert = {}".format(cert))
dump_json_tx('certificate-with-backward-transfer.json', cert)
# add a pair of standard txes
self.nodes[0].sendtoaddress(addr_node1a, Decimal('0.1'))
self.nodes[1].sendtoaddress(addr_node0, Decimal('0.2'))
dump_json_getblocktemplate('getblocktemplate.json', nodeid=0)
bl = self.nodes[0].generate(1)[-1]
self.sync_all()
dump_json_block('block-with-certificates.json', bl, 1)
dump_json_block('block-with-certificates-expanded.json', bl, 2)
# advance one epochs for SC1 and let the others cease
mark_logs(
"\nLet 1 epoch pass by and send a cert for SC1 only...".format(
EPOCH_LENGTH), self.nodes, DEBUG_MODE)
cert, epoch_number = advance_epoch(certMcTest, self.nodes[0],
self.sync_all, scid1, "sc1",
constant1, EPOCH_LENGTH, 10,
CERT_FEE, FT_SC_FEE, MBTR_SC_FEE,
vCfe, vCmt, [fe1, fe2, fe3, fe4])
mark_logs(
"\n==> certificate from SC1 for epoch {} {}".format(
epoch_number, cert), self.nodes, DEBUG_MODE)
dump_json_getscinfo('getscinfo-output.json', nodeid=0)
mark_logs("Let also SC1 cease... ".format(scid2), self.nodes,
DEBUG_MODE)
nbl = int(EPOCH_LENGTH * 1.5)
mark_logs("Node0 generates {} blocks".format(nbl), self.nodes,
DEBUG_MODE)
# let all sidechains cease
self.nodes[0].generate(3 * EPOCH_LENGTH)
self.sync_all()
mark_logs(
"\nCreate a CSW for SC1 withdrawing coins for two different addresses... ",
self.nodes, DEBUG_MODE)
# CSW sender MC address
csw_mc_address = self.nodes[0].getnewaddress()
sc_csw_amount_0 = Decimal('2.0')
sc_csw_amount_1 = Decimal('1.0')
null0 = generate_random_field_element_hex()
null1 = generate_random_field_element_hex()
actCertData = self.nodes[0].getactivecertdatahash(
scid1)['certDataHash']
ceasingCumScTxCommTree = self.nodes[0].getceasingcumsccommtreehash(
scid1)['ceasingCumScTxCommTree']
sc_proof0 = cswMcTest.create_test_proof("sc1", sc_csw_amount_0,
scid1_swapped, null0,
csw_mc_address,
ceasingCumScTxCommTree,
actCertData, constant1)
sc_proof1 = cswMcTest.create_test_proof("sc1", sc_csw_amount_1,
scid1_swapped, null1,
csw_mc_address,
ceasingCumScTxCommTree,
actCertData, constant1)
sc_csws = [{
"amount": sc_csw_amount_0,
"senderAddress": csw_mc_address,
"scId": scid1,
"epoch": 0,
"nullifier": null0,
"activeCertData": actCertData,
"ceasingCumScTxCommTree": ceasingCumScTxCommTree,
"scProof": sc_proof0
}, {
"amount": sc_csw_amount_1,
"senderAddress": csw_mc_address,
"scId": scid1,
"epoch": 0,
"nullifier": null1,
"activeCertData": actCertData,
"ceasingCumScTxCommTree": ceasingCumScTxCommTree,
"scProof": sc_proof1
}]
# recipient MC address
taddr_0 = self.nodes[0].getnewaddress()
taddr_1 = self.nodes[1].getnewaddress()
sc_csw_tx_outs = {taddr_0: sc_csw_amount_0, taddr_1: sc_csw_amount_1}
rawtx = self.nodes[0].createrawtransaction([], sc_csw_tx_outs, sc_csws)
funded_tx = self.nodes[0].fundrawtransaction(rawtx)
sigRawtx = self.nodes[0].signrawtransaction(funded_tx['hex'], None,
None, "NONE")
tx = self.nodes[0].sendrawtransaction(sigRawtx['hex'])
mark_logs("sent csw retrieving coins on Node0 and Node1 behalf",
self.nodes, DEBUG_MODE)
self.sync_all()
print("tx = {}".format(tx))
dump_json_tx('ceased-sidechain-withdrawal.json', tx)
class sc_cert_bwt_amount_rounding(BitcoinTestFramework):
alert_filename = None
def setup_chain(self, split=False):
print("Initializing test directory " + self.options.tmpdir)
initialize_chain_clean(self.options.tmpdir, NUMB_OF_NODES)
self.alert_filename = os.path.join(self.options.tmpdir, "alert.txt")
with open(self.alert_filename, 'w'):
pass # Just open then close to create zero-length file
def setup_network(self, split=False):
self.nodes = start_nodes(
NUMB_OF_NODES,
self.options.tmpdir,
extra_args=[[
'-logtimemicros=1', '-debug=py', '-debug=sc', '-debug=mempool',
'-debug=cert', '-debug=bench', '-scproofqueuesize=0'
]] * NUMB_OF_NODES)
connect_nodes_bi(self.nodes, 0, 1)
self.is_network_split = split
self.sync_all()
def run_test(self):
def create_sc(cmdInput, node):
try:
res = node.sc_create(cmdInput)
tx = res['txid']
scid = res['scid']
except JSONRPCException, e:
errorString = e.error['message']
mark_logs(errorString, self.nodes, DEBUG_MODE)
assert_true(False)
return tx, scid
'''
Purpose of this test is to verify that a decimal amount with many decimal digits is correctly handled, expecially
with reference to the compatibility between creation and verification of the proof, which are performed by the test
framework and the zend_oo core implementations.
'''
# network topology: (0)--(1)
mark_logs("Node 1 generates {} block".format(2), self.nodes,
DEBUG_MODE)
self.nodes[1].generate(2)
self.sync_all()
mark_logs("Node 0 generates {} block".format(MINIMAL_SC_HEIGHT),
self.nodes, DEBUG_MODE)
self.nodes[0].generate(MINIMAL_SC_HEIGHT - 2)
self.sync_all()
#generate Vks and constant
certMcTest = CertTestUtils(self.options.tmpdir, self.options.srcdir)
certVk = certMcTest.generate_params('scs')
constant = generate_random_field_element_hex()
cr_amount = 1000.0
#-------------------------------------------------------
fee = 0.000025
cmdInput = {
'version': 0,
'withdrawalEpochLength': EPOCH_LENGTH,
'amount': cr_amount,
'fee': fee,
'constant': constant,
'wCertVk': certVk,
'toaddress': "cdcd"
}
tx, scid = create_sc(cmdInput, self.nodes[0])
mark_logs("Created SC with scid={} via tx={}".format(scid, tx),
self.nodes, DEBUG_MODE)
self.sync_all()
hexTx = self.nodes[0].getrawtransaction(tx)
print "sz=", len(hexTx) // 2
# advance epoch
self.nodes[0].generate(EPOCH_LENGTH)
self.sync_all()
epoch_number, epoch_cum_tree_hash = get_epoch_data(
scid, self.nodes[0], EPOCH_LENGTH)
NUM_OF_BWT = 1
print "==============================================================================================================================================================================="
print "Adding {} backward transfers to certificate".format(NUM_OF_BWT)
print "==============================================================================================================================================================================="
bwt_amount = Decimal('1.952929687000111')
print "bwt amount {}".format(bwt_amount)
bwt_cert = []
addr_array = []
bwt_amount_array = []
proof = None
addr_node1 = self.nodes[1].getnewaddress()
for _ in range(0, NUM_OF_BWT):
addr_array.append(addr_node1)
bwt_amount_array.append(bwt_amount)
entry = {"address": addr_node1, "amount": bwt_amount}
bwt_cert.append(entry)
pprint.pprint(entry)
print "Generating cert proof..."
t0 = time.time()
q = 10
scid_swapped = str(swap_bytes(scid))
print "---------------------"
proof = certMcTest.create_test_proof("scs", scid_swapped, epoch_number,
q, MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash, constant,
addr_array, bwt_amount_array)
assert_true(proof != None)
t1 = time.time()
print "...proof with sz={} generated: {} secs".format(
len(proof) // 2, t1 - t0)
try:
cert = self.nodes[0].sc_send_certificate(scid, epoch_number, q,
epoch_cum_tree_hash,
proof, bwt_cert,
FT_SC_FEE, MBTR_SC_FEE,
CERT_FEE)
except JSONRPCException, e:
errorString = e.error['message']
print "Send certificate failed with reason {}".format(errorString)
assert (False)
def run_test(self):
'''
The test checks that the "GetBlockTemplate" command correctly detects a new certificate in the mempool,
in the same way as it happens for normal transactions.
'''
# amounts
creation_amount = Decimal("10")
bwt_amount = Decimal("1.0")
mark_logs("Node 0 generates {} block".format(MINIMAL_SC_HEIGHT),
self.nodes, DEBUG_MODE)
self.nodes[0].generate(MINIMAL_SC_HEIGHT)
self.sync_all()
#generate wCertVk and constant
mcTest = CertTestUtils(self.options.tmpdir, self.options.srcdir)
vk = mcTest.generate_params("sc1")
constant = generate_random_field_element_hex()
cmdInput = {
"version": 0,
"withdrawalEpochLength": EPOCH_LENGTH,
"toaddress": "dada",
"amount": creation_amount,
"wCertVk": vk,
"constant": constant,
}
ret = self.nodes[0].sc_create(cmdInput)
scid = ret['scid']
scid_swapped = str(swap_bytes(scid))
mark_logs("Node 0 created a SC", self.nodes, DEBUG_MODE)
nblocks = EPOCH_LENGTH
mark_logs(
"Node 0 generating {} more blocks to confirm the sidechain and reach the end of withdrawal epoch"
.format(nblocks), self.nodes, DEBUG_MODE)
self.nodes[0].generate(nblocks)
self.sync_all()
epoch_number, epoch_cum_tree_hash = get_epoch_data(
scid, self.nodes[0], EPOCH_LENGTH)
addr_node1 = self.nodes[1].getnewaddress()
#Create proof for WCert
quality = 10
proof = mcTest.create_test_proof("sc1", scid_swapped, epoch_number,
quality, MBTR_SC_FEE, FT_SC_FEE,
epoch_cum_tree_hash, constant,
[addr_node1], [bwt_amount])
amount_cert_1 = [{"address": addr_node1, "amount": bwt_amount}]
cur_h = self.nodes[0].getblockcount()
ret = self.nodes[0].getscinfo(scid, True, False)['items'][0]
ceas_h = ret['ceasingHeight']
ceas_limit_delta = ceas_h - cur_h - 1
mark_logs(
"Node0 generating {} blocks reaching the third to last block before the SC ceasing"
.format(ceas_limit_delta), self.nodes, DEBUG_MODE)
self.nodes[0].generate(ceas_limit_delta - 2)
self.sync_all()
mark_logs(
"\nCall GetBlockTemplate on each node to create a cached (empty) version",
self.nodes, DEBUG_MODE)
for i in range(0, NUMB_OF_NODES):
self.nodes[i].getblocktemplate()
mark_logs(
"Node 0 sends a normal mainchain transaction to mempool and checks that it's not immediately included into the block template",
self.nodes, DEBUG_MODE)
self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 0.1)
self.sync_all()
for i in range(0, NUMB_OF_NODES):
assert (len(self.nodes[i].getblocktemplate()['certificates']) == 0)
assert (len(self.nodes[i].getblocktemplate()['transactions']) == 0)
GET_BLOCK_TEMPLATE_DELAY = 5 # Seconds
mark_logs(
"Wait {} seconds and check that the transaction is now included into the block template"
.format(GET_BLOCK_TEMPLATE_DELAY), self.nodes, DEBUG_MODE)
time.sleep(GET_BLOCK_TEMPLATE_DELAY)
for i in range(0, NUMB_OF_NODES):
assert (len(self.nodes[i].getblocktemplate()['certificates']) == 0)
assert (len(self.nodes[i].getblocktemplate()['transactions']) == 1)
mark_logs("Node 0 mines one block to clean the mempool", self.nodes,
DEBUG_MODE)
self.nodes[0].generate(1)
self.sync_all()
mark_logs(
"\nCall GetBlockTemplate on each node to create a new cached version",
self.nodes, DEBUG_MODE)
for i in range(0, NUMB_OF_NODES):
self.nodes[i].getblocktemplate()
mark_logs("Node 0 sends a certificate", self.nodes, DEBUG_MODE)
try:
cert_epoch_0 = self.nodes[0].sc_send_certificate(
scid, epoch_number, quality, epoch_cum_tree_hash, proof,
amount_cert_1, FT_SC_FEE, MBTR_SC_FEE, CERT_FEE)
assert (len(cert_epoch_0) > 0)
except JSONRPCException, e:
errorString = e.error['message']
mark_logs(
"Send certificate failed with reason {}".format(errorString),
self.nodes, DEBUG_MODE)
assert (False)
actCertData1 = self.nodes[0].getactivecertdatahash(
scid1)['certDataHash']
actCertData2 = self.nodes[0].getactivecertdatahash(
scid2)['certDataHash']
ceasingCumScTxCommTree1 = self.nodes[0].getceasingcumsccommtreehash(
scid1)['ceasingCumScTxCommTree']
ceasingCumScTxCommTree2 = self.nodes[0].getceasingcumsccommtreehash(
scid2)['ceasingCumScTxCommTree']
scid1_swapped = swap_bytes(scid1)
scid2_swapped = swap_bytes(scid2)
for i in range(MAX_NUM_OF_CSW_INPUTS_PER_SC + 1):
nullifiers1.append(generate_random_field_element_hex())
nullifiers2.append(generate_random_field_element_hex())
csw_proofs1.append(
cswMcTest.create_test_proof("sc1", sc_csw_amount,
str(scid1_swapped), nullifiers1[i],
csw_mc_address,
ceasingCumScTxCommTree1,
actCertData1, constant1))
csw_proofs2.append(
cswMcTest.create_test_proof("sc2", sc_csw_amount,
str(scid2_swapped), nullifiers2[i],
csw_mc_address,
ceasingCumScTxCommTree2,
actCertData2, constant2))
def run_test(self):
'''
Create a SC, advance two epochs and then let it cease.
Create two transactions, each one containing a CSW with
an input value covering the whole sidechain balance.
Even though the first CSW transaction is still in mempool,
the second one should be rejected.
'''
# prepare some coins
self.nodes[0].generate(MINIMAL_SC_HEIGHT)
self.sync_all()
sc_address = "0000000000000000000000000000000000000000000000000000000000000abc"
sc_epoch_len = EPOCH_LENGTH
sc_cr_amount = Decimal('12.00000000')
certMcTest = CertTestUtils(self.options.tmpdir, self.options.srcdir)
cswMcTest = CSWTestUtils(self.options.tmpdir, self.options.srcdir)
# generate wCertVk and constant
vk = certMcTest.generate_params("sc1")
cswVk = cswMcTest.generate_params("sc1")
constant = generate_random_field_element_hex()
sc_cr = []
sc_cr.append({
"version": 0,
"epoch_length": sc_epoch_len,
"amount": sc_cr_amount,
"address": sc_address,
"wCertVk": vk,
"wCeasedVk": cswVk,
"constant": constant
})
rawtx = self.nodes[0].createrawtransaction([], {}, [], sc_cr)
funded_tx = self.nodes[0].fundrawtransaction(rawtx)
sigRawtx = self.nodes[0].signrawtransaction(funded_tx['hex'])
finalRawtx = self.nodes[0].sendrawtransaction(sigRawtx['hex'])
self.sync_all()
decoded_tx = self.nodes[2].getrawtransaction(finalRawtx, 1)
scid = decoded_tx['vsc_ccout'][0]['scid']
mark_logs("created SC id: {}".format(scid), self.nodes, DEBUG_MODE)
print
# advance two epochs
mark_logs("\nLet 2 epochs pass by...", self.nodes, DEBUG_MODE)
cert, epoch_number = advance_epoch(certMcTest, self.nodes[0],
self.sync_all, scid, "sc1",
constant, sc_epoch_len)
mark_logs(
"\n==> certificate for epoch {} {}".format(epoch_number, cert),
self.nodes, DEBUG_MODE)
cert, epoch_number = advance_epoch(certMcTest, self.nodes[0],
self.sync_all, scid, "sc1",
constant, sc_epoch_len)
mark_logs(
"\n==> certificate for epoch {} {}l".format(epoch_number, cert),
self.nodes, DEBUG_MODE)
# mine one block for having last cert in chain
mark_logs("\nNode0 generates 1 block confirming last cert", self.nodes,
DEBUG_MODE)
self.nodes[0].generate(1)
self.sync_all()
mark_logs("Let SC cease... ", self.nodes, DEBUG_MODE)
nbl = int(sc_epoch_len * 1.5)
mark_logs("Node0 generates {} blocks".format(nbl), self.nodes,
DEBUG_MODE)
self.nodes[0].generate(nbl)
self.sync_all()
# check it is really ceased
ret = self.nodes[0].getscinfo(scid, False, False)['items'][0]
assert_equal(ret['state'], "CEASED")
# and has the expected balance
sc_bal = self.nodes[0].getscinfo(scid, False,
False)['items'][0]['balance']
assert_equal(sc_bal, sc_cr_amount)
mark_logs("\nCreate a CSW withdrawing 90% of the sc balance... ",
self.nodes, DEBUG_MODE)
# CSW sender MC address
csw_mc_address = self.nodes[0].getnewaddress()
sc_csw_amount = sc_bal * Decimal("0.9")
null1 = generate_random_field_element_hex()
actCertData = self.nodes[0].getactivecertdatahash(scid)['certDataHash']
print "Active Cert Data Hash: -------> ", actCertData
ceasingCumScTxCommTree = self.nodes[0].getceasingcumsccommtreehash(
scid)['ceasingCumScTxCommTree']
scid_swapped = swap_bytes(scid)
sc_proof1 = cswMcTest.create_test_proof("sc1", sc_csw_amount,
str(scid_swapped), null1,
csw_mc_address,
ceasingCumScTxCommTree,
actCertData, constant)
sc_csws = [{
"amount": sc_csw_amount,
"senderAddress": csw_mc_address,
"scId": scid,
"epoch": 0,
"nullifier": null1,
"activeCertData": actCertData,
"ceasingCumScTxCommTree": ceasingCumScTxCommTree,
"scProof": sc_proof1
}]
# recipient MC address
taddr_2 = self.nodes[2].getnewaddress()
sc_csw_tx_outs = {taddr_2: sc_csw_amount}
rawtx = self.nodes[0].createrawtransaction([], sc_csw_tx_outs, sc_csws)
funded_tx = self.nodes[0].fundrawtransaction(rawtx)
sigRawtx = self.nodes[0].signrawtransaction(funded_tx['hex'], None,
None, "NONE")
finalRawtx = self.nodes[0].sendrawtransaction(sigRawtx['hex'])
mark_logs(
"sent csw 1 {} retrieving {} coins on Node2 behalf".format(
finalRawtx, sc_csws[0]['amount']), self.nodes, DEBUG_MODE)
self.sync_all()
mark_logs("Check csw is in mempool...", self.nodes, DEBUG_MODE)
assert_true(finalRawtx in self.nodes[2].getrawmempool())
mark_logs(
"\nCreate a second CSW withdrawing 90% of the sc balance (should be rejected)... ",
self.nodes, DEBUG_MODE)
# CSW sender MC address
csw_mc_address = self.nodes[0].getnewaddress()
sc_csw_amount = sc_bal * Decimal("0.9")
null1 = generate_random_field_element_hex()
sc_proof1 = cswMcTest.create_test_proof("sc1", sc_csw_amount,
str(scid_swapped), null1,
csw_mc_address,
ceasingCumScTxCommTree,
actCertData, constant)
sc_csws = [{
"amount": sc_csw_amount,
"senderAddress": csw_mc_address,
"scId": scid,
"epoch": 0,
"nullifier": null1,
"activeCertData": actCertData,
"ceasingCumScTxCommTree": ceasingCumScTxCommTree,
"scProof": sc_proof1
}]
# recipient MC address
taddr_2 = self.nodes[2].getnewaddress()
sc_csw_tx_outs = {taddr_2: sc_csw_amount}
rawtx = self.nodes[0].createrawtransaction([], sc_csw_tx_outs, sc_csws)
funded_tx = self.nodes[0].fundrawtransaction(rawtx)
sigRawtx = self.nodes[0].signrawtransaction(funded_tx['hex'], None,
None, "NONE")
try:
finalRawtx = self.nodes[0].sendrawtransaction(sigRawtx['hex'])
assert (False)
except JSONRPCException, e:
error_string = e.error['message']
mark_logs(
"Failed sending csw 2 {} retrieving {} coins on Node2 behalf, error message: {}"
.format(finalRawtx, sc_csws[0]['amount'],
error_string), self.nodes, DEBUG_MODE)
assert_true("bad-sc-tx-not-applicable" in error_string)
# Check the sidechain has the expected balance
sc_bal = self.nodes[0].getscinfo(scid, False,
False)['items'][0]['balance']
assert_equal(sc_bal, sc_cr_amount)
# create a tx with 3 CSW for sc
mark_logs(
"\nCreate 3 CSWs in a tx withdrawing half the sc balance... ",
self.nodes, DEBUG_MODE)
# CSW sender MC address, in taddress and pub key hash formats
csw_mc_address = self.nodes[0].getnewaddress()
sc_csw_amount = (sc_bal / 2) / 3
null_1 = generate_random_field_element_hex()
null_2 = generate_random_field_element_hex()
null_3 = generate_random_field_element_hex()
act_cert_data = self.nodes[0].getactivecertdatahash(
scid)['certDataHash']
ceasing_cum_cc_tx_comm_tree = self.nodes[
0].getceasingcumsccommtreehash(scid)['ceasingCumScTxCommTree']
pprint.pprint(act_cert_data)
sc_proof_1 = csw_mc_test.create_test_proof(
"sc", sc_csw_amount, str(scid_swapped), null_1, csw_mc_address,
ceasing_cum_cc_tx_comm_tree, act_cert_data, constant)
sc_proof_2 = csw_mc_test.create_test_proof(
"sc", sc_csw_amount, str(scid_swapped), null_2, csw_mc_address,
ceasing_cum_cc_tx_comm_tree, act_cert_data, constant)