diff --git a/qa/rpc-tests/cryptoconditions.py b/qa/rpc-tests/cryptoconditions.py index 1d2f68777..ee119b75a 100755 --- a/qa/rpc-tests/cryptoconditions.py +++ b/qa/rpc-tests/cryptoconditions.py @@ -30,7 +30,7 @@ class CryptoConditionsTest (BitcoinTestFramework): def setup_chain(self): print("Initializing CC test directory "+self.options.tmpdir) - self.num_nodes = 1 + self.num_nodes = 2 initialize_chain_clean(self.options.tmpdir, self.num_nodes) def setup_network(self, split = False): @@ -38,9 +38,12 @@ class CryptoConditionsTest (BitcoinTestFramework): self.addr = "RWPg8B91kfK5UtUN7z6s6TeV9cHSGtVY8D" self.pubkey = "02676d00110c2cd14ae24f95969e8598f7ccfaa675498b82654a5b5bd57fc1d8cf" self.privkey = "UqMgxk7ySPNQ4r9nKAFPjkXy6r5t898yhuNCjSZJLg3RAM4WW1m9" + self.addr1 = "RXEXoa1nRmKhMbuZovpcYwQMsicwzccZBp" + self.pubkey1 = "024026d4ad4ecfc1f705a9b42ca64af6d2ad947509c085534a30b8861d756c6ff0" + self.privkey1 = "UtdydP56pGTFmawHzHr1wDrc4oUwCNW1ttX8Pc3KrvH3MA8P49Wi" self.nodes = start_nodes(self.num_nodes, self.options.tmpdir, extra_args=[[ - # always give -ac_name as first extra_arg + # always give -ac_name as first extra_arg and port as third '-ac_name=REGTEST', '-conf='+self.options.tmpdir+'/node0/REGTEST.conf', '-port=64367', @@ -49,30 +52,49 @@ class CryptoConditionsTest (BitcoinTestFramework): '-addressindex=1', '-spentindex=1', '-ac_supply=5555555', - '-ac_reward=10000000', + '-ac_reward=10000000000000', '-pubkey=' + self.pubkey, '-ac_cc=2', '-whitelist=127.0.0.1', '-debug', - '-daemon', + '--daemon', '-rpcuser=rt', '-rpcpassword=rt' - ]] + ], + ['-ac_name=REGTEST', + '-conf='+self.options.tmpdir+'/node1/REGTEST.conf', + '-port=64365', + '-rpcport=64366', + '-regtest', + '-addressindex=1', + '-spentindex=1', + '-ac_supply=5555555', + '-ac_reward=10000000000000', + '-pubkey=' + self.pubkey1, + '-ac_cc=2', + '-whitelist=127.0.0.1', + '-debug', + '-addnode=127.0.0.1:64367', + '--daemon', + '-rpcuser=rt', + '-rpcpassword=rt']] ) self.is_network_split = split self.rpc = self.nodes[0] + self.rpc1 = self.nodes[1] self.sync_all() print("Done setting up network") - def send_and_mine(self, xtn): - txid = self.rpc.sendrawtransaction(xtn) + def send_and_mine(self, xtn, rpc_connection): + txid = rpc_connection.sendrawtransaction(xtn) assert txid, 'got txid' # we need the tx above to be confirmed in the next block - self.rpc.generate(1) + rpc_connection.generate(1) return txid def run_faucet_tests(self): rpc = self.rpc + rpc1 = self.rpc1 # basic sanity tests result = rpc.getwalletinfo() @@ -117,9 +139,11 @@ class CryptoConditionsTest (BitcoinTestFramework): # we need the tx above to be confirmed in the next block rpc.generate(1) + self.sync_all() result = rpc.getwalletinfo() - balance2 = result['balance'] + # minus one block reward + balance2 = result['balance'] - 100000 # make sure our balance is less now assert_greater_than(balance, balance2) @@ -127,21 +151,31 @@ class CryptoConditionsTest (BitcoinTestFramework): assert_success(result) assert_greater_than( result['funding'], 0 ) - result = rpc.faucetget() - assert_success(result) - assert result['hex'], "hex key found" + # claiming faucet on second node + faucetgethex = rpc1.faucetget() + assert_success(faucetgethex) + assert faucetgethex['hex'], "hex key found" - # try to broadcast the xtn, but we will get 'faucet is only for brand new addresses' - assert_raises(JSONRPCException, rpc.sendrawtransaction, [ result['hex'] ]) + balance1 = rpc1.getwalletinfo()['balance'] - newaddr = rpc.getnewaddress() - assert newaddr, "got a new address" - result = rpc.validateaddress(newaddr) - newpubkey = result['pubkey'] - assert newpubkey, "got a pubkey for new address" + # try to broadcast the faucetget transaction + result = self.send_and_mine(faucetgethex['hex'], rpc1) + assert txid, "transaction broadcasted" + + balance2 = rpc1.getwalletinfo()['balance'] + assert_greater_than(balance2, balance1) + + self.sync_all() def run_dice_tests(self): rpc = self.nodes[0] + rpc1 = self.nodes[1] + self.sync_all() + + # have to generate few blocks on second node to be able to place bets + rpc1.generate(10) + result = rpc1.getbalance() + assert_greater_than(result, 100000) dice = rpc.diceaddress() assert_equal(dice['result'], 'success') @@ -171,7 +205,7 @@ class CryptoConditionsTest (BitcoinTestFramework): # creating dice plan dicefundtx = rpc.dicefund("LUCKY","1000","1","800","10","5") - diceid = self.send_and_mine(dicefundtx['hex']) + diceid = self.send_and_mine(dicefundtx['hex'], rpc) # checking if it in plans list now result = rpc.dicelist() @@ -190,7 +224,7 @@ class CryptoConditionsTest (BitcoinTestFramework): # adding funds to plan addfundstx = rpc.diceaddfunds(dicename,diceid,"1100") - result = self.send_and_mine(addfundstx['hex']) + result = self.send_and_mine(addfundstx['hex'], rpc) # checking if funds added to plan result = rpc.diceinfo(diceid) @@ -201,92 +235,99 @@ class CryptoConditionsTest (BitcoinTestFramework): assert_error(result) # placing 0 amount bet - result = rpc.dicebet(dicename,diceid,"0","1") + result = rpc1.dicebet(dicename,diceid,"0","2") assert_error(result) # placing negative amount bet - result = rpc.dicebet(dicename,diceid,"-1","1") + result = rpc1.dicebet(dicename,diceid,"-1","2") assert_error(result) # placing bet more than maxbet - result = rpc.dicebet(dicename,diceid,"900","1") + result = rpc1.dicebet(dicename,diceid,"900","2") assert_error(result) # placing bet with amount more than funding - result = rpc.dicebet(dicename,diceid,"3000","1") + result = rpc1.dicebet(dicename,diceid,"3000","2") assert_error(result) # placing bet with potential won more than funding - result = rpc.dicebet(dicename,diceid,"750","9") + result = rpc1.dicebet(dicename,diceid,"750","9") assert_error(result) # placing 0 odds bet - result = rpc.dicebet(dicename,diceid,"1","0") + result = rpc1.dicebet(dicename,diceid,"1","0") assert_error(result) # placing negative odds bet - result = rpc.dicebet(dicename,diceid,"1","-1") + result = rpc1.dicebet(dicename,diceid,"1","-1") assert_error(result) # placing bet with odds more than allowed - result = rpc.dicebet(dicename,diceid,"1","11") + result = rpc1.dicebet(dicename,diceid,"1","11") assert_error(result) # placing bet with not correct dice name - result = rpc.dicebet("nope",diceid,"100","1") + result = rpc1.dicebet("nope",diceid,"100","2") assert_error(result) # placing bet with not correct dice id - result = rpc.dicebet(dicename,self.pubkey,"100","1") + result = rpc1.dicebet(dicename,self.pubkey,"100","2") assert_error(result) - # valid bet placing - placebet = rpc.dicebet(dicename,diceid,"100","1") - betid = self.send_and_mine(placebet["hex"]) - assert result, "bet placed" - - # check bet status - result = rpc.dicestatus(dicename,diceid,betid) - assert_success(result) - # have to make some entropy for the next test entropytx = 0 fundingsum = 1 - while entropytx < 10: + while entropytx < 110: fundingsuminput = str(fundingsum) fundinghex = rpc.diceaddfunds(dicename,diceid,fundingsuminput) - result = self.send_and_mine(fundinghex['hex']) + result = self.send_and_mine(fundinghex['hex'], rpc) entropytx = entropytx + 1 fundingsum = fundingsum + 1 rpc.generate(2) + self.sync_all() + + # valid bet placing + placebet = rpc1.dicebet(dicename,diceid,"100","2") + betid = self.send_and_mine(placebet["hex"], rpc1) + assert result, "bet placed" + + # check bet status + result = rpc1.dicestatus(dicename,diceid,betid) + assert_success(result) # note initial dice funding state at this point. # TODO: track player balance somehow (hard to do because of mining and fees) diceinfo = rpc.diceinfo(diceid) funding = float(diceinfo['funding']) - # placing same amount bets with amount 1 and odds 1:2, checking if balance changed correct - losscounter = 0 - wincounter = 0 - betcounter = 0 - - while (betcounter < 10): - placebet = rpc.dicebet(dicename,diceid,"1","1") - betid = self.send_and_mine(placebet["hex"]) - finish = rpc.dicefinish(dicename,diceid,betid) - self.send_and_mine(finish["hex"]) - betresult = rpc.dicestatus(dicename,diceid,betid) - betcounter = betcounter + 1 - if betresult["status"] == "loss": - losscounter = losscounter + 1 - elif betresult["status"] == "win": - wincounter = wincounter + 1 - - # funding balance should increase if player loss, decrease if player won - fundbalanceguess = funding + losscounter - wincounter - fundinfoactual = rpc.diceinfo(diceid) - assert_equal(round(fundbalanceguess),round(float(fundinfoactual['funding']))) + # # placing same amount bets with amount 1 and odds 1:3, checking if balance changed correct + # losscounter = 0 + # wincounter = 0 + # betcounter = 0 + # + # while (betcounter < 10): + # placebet = rpc1.dicebet(dicename,diceid,"1","2") + # betid = self.send_and_mine(placebet["hex"], rpc1) + # time.sleep(3) + # self.sync_all() + # finish = rpc.dicefinish(dicename,diceid,betid) + # self.send_and_mine(finish["hex"], rpc1) + # self.sync_all() + # time.sleep(3) + # betresult = rpc1.dicestatus(dicename,diceid,betid) + # betcounter = betcounter + 1 + # if betresult["status"] == "loss": + # losscounter = losscounter + 1 + # elif betresult["status"] == "win": + # wincounter = wincounter + 1 + # else: + # pass + # + # # funding balance should increase if player loss, decrease if player won + # fundbalanceguess = funding + losscounter - wincounter * 2 + # fundinfoactual = rpc.diceinfo(diceid) + # assert_equal(round(fundbalanceguess),round(float(fundinfoactual['funding']))) def run_token_tests(self): rpc = self.nodes[0] @@ -315,7 +356,7 @@ class CryptoConditionsTest (BitcoinTestFramework): result = rpc.tokencreate("DUKE", "1987.420", "Duke's custom token") assert_success(result) - tokenid = self.send_and_mine(result['hex']) + tokenid = self.send_and_mine(result['hex'], rpc) result = rpc.tokenlist() assert_equal(result[0], tokenid) @@ -379,7 +420,7 @@ class CryptoConditionsTest (BitcoinTestFramework): # valid ask tokenask = rpc.tokenask("100", tokenid, "7.77") tokenaskhex = tokenask['hex'] - tokenaskid = self.send_and_mine(tokenask['hex']) + tokenaskid = self.send_and_mine(tokenask['hex'], rpc) result = rpc.tokenorders() order = result[0] assert order, "found order" @@ -394,7 +435,7 @@ class CryptoConditionsTest (BitcoinTestFramework): # valid ask fillunits fillask = rpc.tokenfillask(tokenid, tokenaskid, "777") - result = self.send_and_mine(fillask['hex']) + result = self.send_and_mine(fillask['hex'], rpc) txid = result[0] assert txid, "found txid" @@ -404,9 +445,9 @@ class CryptoConditionsTest (BitcoinTestFramework): # checking ask cancellation testorder = rpc.tokenask("100", tokenid, "7.77") - testorderid = self.send_and_mine(testorder['hex']) + testorderid = self.send_and_mine(testorder['hex'], rpc) cancel = rpc.tokencancelask(tokenid, testorderid) - self.send_and_mine(cancel["hex"]) + self.send_and_mine(cancel["hex"], rpc) result = rpc.tokenorders() assert_equal(result, []) @@ -432,7 +473,7 @@ class CryptoConditionsTest (BitcoinTestFramework): tokenbid = rpc.tokenbid("100", tokenid, "10") tokenbidhex = tokenbid['hex'] - tokenbidid = self.send_and_mine(tokenbid['hex']) + tokenbidid = self.send_and_mine(tokenbid['hex'], rpc) result = rpc.tokenorders() order = result[0] assert order, "found order" @@ -447,7 +488,7 @@ class CryptoConditionsTest (BitcoinTestFramework): # valid bid fillunits fillbid = rpc.tokenfillbid(tokenid, tokenbidid, "1000") - result = self.send_and_mine(fillbid['hex']) + result = self.send_and_mine(fillbid['hex'], rpc) txid = result[0] assert txid, "found txid" @@ -457,9 +498,9 @@ class CryptoConditionsTest (BitcoinTestFramework): # checking bid cancellation testorder = rpc.tokenbid("100", tokenid, "7.77") - testorderid = self.send_and_mine(testorder['hex']) + testorderid = self.send_and_mine(testorder['hex'], rpc) cancel = rpc.tokencancelbid(tokenid, testorderid) - self.send_and_mine(cancel["hex"]) + self.send_and_mine(cancel["hex"], rpc) result = rpc.tokenorders() assert_equal(result, []) @@ -474,7 +515,7 @@ class CryptoConditionsTest (BitcoinTestFramework): # valid token transfer sendtokens = rpc.tokentransfer(tokenid,randompubkey,"1") - self.send_and_mine(sendtokens["hex"]) + self.send_and_mine(sendtokens["hex"], rpc) result = rpc.tokenbalance(tokenid,randompubkey) assert_equal(result["balance"], 1) @@ -548,7 +589,7 @@ class CryptoConditionsTest (BitcoinTestFramework): # adding valid funding result = rpc.rewardsaddfunding("STUFF", fundingtxid, "555") - addfundingtxid = self.send_and_mine(result['hex']) + addfundingtxid = self.send_and_mine(result['hex'], rpc) assert addfundingtxid, 'got funding txid' # checking if funding added to rewardsplan @@ -590,6 +631,10 @@ class CryptoConditionsTest (BitcoinTestFramework): def run_oracles_tests(self): rpc = self.nodes[0] + rpc1 = self.nodes[1] + + result = rpc1.oraclesaddress() + result = rpc.oraclesaddress() assert_success(result) for x in ['OraclesCCaddress', 'Oraclesmarker', 'myCCaddress', 'myaddress']: @@ -621,36 +666,36 @@ class CryptoConditionsTest (BitcoinTestFramework): too_long_description = generate_random_string(4100) result = rpc.oraclescreate("Test", too_long_description, "s") assert_error(result) - - # valid creating oracles of different types - # using such naming to re-use it for data publishing / reading (e.g. oracle_s for s type) - valid_formats = ["s", "S", "d", "D", "c", "C", "t", "T", "i", "I", "l", "L", "h", "Ihh"] - for f in valid_formats: - result = rpc.oraclescreate("Test", "Test", f) - assert_success(result) - globals()["oracle_{}".format(f)] = self.send_and_mine(result['hex']) - - - + # # valid creating oracles of different types + # # using such naming to re-use it for data publishing / reading (e.g. oracle_s for s type) + # valid_formats = ["s", "S", "d", "D", "c", "C", "t", "T", "i", "I", "l", "L", "h", "Ihh"] + # for f in valid_formats: + # result = rpc.oraclescreate("Test", "Test", f) + # assert_success(result) + # globals()["oracle_{}".format(f)] = self.send_and_mine(result['hex'], rpc) def run_test (self): print("Mining blocks...") rpc = self.nodes[0] - + rpc1 = self.nodes[1] # utxos from block 1 become mature in block 101 rpc.generate(101) self.sync_all() - + rpc.getinfo() + rpc1.getinfo() # this corresponds to -pubkey above - print("Importing privkey") + print("Importing privkeys") rpc.importprivkey(self.privkey) - - #self.run_faucet_tests() - self.run_rewards_tests() - self.run_dice_tests() - self.run_token_tests() + rpc1.importprivkey(self.privkey1) self.run_faucet_tests() + self.sync_all() + self.run_rewards_tests() + self.sync_all() + self.run_dice_tests() + self.sync_all() + self.run_token_tests() + self.sync_all() self.run_oracles_tests() diff --git a/qa/rpc-tests/test_framework/util.py b/qa/rpc-tests/test_framework/util.py index 7689d99b4..e9130171b 100644 --- a/qa/rpc-tests/test_framework/util.py +++ b/qa/rpc-tests/test_framework/util.py @@ -198,6 +198,21 @@ def start_node(i, dirname, extra_args=None, rpchost=None, timewait=None, binary= Start a komodod and return RPC connection to it """ datadir = os.path.join(dirname, "node"+str(i)) + # creating special config in case of cryptocondition asset chain test + if extra_args[0] == '-ac_name=REGTEST': + configpath = datadir + "/REGTEST.conf" + with open(configpath, "w+") as config: + config.write("regtest=1\n") + config.write("rpcuser=rt\n") + config.write("rpcpassword=rt\n") + port = extra_args[3] + config.write("rpcport=" + (port[9:]) + "\n") + config.write("server=1\n") + config.write("txindex=1\n") + config.write("rpcworkqueue=256\n") + config.write("rpcallowip=127.0.0.1\n") + config.write("bind=127.0.0.1\n") + config.write("rpcbind=127.0.0.1") if binary is None: binary = os.getenv("BITCOIND", "komodod") args = [ binary, "-datadir="+datadir, "-keypool=1", "-discover=0", "-rest" ] @@ -223,10 +238,8 @@ def start_node(i, dirname, extra_args=None, rpchost=None, timewait=None, binary= if os.getenv("PYTHON_DEBUG", ""): print "start_node: calling komodo-cli -rpcwait getblockcount returned" devnull.close() - if extra_args[0] == '-ac_name=REGTEST': - url = "http://rt:rt@%s:%d" % (rpchost or '127.0.0.1', 64368) - else: - url = "http://rt:rt@%s:%d" % (rpchost or '127.0.0.1', rpc_port(i)) + port = extra_args[3] + url = "http://rt:rt@%s:%d" % (rpchost or '127.0.0.1', int(port[9:])) print("connecting to " + url) if timewait is not None: proxy = AuthServiceProxy(url, timeout=timewait)