diff --git a/configure.ac b/configure.ac index 77671e2c5..41aa7ac7e 100644 --- a/configure.ac +++ b/configure.ac @@ -922,7 +922,7 @@ unset PKG_CONFIG_LIBDIR PKG_CONFIG_LIBDIR="$PKGCONFIG_LIBDIR_TEMP" ac_configure_args="${ac_configure_args} --disable-shared --with-pic --with-bignum=no --enable-module-recovery" -AC_CONFIG_SUBDIRS([src/secp256k1 src/univalue src/cryptoconditions]) +AC_CONFIG_SUBDIRS([src/secp256k1 src/univalue]) AC_OUTPUT diff --git a/qa/rpc-tests/cryptoconditions.py b/qa/rpc-tests/cryptoconditions.py deleted file mode 100755 index 0a13cb605..000000000 --- a/qa/rpc-tests/cryptoconditions.py +++ /dev/null @@ -1,691 +0,0 @@ -#!/usr/bin/env python2 -# Copyright (c) 2016-2023 The Hush developers -# Copyright (c) 2018 SuperNET developers -# Distributed under the GPLv3 software license, see the accompanying -# file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html - -from test_framework.test_framework import BitcoinTestFramework -from test_framework.authproxy import JSONRPCException -from test_framework.util import assert_equal, assert_greater_than, \ - initialize_chain_clean, initialize_chain, start_nodes, start_node, connect_nodes_bi, \ - stop_nodes, sync_blocks, sync_mempools, wait_bitcoinds, rpc_port, assert_raises - -import time -from decimal import Decimal -from random import choice -from string import ascii_uppercase - -def assert_success(result): - assert_equal(result['result'], 'success') - -def assert_error(result): - assert_equal(result['result'], 'error') - -def generate_random_string(length): - random_string = ''.join(choice(ascii_uppercase) for i in range(length)) - return random_string - -class CryptoConditionsTest (BitcoinTestFramework): - - def setup_chain(self): - print("Initializing CC test directory "+self.options.tmpdir) - self.num_nodes = 2 - initialize_chain_clean(self.options.tmpdir, self.num_nodes) - - def setup_network(self, split = False): - print("Setting up network...") - 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 and port as third - '-ac_name=REGTEST', - '-conf='+self.options.tmpdir+'/node0/REGTEST.conf', - '-port=64367', - '-rpcport=64368', - '-regtest', - '-addressindex=1', - '-spentindex=1', - '-ac_supply=5555555', - '-ac_reward=10000000000000', - '-pubkey=' + self.pubkey, - '-ac_cc=2', - '-allowlist=127.0.0.1', - '-debug', - '--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', - '-allowlist=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, rpc_connection): - txid = rpc_connection.sendrawtransaction(xtn) - assert txid, 'got txid' - # we need the tx above to be confirmed in the next block - rpc_connection.generate(1) - return txid - - def run_faucet_tests(self): - rpc = self.rpc - rpc1 = self.rpc1 - - # basic sanity tests - result = rpc.getwalletinfo() - assert_greater_than(result['txcount'], 100) - assert_greater_than(result['balance'], 0.0) - balance = result['balance'] - - faucet = rpc.faucetaddress() - assert_equal(faucet['result'], 'success') - # verify all keys look like valid AC addrs, could be better - for x in ['myCCAddress(Faucet)', 'FaucetCCAddress', 'FaucetCCTokensAddress', 'myaddress', 'FaucetNormalAddress']: - assert_equal(faucet[x][0], 'R') - - result = rpc.faucetaddress(self.pubkey) - assert_success(result) - # test that additional CCaddress key is returned - for x in ['myCCAddress(Faucet)', 'FaucetCCAddress', 'FaucetCCTokensAddress', 'myaddress', 'FaucetNormalAddress']: - assert_equal(result[x][0], 'R') - - # no funds in the faucet yet - result = rpc.faucetget() - assert_error(result) - - result = rpc.faucetinfo() - assert_success(result) - - result = rpc.faucetfund("0") - assert_error(result) - - result = rpc.faucetfund("-1") - assert_error(result) - - # we need at least 1 + txfee to get - result = rpc.faucetfund("2") - assert_success(result) - assert result['hex'], "hex key found" - - # broadcast the xtn - result = rpc.sendrawtransaction(result['hex']) - txid = result[0] - assert txid, "found txid" - - # we need the tx above to be confirmed in the next block - rpc.generate(1) - self.sync_all() - - result = rpc.getwalletinfo() - # minus one block reward - balance2 = result['balance'] - 100000 - # make sure our balance is less now - assert_greater_than(balance, balance2) - - result = rpc.faucetinfo() - assert_success(result) - assert_greater_than( result['funding'], 0 ) - - # claiming faucet on second node - faucetgethex = rpc1.faucetget() - assert_success(faucetgethex) - assert faucetgethex['hex'], "hex key found" - - balance1 = rpc1.getwalletinfo()['balance'] - - # 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') - for x in ['myCCAddress(Dice)', 'DiceCCAddress', 'DiceCCTokensAddress', 'myaddress', 'DiceNormalAddress']: - assert_equal(dice[x][0], 'R') - - dice = rpc.diceaddress(self.pubkey) - assert_equal(dice['result'], 'success') - for x in ['myCCAddress(Dice)', 'DiceCCAddress', 'DiceCCTokensAddress', 'myaddress', 'DiceNormalAddress']: - assert_equal(dice[x][0], 'R') - - # no dice created yet - result = rpc.dicelist() - assert_equal(result, []) - - # creating dice plan with too long name (>8 chars) - result = rpc.dicefund("THISISTOOLONG", "10000", "10", "10000", "10", "5") - assert_error(result) - - # creating dice plan with < 100 funding - result = rpc.dicefund("LUCKY","10","1","10000","10","5") - assert_error(result) - - # creating dice plan with 0 blocks timeout - result = rpc.dicefund("LUCKY","10","1","10000","10","0") - assert_error(result) - - # creating dice plan - dicefundtx = rpc.dicefund("LUCKY","1000","1","800","10","5") - diceid = self.send_and_mine(dicefundtx['hex'], rpc) - - # checking if it in plans list now - result = rpc.dicelist() - assert_equal(result[0], diceid) - - # set dice name for futher usage - dicename = "LUCKY" - - # adding zero funds to plan - result = rpc.diceaddfunds(dicename,diceid,"0") - assert_error(result) - - # adding negative funds to plan - result = rpc.diceaddfunds(dicename,diceid,"-1") - assert_error(result) - - # adding funds to plan - addfundstx = rpc.diceaddfunds(dicename,diceid,"1100") - result = self.send_and_mine(addfundstx['hex'], rpc) - - # checking if funds added to plan - result = rpc.diceinfo(diceid) - assert_equal(result["funding"], "2100.00000000") - - # not valid dice info checking - result = rpc.diceinfo("invalid") - assert_error(result) - - # placing 0 amount bet - result = rpc1.dicebet(dicename,diceid,"0","2") - assert_error(result) - - # placing negative amount bet - result = rpc1.dicebet(dicename,diceid,"-1","2") - assert_error(result) - - # placing bet more than maxbet - result = rpc1.dicebet(dicename,diceid,"900","2") - assert_error(result) - - # placing bet with amount more than funding - result = rpc1.dicebet(dicename,diceid,"3000","2") - assert_error(result) - - # placing bet with potential won more than funding - result = rpc1.dicebet(dicename,diceid,"750","9") - assert_error(result) - - # placing 0 odds bet - result = rpc1.dicebet(dicename,diceid,"1","0") - assert_error(result) - - # placing negative odds bet - result = rpc1.dicebet(dicename,diceid,"1","-1") - assert_error(result) - - # placing bet with odds more than allowed - result = rpc1.dicebet(dicename,diceid,"1","11") - assert_error(result) - - # placing bet with not correct dice name - result = rpc1.dicebet("nope",diceid,"100","2") - assert_error(result) - - # placing bet with not correct dice id - result = rpc1.dicebet(dicename,self.pubkey,"100","2") - assert_error(result) - - # have to make some entropy for the next test - entropytx = 0 - fundingsum = 1 - while entropytx < 110: - fundingsuminput = str(fundingsum) - fundinghex = rpc.diceaddfunds(dicename,diceid,fundingsuminput) - 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: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] - result = rpc.tokenaddress() - assert_success(result) - for x in ['myCCAddress(Tokens)', 'TokensNormalAddress', 'TokensNormalAddress', 'myaddress','TokensCCAddress']: - assert_equal(result[x][0], 'R') - - result = rpc.tokenaddress(self.pubkey) - assert_success(result) - for x in ['myCCAddress(Tokens)', 'TokensNormalAddress', 'TokensNormalAddress', 'myaddress','TokensCCAddress']: - assert_equal(result[x][0], 'R') - # there are no tokens created yet - result = rpc.tokenlist() - assert_equal(result, []) - - # trying to create token with negaive supply - result = rpc.tokencreate("NUKE", "-1987420", "no bueno supply") - assert_error(result) - - # creating token with name more than 32 chars - result = rpc.tokencreate("NUKE123456789012345678901234567890", "1987420", "name too long") - assert_error(result) - - # creating valid token - result = rpc.tokencreate("DUKE", "1987.420", "Duke's custom token") - assert_success(result) - - tokenid = self.send_and_mine(result['hex'], rpc) - - result = rpc.tokenlist() - assert_equal(result[0], tokenid) - - # get token balance for token with pubkey - result = rpc.tokenbalance(tokenid, self.pubkey) - assert_success(result) - assert_equal(result['balance'], 198742000000) - assert_equal(result['tokenid'], tokenid) - - # get token balance for token without pubkey - result = rpc.tokenbalance(tokenid) - assert_success(result) - assert_equal(result['balance'], 198742000000) - assert_equal(result['tokenid'], tokenid) - - # this is not a valid assetid - result = rpc.tokeninfo(self.pubkey) - assert_error(result) - - # check tokeninfo for valid token - result = rpc.tokeninfo(tokenid) - assert_success(result) - assert_equal(result['tokenid'], tokenid) - assert_equal(result['owner'], self.pubkey) - assert_equal(result['name'], "DUKE") - assert_equal(result['supply'], 198742000000) - assert_equal(result['description'], "Duke's custom token") - - # invalid numtokens ask - result = rpc.tokenask("-1", tokenid, "1") - assert_error(result) - - # invalid numtokens ask - result = rpc.tokenask("0", tokenid, "1") - assert_error(result) - - # invalid price ask - result = rpc.tokenask("1", tokenid, "-1") - assert_error(result) - - # invalid price ask - result = rpc.tokenask("1", tokenid, "0") - assert_error(result) - - # invalid tokenid ask - result = rpc.tokenask("100", "deadbeef", "1") - assert_error(result) - - # valid ask - tokenask = rpc.tokenask("100", tokenid, "7.77") - tokenaskhex = tokenask['hex'] - tokenaskid = self.send_and_mine(tokenask['hex'], rpc) - result = rpc.tokenorders(tokenid) - order = result[0] - assert order, "found order" - - # invalid ask fillunits - result = rpc.tokenfillask(tokenid, tokenaskid, "0") - assert_error(result) - - # invalid ask fillunits - result = rpc.tokenfillask(tokenid, tokenaskid, "-777") - assert_error(result) - - # valid ask fillunits - fillask = rpc.tokenfillask(tokenid, tokenaskid, "777") - result = self.send_and_mine(fillask['hex'], rpc) - txid = result[0] - assert txid, "found txid" - - # should be no token orders - result = rpc.tokenorders(tokenid) - assert_equal(result, []) - - # checking ask cancellation - testorder = rpc.tokenask("100", tokenid, "7.77") - testorderid = self.send_and_mine(testorder['hex'], rpc) - cancel = rpc.tokencancelask(tokenid, testorderid) - self.send_and_mine(cancel["hex"], rpc) - result = rpc.tokenorders(tokenid) - assert_equal(result, []) - - # invalid numtokens bid - result = rpc.tokenbid("-1", tokenid, "1") - assert_error(result) - - # invalid numtokens bid - result = rpc.tokenbid("0", tokenid, "1") - assert_error(result) - - # invalid price bid - result = rpc.tokenbid("1", tokenid, "-1") - assert_error(result) - - # invalid price bid - result = rpc.tokenbid("1", tokenid, "0") - assert_error(result) - - # invalid tokenid bid - result = rpc.tokenbid("100", "deadbeef", "1") - assert_error(result) - - tokenbid = rpc.tokenbid("100", tokenid, "10") - tokenbidhex = tokenbid['hex'] - tokenbidid = self.send_and_mine(tokenbid['hex'], rpc) - result = rpc.tokenorders(tokenid) - order = result[0] - assert order, "found order" - - # invalid bid fillunits - result = rpc.tokenfillbid(tokenid, tokenbidid, "0") - assert_error(result) - - # invalid bid fillunits - result = rpc.tokenfillbid(tokenid, tokenbidid, "-777") - assert_error(result) - - # valid bid fillunits - fillbid = rpc.tokenfillbid(tokenid, tokenbidid, "1000") - result = self.send_and_mine(fillbid['hex'], rpc) - txid = result[0] - assert txid, "found txid" - - # should be no token orders - result = rpc.tokenorders(tokenid) - assert_equal(result, []) - - # checking bid cancellation - testorder = rpc.tokenbid("100", tokenid, "7.77") - testorderid = self.send_and_mine(testorder['hex'], rpc) - cancel = rpc.tokencancelbid(tokenid, testorderid) - self.send_and_mine(cancel["hex"], rpc) - result = rpc.tokenorders(tokenid) - assert_equal(result, []) - - # invalid token transfer amount (have to add status to CC code!) - randompubkey = "021a559101e355c907d9c553671044d619769a6e71d624f68bfec7d0afa6bd6a96" - result = rpc.tokentransfer(tokenid,randompubkey,"0") - assert_error(result) - - # invalid token transfer amount (have to add status to CC code!) - result = rpc.tokentransfer(tokenid,randompubkey,"-1") - assert_error(result) - - # valid token transfer - sendtokens = rpc.tokentransfer(tokenid,randompubkey,"1") - self.send_and_mine(sendtokens["hex"], rpc) - result = rpc.tokenbalance(tokenid,randompubkey) - assert_equal(result["balance"], 1) - - def run_rewards_tests(self): - rpc = self.nodes[0] - result = rpc.rewardsaddress() - for x in ['myCCAddress(Rewards)', 'myaddress', 'RewardsCCAddress', 'RewardsCCTokensAddress', 'RewardsNormalAddress']: - assert_equal(result[x][0], 'R') - - result = rpc.rewardsaddress(self.pubkey) - for x in ['myCCAddress(Rewards)', 'myaddress', 'RewardsCCAddress', 'RewardsCCTokensAddress', 'RewardsNormalAddress']: - assert_equal(result[x][0], 'R') - - # no rewards yet - result = rpc.rewardslist() - assert_equal(result, []) - - # looking up non-existent reward should return error - result = rpc.rewardsinfo("none") - assert_error(result) - - # creating rewards plan with name > 8 chars, should return error - result = rpc.rewardscreatefunding("STUFFSTUFF", "7777", "25", "0", "10", "10") - assert_error(result) - - # creating rewards plan with 0 funding - result = rpc.rewardscreatefunding("STUFF", "0", "25", "0", "10", "10") - assert_error(result) - - # creating rewards plan with 0 maxdays - result = rpc.rewardscreatefunding("STUFF", "7777", "25", "0", "10", "0") - assert_error(result) - - # creating rewards plan with > 25% APR - result = rpc.rewardscreatefunding("STUFF", "7777", "30", "0", "10", "10") - assert_error(result) - - # creating valid rewards plan - result = rpc.rewardscreatefunding("STUFF", "7777", "25", "0", "10", "10") - assert result['hex'], 'got raw xtn' - fundingtxid = rpc.sendrawtransaction(result['hex']) - assert fundingtxid, 'got txid' - - # confirm the above xtn - rpc.generate(1) - result = rpc.rewardsinfo(fundingtxid) - assert_success(result) - assert_equal(result['name'], 'STUFF') - assert_equal(result['APR'], "25.00000000") - assert_equal(result['minseconds'], 0) - assert_equal(result['maxseconds'], 864000) - assert_equal(result['funding'], "7777.00000000") - assert_equal(result['mindeposit'], "10.00000000") - assert_equal(result['fundingtxid'], fundingtxid) - - # checking if new plan in rewardslist - result = rpc.rewardslist() - assert_equal(result[0], fundingtxid) - - # creating reward plan with already existing name, should return error - result = rpc.rewardscreatefunding("STUFF", "7777", "25", "0", "10", "10") - assert_error(result) - - # add funding amount must be positive - result = rpc.rewardsaddfunding("STUFF", fundingtxid, "-1") - assert_error(result) - - # add funding amount must be positive - result = rpc.rewardsaddfunding("STUFF", fundingtxid, "0") - assert_error(result) - - # adding valid funding - result = rpc.rewardsaddfunding("STUFF", fundingtxid, "555") - addfundingtxid = self.send_and_mine(result['hex'], rpc) - assert addfundingtxid, 'got funding txid' - - # checking if funding added to rewardsplan - result = rpc.rewardsinfo(fundingtxid) - assert_equal(result['funding'], "8332.00000000") - - # trying to lock funds, locking funds amount must be positive - result = rpc.rewardslock("STUFF", fundingtxid, "-5") - assert_error(result) - - # trying to lock funds, locking funds amount must be positive - result = rpc.rewardslock("STUFF", fundingtxid, "0") - assert_error(result) - - # trying to lock less than the min amount is an error - result = rpc.rewardslock("STUFF", fundingtxid, "7") - assert_error(result) - - # locking funds in rewards plan - result = rpc.rewardslock("STUFF", fundingtxid, "10") - assert_success(result) - locktxid = result['hex'] - assert locktxid, "got lock txid" - - # locktxid has not been broadcast yet - result = rpc.rewardsunlock("STUFF", fundingtxid, locktxid) - assert_error(result) - - # broadcast xtn - txid = rpc.sendrawtransaction(locktxid) - assert txid, 'got txid from sendrawtransaction' - - # confirm the xtn above - rpc.generate(1) - - # will not unlock since reward amount is less than tx fee - result = rpc.rewardsunlock("STUFF", fundingtxid, locktxid) - assert_error(result) - - 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', 'OraclesNormalAddress', 'myCCAddress(Oracles)','OraclesCCTokensAddress', 'myaddress']: - assert_equal(result[x][0], 'R') - - result = rpc.oraclesaddress(self.pubkey) - assert_success(result) - for x in ['OraclesCCAddress', 'OraclesNormalAddress', 'myCCAddress(Oracles)','OraclesCCTokensAddress', 'myaddress']: - assert_equal(result[x][0], 'R') - - # there are no oracles created yet - result = rpc.oracleslist() - assert_equal(result, []) - - # looking up non-existent oracle should return error. - result = rpc.oraclesinfo("none") - assert_error(result) - - # attempt to create oracle with not valid data type should return error - result = rpc.oraclescreate("Test", "Test", "Test") - assert_error(result) - - # attempt to create oracle with description > 32 symbols should return error - too_long_name = generate_random_string(33) - result = rpc.oraclescreate(too_long_name, "Test", "s") - - - # attempt to create oracle with description > 4096 symbols should return error - 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'], 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 privkeys") - rpc.importprivkey(self.privkey) - 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() - - -if __name__ == '__main__': - CryptoConditionsTest ().main() diff --git a/qa/rpc-tests/cryptoconditions_channels.py b/qa/rpc-tests/cryptoconditions_channels.py deleted file mode 100755 index 2f6487f84..000000000 --- a/qa/rpc-tests/cryptoconditions_channels.py +++ /dev/null @@ -1,261 +0,0 @@ -#!/usr/bin/env python2 -# Copyright (c) 2016-2023 The Hush developers -# Copyright (c) 2018 SuperNET developers -# Distributed under the GPLv3 software license, see the accompanying -# file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html - - -import time -from test_framework.test_framework import CryptoconditionsTestFramework -from test_framework.authproxy import JSONRPCException -from test_framework.util import assert_equal, assert_greater_than, \ - initialize_chain_clean, initialize_chain, start_nodes, start_node, connect_nodes_bi, \ - stop_nodes, sync_blocks, sync_mempools, wait_bitcoinds, rpc_port, assert_raises -from cryptoconditions import assert_success, assert_error, generate_random_string - - -class CryptoconditionsChannelsTest(CryptoconditionsTestFramework): - - def run_channels_tests(self): - - - """!!! for testing needed test daemon which built with custom flag - export CONFIGURE_FLAGS='CPPFLAGS=-DTESTMODE' - since in usual mode 101 confirmations are needed for payment/refund - """ - - rpc = self.nodes[0] - rpc1 = self.nodes[1] - - # checking channelsaddress call - - result = rpc.channelsaddress(self.pubkey) - assert_success(result) - # test that additional CCaddress key is returned - - for x in result.keys(): - if x.find('ddress') > 0: - assert_equal(result[x][0], 'R') - - # getting empty channels list - result = rpc.channelslist() - assert_equal(len(result), 2) - assert_equal(result["result"], "success") - assert_equal(result["name"], "Channels List") - - # 10 payments, 100000 sat denomination channel opening with second node pubkey - new_channel_hex = rpc.channelsopen(self.pubkey1, "10", "100000") - assert_success(new_channel_hex) - channel_txid = self.send_and_mine(new_channel_hex["hex"], rpc) - assert channel_txid, "got channel txid" - - # checking if our new channel in common channels list - result = rpc.channelslist() - assert_equal(len(result), 3) - - # checking info about channel directly - result = rpc.channelsinfo(channel_txid) - assert_success(result) - assert_equal(result["Transactions"][0]["Open"], channel_txid) - - # open transaction should be confirmed - rpc.generate(1) - - # trying to make wrong denomination channel payment - result = rpc.channelspayment(channel_txid, "199000") - assert_error(result) - - # trying to make 0 channel payment - result = rpc.channelspayment(channel_txid, "0") - assert_error(result) - - # trying to make negative channel payment - result = rpc.channelspayment(channel_txid, "-1") - assert_error(result) - - # valid channel payment - result = rpc.channelspayment(channel_txid, "100000") - assert_success(result) - payment_tx_id = self.send_and_mine(result["hex"], rpc) - assert payment_tx_id, "got txid" - - # now in channelinfo payment information should appear - result = rpc.channelsinfo(channel_txid) - assert_equal(result["Transactions"][1]["Payment"], payment_tx_id) - - # number of payments should be equal 1 (one denomination used) - result = rpc.channelsinfo(channel_txid)["Transactions"][1]["Number of payments"] - assert_equal(result, 1) - # payments left param should reduce 1 and be equal 9 now ( 10 - 1 = 9 ) - result = rpc.channelsinfo(channel_txid)["Transactions"][1]["Payments left"] - assert_equal(result, 9) - - # lets try payment with x2 amount to ensure that counters works correct - result = rpc.channelspayment(channel_txid, "200000") - assert_success(result) - payment_tx_id = self.send_and_mine(result["hex"], rpc) - assert payment_tx_id, "got txid" - - result = rpc.channelsinfo(channel_txid) - assert_equal(result["Transactions"][2]["Payment"], payment_tx_id) - - result = rpc.channelsinfo(channel_txid)["Transactions"][2]["Number of payments"] - assert_equal(result, 2) - - result = rpc.channelsinfo(channel_txid)["Transactions"][2]["Payments left"] - assert_equal(result, 7) - - # check if payment value really transferred - raw_transaction = rpc.getrawtransaction(payment_tx_id, 1) - - result = raw_transaction["vout"][3]["valueSat"] - assert_equal(result, 200000) - - result = rpc1.validateaddress(raw_transaction["vout"][3]["scriptPubKey"]["addresses"][0])["ismine"] - assert_equal(result, True) - - # have to check that second node have coins to cover txfee at least - rpc.sendtoaddress(rpc1.getnewaddress(), 1) - rpc.sendtoaddress(rpc1.getnewaddress(), 1) - rpc.generate(2) - self.sync_all() - result = rpc1.getbalance() - assert_greater_than(result, 0.1) - - # trying to initiate channels payment from node B without any secret - # TODO: have to add RPC validation - payment_hex = rpc1.channelspayment(channel_txid, "100000") - try: - result = rpc1.sendrawtransaction(payment_hex["hex"]) - except Exception as e: - pass - - # trying to initiate channels payment from node B with secret from previous payment - result = rpc1.channelspayment(channel_txid, "100000", rpc1.channelsinfo(channel_txid)["Transactions"][1]["Secret"]) - #result = rpc1.sendrawtransaction(payment_hex["hex"]) - assert_error(result) - - # executing channel close - result = rpc.channelsclose(channel_txid) - assert_success(result) - channel_close_txid = self.send_and_mine(result["hex"], rpc) - assert channel_close_txid, "got txid" - - rpc.generate(2) - self.sync_all() - - # now in channelinfo closed flag should appear - result = rpc.channelsinfo(channel_txid) - assert_equal(result["Transactions"][3]["Close"], channel_close_txid) - - # executing channel refund - result = rpc.channelsrefund(channel_txid, channel_close_txid) - assert_success(result) - refund_txid = self.send_and_mine(result["hex"], rpc) - assert refund_txid, "got txid" - - # checking if it refunded to opener address - raw_transaction = rpc.getrawtransaction(refund_txid, 1) - - result = raw_transaction["vout"][2]["valueSat"] - assert_equal(result, 700000) - - result = rpc.validateaddress(raw_transaction["vout"][2]["scriptPubKey"]["addresses"][0])["ismine"] - assert_equal(result, True) - - - # creating and draining channel (10 payment by 100000 satoshies in total to fit full capacity) - new_channel_hex1 = rpc.channelsopen(self.pubkey1, "10", "100000") - assert_success(new_channel_hex1) - channel1_txid = self.send_and_mine(new_channel_hex1["hex"], rpc) - assert channel1_txid, "got channel txid" - - # need to have 2+ confirmations in the test mode - rpc.generate(2) - self.sync_all() - - for i in range(10): - result = rpc.channelspayment(channel1_txid, "100000") - assert_success(result) - payment_tx_id = self.send_and_mine(result["hex"], rpc) - assert payment_tx_id, "got txid" - - # last payment should indicate that 0 payments left - result = rpc.channelsinfo(channel1_txid)["Transactions"][10]["Payments left"] - assert_equal(result, 0) - - # no more payments possible - result = rpc.channelspayment(channel1_txid, "100000") - assert_error(result) - - # creating new channel to test the case when node B initiate payment when node A revealed secret in offline - # 10 payments, 100000 sat denomination channel opening with second node pubkey - new_channel_hex2 = rpc.channelsopen(self.pubkey1, "10", "100000") - assert_success(new_channel_hex) - channel2_txid = self.send_and_mine(new_channel_hex2["hex"], rpc) - assert channel2_txid, "got channel txid" - - rpc.generate(2) - self.sync_all() - - # disconnecting first node from network - rpc.setban("127.0.0.0/24","add") - assert_equal(rpc.getinfo()["connections"], 0) - assert_equal(rpc1.getinfo()["connections"], 0) - - rpc1.generate(1) - - # sending one payment to mempool to reveal the secret but not mine it - payment_hex = rpc.channelspayment(channel2_txid, "100000") - result = rpc.sendrawtransaction(payment_hex["hex"]) - assert result, "got payment txid" - - secret = rpc.channelsinfo(channel2_txid)["Transactions"][1]["Secret"] - assert secret, "Secret revealed" - - # secret shouldn't be available for node B - secret_not_revealed = None - try: - rpc1.channelsinfo(channel2_txid)["Transactions"][1]["Secret"] - except Exception: - secret_not_revealed = True - assert_equal(secret_not_revealed, True) - - # trying to initiate payment from second node with revealed secret - assert_equal(rpc1.getinfo()["connections"], 0) - dc_payment_hex = rpc1.channelspayment(channel2_txid, "100000", secret) - assert_success(dc_payment_hex) - result = rpc1.sendrawtransaction(dc_payment_hex["hex"]) - assert result, "got channelspayment transaction id" - - # TODO: it crash first node after block generating on mempools merging - # # restoring connection between nodes - # rpc.setban("127.0.0.0/24","remove") - # #rpc.generate(1) - # #rpc1.generate(1) - # sync_blocks(self.nodes) - # rpc.generate(1) - # sync_blocks(self.nodes) - # sync_mempools(self.nodes) - # assert_equal(rpc.getinfo()["connections"], 1) - # assert_equal(rpc1.getinfo()["connections"], 1) - - def run_test(self): - print("Mining blocks...") - rpc = self.nodes[0] - rpc1 = self.nodes[1] - # utxos from block 1 become mature in block 101 - if not self.options.noshutdown: - rpc.generate(101) - self.sync_all() - rpc.getinfo() - rpc1.getinfo() - # this corresponds to -pubkey above - print("Importing privkeys") - rpc.importprivkey(self.privkey) - rpc1.importprivkey(self.privkey1) - self.run_channels_tests() - - -if __name__ == '__main__': - CryptoconditionsChannelsTest().main() diff --git a/qa/rpc-tests/cryptoconditions_dice.py b/qa/rpc-tests/cryptoconditions_dice.py deleted file mode 100755 index 4a3a202a4..000000000 --- a/qa/rpc-tests/cryptoconditions_dice.py +++ /dev/null @@ -1,204 +0,0 @@ -#!/usr/bin/env python2 -# Copyright (c) 2016-2023 The Hush developers -# Copyright (c) 2018 SuperNET developers -# Distributed under the GPLv3 software license, see the accompanying -# file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html - - -from test_framework.test_framework import CryptoconditionsTestFramework -from test_framework.authproxy import JSONRPCException -from test_framework.util import assert_equal, assert_greater_than, \ - initialize_chain_clean, initialize_chain, start_nodes, start_node, connect_nodes_bi, \ - stop_nodes, sync_blocks, sync_mempools, wait_bitcoinds, rpc_port, assert_raises -from cryptoconditions import assert_success, assert_error, generate_random_string - - -class CryptoconditionsDiceTest(CryptoconditionsTestFramework): - - 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) - - result = rpc.diceaddress() - assert_equal(result['result'], 'success') - - for x in result.keys(): - if x.find('ddress') > 0: - assert_equal(result[x][0], 'R') - - result = rpc.diceaddress(self.pubkey) - for x in result.keys(): - print(x+": "+str(result[x])) - assert_equal(result['result'], 'success') - - for x in result.keys(): - if x.find('ddress') > 0: - assert_equal(result[x][0], 'R') - - # no dice created yet - result = rpc.dicelist() - assert_equal(result, []) - - # creating dice plan with too long name (>8 chars) - result = rpc.dicefund("THISISTOOLONG", "10000", "10", "10000", "10", "5") - assert_error(result) - - # creating dice plan with < 100 funding - result = rpc.dicefund("LUCKY","10","1","10000","10","5") - assert_error(result) - - # creating dice plan with 0 blocks timeout - result = rpc.dicefund("LUCKY","10","1","10000","10","0") - assert_error(result) - - # creating dice plan - dicefundtx = rpc.dicefund("LUCKY","1000","1","800","10","5") - diceid = self.send_and_mine(dicefundtx['hex'], rpc) - - # checking if it in plans list now - result = rpc.dicelist() - assert_equal(result[0], diceid) - - # set dice name for futher usage - dicename = "LUCKY" - - # adding zero funds to plan - result = rpc.diceaddfunds(dicename,diceid,"0") - assert_error(result) - - # adding negative funds to plan - result = rpc.diceaddfunds(dicename,diceid,"-1") - assert_error(result) - - # adding funds to plan - addfundstx = rpc.diceaddfunds(dicename,diceid,"1100") - result = self.send_and_mine(addfundstx['hex'], rpc) - - # checking if funds added to plan - result = rpc.diceinfo(diceid) - assert_equal(result["funding"], "2100.00000000") - - # not valid dice info checking - result = rpc.diceinfo("invalid") - assert_error(result) - - # placing 0 amount bet - result = rpc1.dicebet(dicename,diceid,"0","2") - assert_error(result) - - # placing negative amount bet - result = rpc1.dicebet(dicename,diceid,"-1","2") - assert_error(result) - - # placing bet more than maxbet - result = rpc1.dicebet(dicename,diceid,"900","2") - assert_error(result) - - # placing bet with amount more than funding - result = rpc1.dicebet(dicename,diceid,"3000","2") - assert_error(result) - - # placing bet with potential won more than funding - result = rpc1.dicebet(dicename,diceid,"750","9") - assert_error(result) - - # placing 0 odds bet - result = rpc1.dicebet(dicename,diceid,"1","0") - assert_error(result) - - # placing negative odds bet - result = rpc1.dicebet(dicename,diceid,"1","-1") - assert_error(result) - - # placing bet with odds more than allowed - result = rpc1.dicebet(dicename,diceid,"1","11") - assert_error(result) - - # placing bet with not correct dice name - result = rpc1.dicebet("nope",diceid,"100","2") - assert_error(result) - - # placing bet with not correct dice id - result = rpc1.dicebet(dicename,self.pubkey,"100","2") - assert_error(result) - - # have to make some entropy for the next test - entropytx = 0 - fundingsum = 1 - while entropytx < 110: - fundingsuminput = str(fundingsum) - fundinghex = rpc.diceaddfunds(dicename,diceid,fundingsuminput) - 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: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_test(self): - print("Mining blocks...") - rpc = self.nodes[0] - rpc1 = self.nodes[1] - # utxos from block 1 become mature in block 101 - if not self.options.noshutdown: - rpc.generate(101) - self.sync_all() - rpc.getinfo() - rpc1.getinfo() - # this corresponds to -pubkey above - print("Importing privkeys") - rpc.importprivkey(self.privkey) - rpc1.importprivkey(self.privkey1) - self.run_dice_tests() - - -if __name__ == '__main__': - CryptoconditionsDiceTest ().main() diff --git a/qa/rpc-tests/cryptoconditions_faucet.py b/qa/rpc-tests/cryptoconditions_faucet.py deleted file mode 100755 index ba7648c4d..000000000 --- a/qa/rpc-tests/cryptoconditions_faucet.py +++ /dev/null @@ -1,116 +0,0 @@ -#!/usr/bin/env python2 -# Copyright (c) 2016-2023 The Hush developers -# Copyright (c) 2018 SuperNET developers -# Distributed under the GPLv3 software license, see the accompanying -# file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html - - -from test_framework.test_framework import CryptoconditionsTestFramework -from test_framework.authproxy import JSONRPCException -from test_framework.util import assert_equal, assert_greater_than, \ - initialize_chain_clean, initialize_chain, start_nodes, start_node, connect_nodes_bi, \ - stop_nodes, sync_blocks, sync_mempools, wait_bitcoinds, rpc_port, assert_raises -from cryptoconditions import assert_success, assert_error, generate_random_string - - -class CryptoconditionsFaucetTest(CryptoconditionsTestFramework): - - def run_faucet_tests(self): - rpc = self.rpc - rpc1 = self.rpc1 - - # basic sanity tests - result = rpc.getwalletinfo() - assert_greater_than(result['txcount'], 100) - assert_greater_than(result['balance'], 0.0) - balance = result['balance'] - - result = rpc.faucetaddress() - assert_equal(result['result'], 'success') - - # verify all keys look like valid AC addrs, could be better - for x in result.keys(): - if x.find('ddress') > 0: - assert_equal(result[x][0], 'R') - - result = rpc.faucetaddress(self.pubkey) - assert_success(result) - for x in result.keys(): - print(x+": "+str(result[x])) - # test that additional CCaddress key is returned - - for x in result.keys(): - if x.find('ddress') > 0: - assert_equal(result[x][0], 'R') - - # no funds in the faucet yet - result = rpc.faucetget() - assert_error(result) - - result = rpc.faucetinfo() - assert_success(result) - - result = rpc.faucetfund("0") - assert_error(result) - - result = rpc.faucetfund("-1") - assert_error(result) - - # we need at least 1 + txfee to get - result = rpc.faucetfund("2") - assert_success(result) - assert result['hex'], "hex key found" - - # broadcast the xtn - result = rpc.sendrawtransaction(result['hex']) - txid = result[0] - assert txid, "found txid" - - # we need the tx above to be confirmed in the next block - rpc.generate(1) - self.sync_all() - - result = rpc.getwalletinfo() - # minus one block reward - balance2 = result['balance'] - 100000 - # make sure our balance is less now - assert_greater_than(balance, balance2) - - result = rpc.faucetinfo() - assert_success(result) - assert_greater_than( result['funding'], 0 ) - - # claiming faucet on second node - faucetgethex = rpc1.faucetget() - assert_success(faucetgethex) - assert faucetgethex['hex'], "hex key found" - - balance1 = rpc1.getwalletinfo()['balance'] - - # 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_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 privkeys") - rpc.importprivkey(self.privkey) - rpc1.importprivkey(self.privkey1) - self.run_faucet_tests() - - -if __name__ == '__main__': - CryptoconditionsFaucetTest ().main() diff --git a/qa/rpc-tests/cryptoconditions_gateways.py b/qa/rpc-tests/cryptoconditions_gateways.py deleted file mode 100755 index d31e89d9f..000000000 --- a/qa/rpc-tests/cryptoconditions_gateways.py +++ /dev/null @@ -1,97 +0,0 @@ -#!/usr/bin/env python2 -# Copyright (c) 2016-2023 The Hush developers -# Copyright (c) 2018 SuperNET developers -# Distributed under the GPLv3 software license, see the accompanying -# file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html - - -from test_framework.test_framework import CryptoconditionsTestFramework -from test_framework.authproxy import JSONRPCException -from test_framework.util import assert_equal, assert_greater_than, \ - initialize_chain_clean, initialize_chain, start_nodes, start_node, connect_nodes_bi, \ - stop_nodes, sync_blocks, sync_mempools, wait_bitcoinds, rpc_port, assert_raises -from cryptoconditions import assert_success, assert_error, generate_random_string - - -class CryptoconditionsGatewaysTest(CryptoconditionsTestFramework): - - def run_gateways_tests(self): - rpc = self.nodes[0] - rpc1 = self.nodes[1] - - result = rpc.gatewaysaddress() - assert_success(result) - - for x in result.keys(): - if x.find('ddress') > 0: - assert_equal(result[x][0], 'R') - - assert_equal("03ea9c062b9652d8eff34879b504eda0717895d27597aaeb60347d65eed96ccb40", result["GatewaysPubkey"]) - - # getting an empty gateways list - - result = rpc.gatewayslist() - assert_equal(result, []) - - # Gateways binding preparation - - # creating oracle - oracle_hex = rpc.oraclescreate("Test", "Testing", "Ihh") - assert_success(oracle_hex) - oracle_txid = self.send_and_mine(oracle_hex["hex"], rpc) - assert oracle_txid, "got txid" - - # registering as an oracle publisher - reg_hex = rpc.oraclesregister(oracle_txid, "10000") - assert_success(reg_hex) - reg_txid = self.send_and_mine(reg_hex["hex"], rpc) - assert reg_txid, "got txid" - - # subscribing on oracle - sub_hex = rpc.oraclessubscribe(oracle_txid, self.pubkey, "1") - assert_success(sub_hex) - sub_txid = self.send_and_mine(sub_hex["hex"], rpc) - assert sub_txid, "got txid" - - # creating token - token_hex = rpc.tokencreate("Test", "1", "Testing") - assert_success(token_hex) - token_txid = self.send_and_mine(token_hex["hex"], rpc) - assert token_txid, "got txid" - - # converting tokens - convertion_hex = rpc.tokenconvert("241",token_txid,"03ea9c062b9652d8eff34879b504eda0717895d27597aaeb60347d65eed96ccb40","100000000") - assert_success(convertion_hex) - convertion_txid = self.send_and_mine(convertion_hex["hex"], rpc) - assert convertion_txid, "got txid" - - # binding gateway - bind_hex = rpc.gatewaysbind(token_txid, oracle_txid, "KMD", "100000000", "1", "1", self.pubkey) - assert_success(bind_hex) - bind_txid = self.send_and_mine(bind_hex["hex"], rpc) - assert bind_txid, "got txid" - - # checking if created gateway in list - result = rpc.gatewayslist() - assert_equal(result[0], bind_txid) - - - def run_test(self): - print("Mining blocks...") - rpc = self.nodes[0] - rpc1 = self.nodes[1] - # utxos from block 1 become mature in block 101 - if not self.options.noshutdown: - rpc.generate(101) - self.sync_all() - rpc.getinfo() - rpc1.getinfo() - # this corresponds to -pubkey above - print("Importing privkeys") - rpc.importprivkey(self.privkey) - rpc1.importprivkey(self.privkey1) - self.run_gateways_tests() - - -if __name__ == '__main__': - CryptoconditionsGatewaysTest().main() diff --git a/qa/rpc-tests/cryptoconditions_heir.py b/qa/rpc-tests/cryptoconditions_heir.py deleted file mode 100755 index be248bb53..000000000 --- a/qa/rpc-tests/cryptoconditions_heir.py +++ /dev/null @@ -1,177 +0,0 @@ -#!/usr/bin/env python2 -# Copyright (c) 2016-2023 The Hush developers -# Copyright (c) 2018 SuperNET developers -# Distributed under the GPLv3 software license, see the accompanying -# file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html - - -import time -from test_framework.test_framework import CryptoconditionsTestFramework -from test_framework.authproxy import JSONRPCException -from test_framework.util import assert_equal, assert_greater_than, \ - initialize_chain_clean, initialize_chain, start_nodes, start_node, connect_nodes_bi, \ - stop_nodes, sync_blocks, sync_mempools, wait_bitcoinds, rpc_port, assert_raises -from cryptoconditions import assert_success, assert_error, generate_random_string - - -class CryptoconditionsHeirTest(CryptoconditionsTestFramework): - - def run_heir_tests(self): - - rpc = self.nodes[0] - rpc1 = self.nodes[1] - - result = rpc.heiraddress('') - assert_success(result) - - # verify all keys look like valid AC addrs, could be better - for x in result.keys(): - if x.find('ddress') > 0: - assert_equal(result[x][0], 'R') - - result = rpc.heiraddress(self.pubkey) - assert_success(result) - - # test that additional CCaddress key is returned - for x in result.keys(): - if x.find('ddress') > 0: - assert_equal(result[x][0], 'R') - - # getting empty heir list - result = rpc.heirlist() - assert_equal(result, []) - - # valid heirfund case with coins - result = rpc.heirfund("0", "1000", "UNITHEIR", self.pubkey1, "10", "TESTMEMO") - assert_success(result) - - heir_fund_txid = self.send_and_mine(result["hex"], rpc) - assert heir_fund_txid, "got heir funding txid" - - # heir fund txid should be in heirlist now - result = rpc.heirlist() - assert_equal(result, [heir_fund_txid]) - - # checking heirinfo - result = rpc.heirinfo(heir_fund_txid) - assert_success(result) - assert_equal(result["fundingtxid"], heir_fund_txid) - assert_equal(result["name"], "UNITHEIR") - assert_equal(result["owner"], self.pubkey) - assert_equal(result["heir"], self.pubkey1) - assert_equal(result["memo"], "TESTMEMO") - assert_equal(result["lifetime"], "1000.00000000") - assert_equal(result["type"], "coins") - assert_equal(result["InactivityTimeSetting"], "10") - assert_equal(result["InactivityTime"], "0") - assert_equal(result["IsHeirSpendingAllowed"], "false") - - # waiting for 11 seconds to be sure that needed time passed for heir claiming - time.sleep(11) - rpc.generate(1) - self.sync_all() - result = rpc.heirinfo(heir_fund_txid) - assert_equal(result["lifetime"], "1000.00000000") - assert_equal(result["IsHeirSpendingAllowed"], "true") - - # have to check that second node have coins to cover txfee at least - rpc.sendtoaddress(rpc1.getnewaddress(), 1) - rpc.sendtoaddress(rpc1.getnewaddress(), 1) - rpc.generate(2) - self.sync_all() - second_node_balance = rpc1.getbalance() - assert_greater_than(second_node_balance, 0.1) - - # let's claim whole heir sum from second node - result = rpc1.heirclaim("0", "1000", heir_fund_txid) - assert_success(result) - - heir_claim_txid = self.send_and_mine(result["hex"], rpc1) - assert heir_claim_txid, "got claim txid" - - # balance of second node after heirclaim should increase for 1000 coins - txfees - # + get one block reward when broadcasted heir_claim_txid - result = round(rpc1.getbalance()) - round(second_node_balance) - assert_greater_than(result, 100999) - - self.sync_all() - - # no more funds should be available for claiming - result = rpc.heirinfo(heir_fund_txid) - assert_equal(result["lifetime"], "1000.00000000") - assert_equal(result["available"], "0.00000000") - - # creating tokens which we put to heir contract - token_hex = rpc.tokencreate("TEST", "1", "TESTING") - token_txid = self.send_and_mine(token_hex["hex"], rpc) - assert token_txid, "got token txid" - - # checking possesion over the tokens and balance - result = rpc.tokenbalance(token_txid, self.pubkey)["balance"] - assert_equal(result, 100000000) - - # valid heir case with tokens - token_heir_hex = rpc.heirfund("0", "100000000", "UNITHEIR", self.pubkey1, "10", "TESTMEMO", token_txid) - token_heir_txid = self.send_and_mine(token_heir_hex["hex"], rpc) - assert token_heir_txid, "got txid of heirfund with tokens" - - self.sync_all() - - # checking heirinfo - result = rpc.heirinfo(token_heir_txid) - assert_success(result) - assert_equal(result["fundingtxid"], token_heir_txid) - assert_equal(result["name"], "UNITHEIR") - assert_equal(result["owner"], self.pubkey) - assert_equal(result["heir"], self.pubkey1) - assert_equal(result["lifetime"], "100000000") - assert_equal(result["type"], "tokens") - assert_equal(result["InactivityTimeSetting"], "10") - assert_equal(result["InactivityTime"], "0") - assert_equal(result["IsHeirSpendingAllowed"], "false") - - # waiting for 11 seconds to be sure that needed time passed for heir claiming - time.sleep(11) - rpc.generate(1) - self.sync_all() - result = rpc.heirinfo(token_heir_txid) - assert_equal(result["lifetime"], "100000000") - assert_equal(result["IsHeirSpendingAllowed"], "true") - - # let's claim whole heir sum from second node - result = rpc1.heirclaim("0", "100000000", token_heir_txid) - assert_success(result) - - heir_tokens_claim_txid = self.send_and_mine(result["hex"], rpc1) - assert heir_tokens_claim_txid, "got claim txid" - - # claiming node should have correct token balance now - result = rpc1.tokenbalance(token_txid, self.pubkey1)["balance"] - assert_equal(result, 100000000) - - self.sync_all() - - # no more funds should be available for claiming - result = rpc.heirinfo(token_heir_txid) - assert_equal(result["lifetime"], "100000000") - assert_equal(result["available"], "0") - - def run_test(self): - print("Mining blocks...") - rpc = self.nodes[0] - rpc1 = self.nodes[1] - # utxos from block 1 become mature in block 101 - if not self.options.noshutdown: - rpc.generate(101) - self.sync_all() - rpc.getinfo() - rpc1.getinfo() - # this corresponds to -pubkey above - print("Importing privkeys") - rpc.importprivkey(self.privkey) - rpc1.importprivkey(self.privkey1) - self.run_heir_tests() - - -if __name__ == '__main__': - CryptoconditionsHeirTest().main() diff --git a/qa/rpc-tests/cryptoconditions_oracles.py b/qa/rpc-tests/cryptoconditions_oracles.py deleted file mode 100755 index d07389542..000000000 --- a/qa/rpc-tests/cryptoconditions_oracles.py +++ /dev/null @@ -1,265 +0,0 @@ -#!/usr/bin/env python2 -# Copyright (c) 2016-2023 The Hush developers -# Copyright (c) 2018 SuperNET developers -# Distributed under the GPLv3 software license, see the accompanying -# file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html - -from test_framework.test_framework import CryptoconditionsTestFramework -from test_framework.authproxy import JSONRPCException -from test_framework.util import assert_equal, assert_greater_than, \ - initialize_chain_clean, initialize_chain, start_nodes, start_node, connect_nodes_bi, \ - stop_nodes, sync_blocks, sync_mempools, wait_bitcoinds, rpc_port, assert_raises -from cryptoconditions import assert_success, assert_error, generate_random_string - -class CryptoconditionsOraclesTest(CryptoconditionsTestFramework): - - 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 result.keys(): - if x.find('ddress') > 0: - assert_equal(result[x][0], 'R') - - result = rpc.oraclesaddress(self.pubkey) - assert_success(result) - - for x in result.keys(): - if x.find('ddress') > 0: - assert_equal(result[x][0], 'R') - - # there are no oracles created yet - result = rpc.oracleslist() - assert_equal(result, []) - - # looking up non-existent oracle should return error. - result = rpc.oraclesinfo("none") - assert_error(result) - - # attempt to create oracle with not valid data type should return error - result = rpc.oraclescreate("Test", "Test", "Test") - assert_error(result) - - # attempt to create oracle with description > 32 symbols should return error - too_long_name = generate_random_string(33) - result = rpc.oraclescreate(too_long_name, "Test", "s") - - # attempt to create oracle with description > 4096 symbols should return error - too_long_description = generate_random_string(4100) - result = rpc.oraclescreate("Test", too_long_description, "s") - assert_error(result) - - # need uxtos to create oracle? Crashes if without generate - rpc.generate(2) - - # 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_"+f, "Test_"+f, f) - assert_success(result) - globals()["oracle_{}".format(f)] = self.send_and_mine(result['hex'], rpc) - - # trying to register with negative datafee - result = rpc.oraclesregister(globals()["oracle_{}".format(f)], "-100") - assert_error(result) - - # trying to register with zero datafee - result = rpc.oraclesregister(globals()["oracle_{}".format(f)], "0") - assert_error(result) - - # trying to register with datafee less than txfee - result = rpc.oraclesregister(globals()["oracle_{}".format(f)], "500") - assert_error(result) - - # trying to register valid (unfunded) - result = rpc.oraclesregister(globals()["oracle_{}".format(f)], "10000") - assert_error(result) - - # Fund the oracles - result = rpc.oraclesfund(globals()["oracle_{}".format(f)]) - assert_success(result) - fund_txid = self.send_and_mine(result["hex"], rpc) - assert fund_txid, "got txid" - - # trying to register valid (funded) - result = rpc.oraclesregister(globals()["oracle_{}".format(f)], "10000") - print(f) - assert_success(result) - register_txid = self.send_and_mine(result["hex"], rpc) - assert register_txid, "got txid" - - # TODO: for most of the non valid oraclesregister and oraclessubscribe transactions generating and broadcasting now - # so trying only valid oraclessubscribe atm - result = rpc.oraclessubscribe(globals()["oracle_{}".format(f)], self.pubkey, "1") - assert_success(result) - subscribe_txid = self.send_and_mine(result["hex"], rpc) - assert register_txid, "got txid" - - rpc.generate(1) - - # now lets publish and read valid data for each oracle type - - # s type - result = rpc.oraclesdata(globals()["oracle_{}".format("s")], "05416e746f6e") - assert_success(result) - oraclesdata_s = self.send_and_mine(result["hex"], rpc) - info = rpc.oraclesinfo(globals()["oracle_{}".format("s")]) - batonaddr = info['registered'][0]['baton'] - result = rpc.oraclessamples(globals()["oracle_{}".format("s")], batonaddr, "1") - assert_equal("[u'Anton']", str(result["samples"][0]['data']), "Data match") - - # S type - result = rpc.oraclesdata(globals()["oracle_{}".format("S")], "000161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161") - assert_success(result) - oraclesdata_S = self.send_and_mine(result["hex"], rpc) - info = rpc.oraclesinfo(globals()["oracle_{}".format("S")]) - batonaddr = info['registered'][0]['baton'] - result = rpc.oraclessamples(globals()["oracle_{}".format("S")], batonaddr, "1") - assert_equal("[u'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa']", str(result["samples"][0]['data']), "Data match") - - # d type - result = rpc.oraclesdata(globals()["oracle_{}".format("d")], "0101") - assert_success(result) - # baton - oraclesdata_d = self.send_and_mine(result["hex"], rpc) - info = rpc.oraclesinfo(globals()["oracle_{}".format("d")]) - batonaddr = info['registered'][0]['baton'] - result = rpc.oraclessamples(globals()["oracle_{}".format("d")], batonaddr, "1") - assert_equal("[u'01']", str(result["samples"][0]['data']), "Data match") - - # D type - result = rpc.oraclesdata(globals()["oracle_{}".format("D")], "010001") - assert_success(result) - # baton - oraclesdata_D = self.send_and_mine(result["hex"], rpc) - info = rpc.oraclesinfo(globals()["oracle_{}".format("D")]) - batonaddr = info['registered'][0]['baton'] - result = rpc.oraclessamples(globals()["oracle_{}".format("D")], batonaddr, "1") - assert_equal("[u'01']", str(result["samples"][0]['data']), "Data match") - - # c type - result = rpc.oraclesdata(globals()["oracle_{}".format("c")], "ff") - assert_success(result) - # baton - oraclesdata_c = self.send_and_mine(result["hex"], rpc) - info = rpc.oraclesinfo(globals()["oracle_{}".format("c")]) - batonaddr = info['registered'][0]['baton'] - result = rpc.oraclessamples(globals()["oracle_{}".format("c")], batonaddr, "1") - assert_equal("[u'-1']", str(result["samples"][0]['data']), "Data match") - - # C type - result = rpc.oraclesdata(globals()["oracle_{}".format("C")], "ff") - assert_success(result) - # baton - oraclesdata_C = self.send_and_mine(result["hex"], rpc) - info = rpc.oraclesinfo(globals()["oracle_{}".format("C")]) - batonaddr = info['registered'][0]['baton'] - result = rpc.oraclessamples(globals()["oracle_{}".format("C")], batonaddr, "1") - assert_equal("[u'255']", str(result["samples"][0]['data']), "Data match") - - # t type - result = rpc.oraclesdata(globals()["oracle_{}".format("t")], "ffff") - assert_success(result) - # baton - oraclesdata_t = self.send_and_mine(result["hex"], rpc) - info = rpc.oraclesinfo(globals()["oracle_{}".format("t")]) - batonaddr = info['registered'][0]['baton'] - result = rpc.oraclessamples(globals()["oracle_{}".format("t")], batonaddr, "1") - assert_equal("[u'-1']", str(result["samples"][0]['data']), "Data match") - - # T type - result = rpc.oraclesdata(globals()["oracle_{}".format("T")], "ffff") - assert_success(result) - # baton - oraclesdata_T = self.send_and_mine(result["hex"], rpc) - info = rpc.oraclesinfo(globals()["oracle_{}".format("T")]) - batonaddr = info['registered'][0]['baton'] - result = rpc.oraclessamples(globals()["oracle_{}".format("T")], batonaddr, "1") - assert_equal("[u'65535']", str(result["samples"][0]['data']), "Data match") - - # i type - result = rpc.oraclesdata(globals()["oracle_{}".format("i")], "ffffffff") - assert_success(result) - # baton - oraclesdata_i = self.send_and_mine(result["hex"], rpc) - info = rpc.oraclesinfo(globals()["oracle_{}".format("i")]) - batonaddr = info['registered'][0]['baton'] - result = rpc.oraclessamples(globals()["oracle_{}".format("i")], batonaddr, "1") - assert_equal("[u'-1']", str(result["samples"][0]['data']), "Data match") - - # I type - result = rpc.oraclesdata(globals()["oracle_{}".format("I")], "ffffffff") - assert_success(result) - # baton - oraclesdata_I = self.send_and_mine(result["hex"], rpc) - info = rpc.oraclesinfo(globals()["oracle_{}".format("I")]) - batonaddr = info['registered'][0]['baton'] - result = rpc.oraclessamples(globals()["oracle_{}".format("I")], batonaddr, "1") - assert_equal("[u'4294967295']", str(result["samples"][0]['data']), "Data match") - - # l type - result = rpc.oraclesdata(globals()["oracle_{}".format("l")], "00000000ffffffff") - assert_success(result) - # baton - oraclesdata_l = self.send_and_mine(result["hex"], rpc) - info = rpc.oraclesinfo(globals()["oracle_{}".format("l")]) - batonaddr = info['registered'][0]['baton'] - result = rpc.oraclessamples(globals()["oracle_{}".format("l")], batonaddr, "1") - assert_equal("[u'-4294967296']", str(result["samples"][0]['data']), "Data match") - - # L type - result = rpc.oraclesdata(globals()["oracle_{}".format("L")], "00000000ffffffff") - assert_success(result) - # baton - oraclesdata_L = self.send_and_mine(result["hex"], rpc) - info = rpc.oraclesinfo(globals()["oracle_{}".format("L")]) - batonaddr = info['registered'][0]['baton'] - result = rpc.oraclessamples(globals()["oracle_{}".format("L")], batonaddr, "1") - assert_equal("[u'18446744069414584320']", str(result["samples"][0]['data']), "Data match") - - # h type - result = rpc.oraclesdata(globals()["oracle_{}".format("h")], "00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff") - assert_success(result) - # baton - oraclesdata_h = self.send_and_mine(result["hex"], rpc) - info = rpc.oraclesinfo(globals()["oracle_{}".format("h")]) - batonaddr = info['registered'][0]['baton'] - result = rpc.oraclessamples(globals()["oracle_{}".format("h")], batonaddr, "1") - assert_equal("[u'ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000']", str(result["samples"][0]['data']), "Data match") - - # Ihh type - result = rpc.oraclesdata(globals()["oracle_{}".format("Ihh")], "ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff") - assert_success(result) - # baton - oraclesdata_Ihh = self.send_and_mine(result["hex"], rpc) - info = rpc.oraclesinfo(globals()["oracle_{}".format("Ihh")]) - batonaddr = info['registered'][0]['baton'] - result = rpc.oraclessamples(globals()["oracle_{}".format("Ihh")], batonaddr, "1") - print(result) - assert_equal("[u'4294967295', u'ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000', u'ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000']", str(result["samples"][0]['data']), "Data match") - - def run_test(self): - print("Mining blocks...") - rpc = self.nodes[0] - rpc1 = self.nodes[1] - # utxos from block 1 become mature in block 101 - if not self.options.noshutdown: - rpc.generate(101) - self.sync_all() - rpc.getinfo() - rpc1.getinfo() - # this corresponds to -pubkey above - print("Importing privkeys") - rpc.importprivkey(self.privkey) - rpc1.importprivkey(self.privkey1) - self.run_oracles_tests() - - -if __name__ == '__main__': - CryptoconditionsOraclesTest().main() diff --git a/qa/rpc-tests/cryptoconditions_rewards.py b/qa/rpc-tests/cryptoconditions_rewards.py deleted file mode 100755 index 2144ba673..000000000 --- a/qa/rpc-tests/cryptoconditions_rewards.py +++ /dev/null @@ -1,149 +0,0 @@ -#!/usr/bin/env python2 -# Copyright (c) 2016-2023 The Hush developers -# Copyright (c) 2018 SuperNET developers -# Distributed under the GPLv3 software license, see the accompanying -# file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html - - -from test_framework.test_framework import CryptoconditionsTestFramework -from test_framework.authproxy import JSONRPCException -from test_framework.util import assert_equal, assert_greater_than, \ - initialize_chain_clean, initialize_chain, start_nodes, start_node, connect_nodes_bi, \ - stop_nodes, sync_blocks, sync_mempools, wait_bitcoinds, rpc_port, assert_raises -from cryptoconditions import assert_success, assert_error, generate_random_string - - -class CryptoconditionsRewardsTest(CryptoconditionsTestFramework): - - def run_rewards_tests(self): - - rpc = self.nodes[0] - - result = rpc.rewardsaddress() - for x in result.keys(): - if x.find('ddress') > 0: - assert_equal(result[x][0], 'R') - - result = rpc.rewardsaddress(self.pubkey) - for x in result.keys(): - if x.find('ddress') > 0: - assert_equal(result[x][0], 'R') - - # no rewards yet - result = rpc.rewardslist() - assert_equal(result, []) - - # looking up non-existent reward should return error - result = rpc.rewardsinfo("none") - assert_error(result) - - # creating rewards plan with name > 8 chars, should return error - result = rpc.rewardscreatefunding("STUFFSTUFF", "7777", "25", "0", "10", "10") - assert_error(result) - - # creating rewards plan with 0 funding - result = rpc.rewardscreatefunding("STUFF", "0", "25", "0", "10", "10") - assert_error(result) - - # creating rewards plan with 0 maxdays - result = rpc.rewardscreatefunding("STUFF", "7777", "25", "0", "10", "0") - assert_error(result) - - # creating rewards plan with > 25% APR - result = rpc.rewardscreatefunding("STUFF", "7777", "30", "0", "10", "10") - assert_error(result) - - # creating valid rewards plan - result = rpc.rewardscreatefunding("STUFF", "7777", "25", "0", "10", "10") - assert result['hex'], 'got raw xtn' - fundingtxid = rpc.sendrawtransaction(result['hex']) - assert fundingtxid, 'got txid' - - # confirm the above xtn - rpc.generate(1) - result = rpc.rewardsinfo(fundingtxid) - assert_success(result) - assert_equal(result['name'], 'STUFF') - assert_equal(result['APR'], "25.00000000") - assert_equal(result['minseconds'], 0) - assert_equal(result['maxseconds'], 864000) - assert_equal(result['funding'], "7777.00000000") - assert_equal(result['mindeposit'], "10.00000000") - assert_equal(result['fundingtxid'], fundingtxid) - - # checking if new plan in rewardslist - result = rpc.rewardslist() - assert_equal(result[0], fundingtxid) - - # creating reward plan with already existing name, should return error - result = rpc.rewardscreatefunding("STUFF", "7777", "25", "0", "10", "10") - assert_error(result) - - # add funding amount must be positive - result = rpc.rewardsaddfunding("STUFF", fundingtxid, "-1") - assert_error(result) - - # add funding amount must be positive - result = rpc.rewardsaddfunding("STUFF", fundingtxid, "0") - assert_error(result) - - # adding valid funding - result = rpc.rewardsaddfunding("STUFF", fundingtxid, "555") - addfundingtxid = self.send_and_mine(result['hex'], rpc) - assert addfundingtxid, 'got funding txid' - - # checking if funding added to rewardsplan - result = rpc.rewardsinfo(fundingtxid) - assert_equal(result['funding'], "8332.00000000") - - # trying to lock funds, locking funds amount must be positive - result = rpc.rewardslock("STUFF", fundingtxid, "-5") - assert_error(result) - - # trying to lock funds, locking funds amount must be positive - result = rpc.rewardslock("STUFF", fundingtxid, "0") - assert_error(result) - - # trying to lock less than the min amount is an error - result = rpc.rewardslock("STUFF", fundingtxid, "7") - assert_error(result) - - # locking funds in rewards plan - result = rpc.rewardslock("STUFF", fundingtxid, "10") - assert_success(result) - locktxid = result['hex'] - assert locktxid, "got lock txid" - - # locktxid has not been broadcast yet - result = rpc.rewardsunlock("STUFF", fundingtxid, locktxid) - assert_error(result) - - # broadcast xtn - txid = rpc.sendrawtransaction(locktxid) - assert txid, 'got txid from sendrawtransaction' - - # confirm the xtn above - rpc.generate(1) - - # will not unlock since reward amount is less than tx fee - result = rpc.rewardsunlock("STUFF", fundingtxid, locktxid) - assert_error(result) - - def run_test(self): - print("Mining blocks...") - rpc = self.nodes[0] - rpc1 = self.nodes[1] - # utxos from block 1 become mature in block 101 - if not self.options.noshutdown: - rpc.generate(101) - self.sync_all() - rpc.getinfo() - rpc1.getinfo() - # this corresponds to -pubkey above - print("Importing privkeys") - rpc.importprivkey(self.privkey) - rpc1.importprivkey(self.privkey1) - self.run_rewards_tests() - -if __name__ == '__main__': - CryptoconditionsRewardsTest().main() diff --git a/qa/rpc-tests/cryptoconditions_token.py b/qa/rpc-tests/cryptoconditions_token.py deleted file mode 100755 index 3c00279e8..000000000 --- a/qa/rpc-tests/cryptoconditions_token.py +++ /dev/null @@ -1,264 +0,0 @@ -#!/usr/bin/env python2 -# Copyright (c) 2016-2023 The Hush developers -# Copyright (c) 2018 SuperNET developers -# Distributed under the GPLv3 software license, see the accompanying -# file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html - - -from test_framework.test_framework import CryptoconditionsTestFramework -from test_framework.authproxy import JSONRPCException -from test_framework.util import assert_equal, assert_greater_than, \ - initialize_chain_clean, initialize_chain, start_nodes, start_node, connect_nodes_bi, \ - stop_nodes, sync_blocks, sync_mempools, wait_bitcoinds, rpc_port, assert_raises -from cryptoconditions import assert_success, assert_error, generate_random_string - - -class CryptoconditionsTokenTest(CryptoconditionsTestFramework): - - def run_token_tests(self): - - rpc = self.nodes[0] - rpc1 = self.nodes[1] - - result = rpc.tokenaddress() - assert_success(result) - for x in result.keys(): - if x.find('ddress') > 0: - assert_equal(result[x][0], 'R') - - result = rpc.tokenaddress(self.pubkey) - assert_success(result) - for x in result.keys(): - if x.find('ddress') > 0: - assert_equal(result[x][0], 'R') - - result = rpc.assetsaddress() - assert_success(result) - for x in result.keys(): - if x.find('ddress') > 0: - assert_equal(result[x][0], 'R') - - result = rpc.assetsaddress(self.pubkey) - assert_success(result) - for x in result.keys(): - if x.find('ddress') > 0: - assert_equal(result[x][0], 'R') - - # there are no tokens created yet - result = rpc.tokenlist() - assert_equal(result, []) - - # trying to create token with negative supply - result = rpc.tokencreate("NUKE", "-1987420", "no bueno supply") - assert_error(result) - - # creating token with name more than 32 chars - result = rpc.tokencreate("NUKE123456789012345678901234567890", "1987420", "name too long") - assert_error(result) - - # creating valid token - result = rpc.tokencreate("DUKE", "1987.420", "Duke's custom token") - assert_success(result) - - tokenid = self.send_and_mine(result['hex'], rpc) - - result = rpc.tokenlist() - assert_equal(result[0], tokenid) - - # there are no token orders yet - result = rpc.tokenorders(tokenid) - assert_equal(result, []) - - # getting token balance for non existing tokenid - result = rpc.tokenbalance(self.pubkey) - assert_error(result) - - # get token balance for token with pubkey - result = rpc.tokenbalance(tokenid, self.pubkey) - assert_success(result) - assert_equal(result['balance'], 198742000000) - assert_equal(result['tokenid'], tokenid) - - # get token balance for token without pubkey - result = rpc.tokenbalance(tokenid) - assert_success(result) - assert_equal(result['balance'], 198742000000) - assert_equal(result['tokenid'], tokenid) - - # this is not a valid assetid - result = rpc.tokeninfo(self.pubkey) - assert_error(result) - - # check tokeninfo for valid token - result = rpc.tokeninfo(tokenid) - assert_success(result) - assert_equal(result['tokenid'], tokenid) - assert_equal(result['owner'], self.pubkey) - assert_equal(result['name'], "DUKE") - assert_equal(result['supply'], 198742000000) - assert_equal(result['description'], "Duke's custom token") - - # invalid numtokens ask - result = rpc.tokenask("-1", tokenid, "1") - assert_error(result) - - # invalid numtokens ask - result = rpc.tokenask("0", tokenid, "1") - assert_error(result) - - # invalid price ask - result = rpc.tokenask("1", tokenid, "-1") - assert_error(result) - - # invalid price ask - result = rpc.tokenask("1", tokenid, "0") - assert_error(result) - - # invalid tokenid ask - result = rpc.tokenask("100", "deadbeef", "1") - assert_error(result) - - # valid ask - tokenask = rpc.tokenask("100", tokenid, "7.77") - tokenaskhex = tokenask['hex'] - tokenaskid = self.send_and_mine(tokenask['hex'], rpc) - result = rpc.tokenorders(tokenid) - order = result[0] - assert order, "found order" - - # invalid ask fillunits - result = rpc.tokenfillask(tokenid, tokenaskid, "0") - assert_error(result) - - # invalid ask fillunits - result = rpc.tokenfillask(tokenid, tokenaskid, "-777") - assert_error(result) - - # valid ask fillunits - fillask = rpc.tokenfillask(tokenid, tokenaskid, "777") - result = self.send_and_mine(fillask['hex'], rpc) - txid = result[0] - assert txid, "found txid" - - # should be no token orders - result = rpc.tokenorders(tokenid) - assert_equal(result, []) - - # checking ask cancellation - testorder = rpc.tokenask("100", tokenid, "7.77") - testorderid = self.send_and_mine(testorder['hex'], rpc) - # from other node (ensuring that second node have enough balance to cover txfee - # to get the actual error - not "not enough balance" one - rpc.sendtoaddress(rpc1.getnewaddress(), 1) - rpc.sendtoaddress(rpc1.getnewaddress(), 1) - rpc.generate(2) - self.sync_all() - result = rpc1.getbalance() - assert_greater_than(result, 0.1) - - result = rpc1.tokencancelask(tokenid, testorderid) - assert_error(result) - - # from valid node - cancel = rpc.tokencancelask(tokenid, testorderid) - self.send_and_mine(cancel["hex"], rpc) - result = rpc.tokenorders(tokenid) - assert_equal(result, []) - - - # invalid numtokens bid - result = rpc.tokenbid("-1", tokenid, "1") - assert_error(result) - - # invalid numtokens bid - result = rpc.tokenbid("0", tokenid, "1") - assert_error(result) - - # invalid price bid - result = rpc.tokenbid("1", tokenid, "-1") - assert_error(result) - - # invalid price bid - result = rpc.tokenbid("1", tokenid, "0") - assert_error(result) - - # invalid tokenid bid - result = rpc.tokenbid("100", "deadbeef", "1") - assert_error(result) - - tokenbid = rpc.tokenbid("100", tokenid, "10") - tokenbidhex = tokenbid['hex'] - tokenbidid = self.send_and_mine(tokenbid['hex'], rpc) - result = rpc.tokenorders(tokenid) - order = result[0] - assert order, "found order" - - # invalid bid fillunits - result = rpc.tokenfillbid(tokenid, tokenbidid, "0") - assert_error(result) - - # invalid bid fillunits - result = rpc.tokenfillbid(tokenid, tokenbidid, "-777") - assert_error(result) - - # valid bid fillunits - fillbid = rpc.tokenfillbid(tokenid, tokenbidid, "1000") - result = self.send_and_mine(fillbid['hex'], rpc) - txid = result[0] - assert txid, "found txid" - - # should be no token orders - result = rpc.tokenorders(tokenid) - assert_equal(result, []) - - # checking bid cancellation - testorder = rpc.tokenbid("100", tokenid, "7.77") - testorderid = self.send_and_mine(testorder['hex'], rpc) - - # from other node - result = rpc1.getbalance() - assert_greater_than(result, 0.1) - - result = rpc1.tokencancelbid(tokenid, testorderid) - assert_error(result) - - # from valid node - cancel = rpc.tokencancelbid(tokenid, testorderid) - self.send_and_mine(cancel["hex"], rpc) - result = rpc.tokenorders(tokenid) - assert_equal(result, []) - - # invalid token transfer amount (have to add status to CC code!) - randompubkey = "021a559101e355c907d9c553671044d619769a6e71d624f68bfec7d0afa6bd6a96" - result = rpc.tokentransfer(tokenid,randompubkey,"0") - assert_error(result) - - # invalid token transfer amount (have to add status to CC code!) - result = rpc.tokentransfer(tokenid,randompubkey,"-1") - assert_error(result) - - # valid token transfer - sendtokens = rpc.tokentransfer(tokenid,randompubkey,"1") - self.send_and_mine(sendtokens["hex"], rpc) - result = rpc.tokenbalance(tokenid,randompubkey) - assert_equal(result["balance"], 1) - - def run_test(self): - print("Mining blocks...") - rpc = self.nodes[0] - rpc1 = self.nodes[1] - # utxos from block 1 become mature in block 101 - if not self.options.noshutdown: - rpc.generate(101) - self.sync_all() - rpc.getinfo() - rpc1.getinfo() - # this corresponds to -pubkey above - print("Importing privkeys") - rpc.importprivkey(self.privkey) - rpc1.importprivkey(self.privkey1) - self.run_token_tests() - - -if __name__ == '__main__': - CryptoconditionsTokenTest().main() diff --git a/src/Makefile.am b/src/Makefile.am index f914300de..a12421a1e 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -2,7 +2,7 @@ # Distributed under the GPLv3 software license, see the accompanying # file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html -DIST_SUBDIRS = secp256k1 univalue cryptoconditions +DIST_SUBDIRS = secp256k1 univalue AM_LDFLAGS = $(PTHREAD_CFLAGS) $(LIBTOOL_LDFLAGS) $(SAN_LDFLAGS) $(HARDENED_LDFLAGS) AM_CXXFLAGS = $(SAN_CXXFLAGS) $(HARDENED_CXXFLAGS) $(ERROR_CXXFLAGS) @@ -35,9 +35,6 @@ BITCOIN_INCLUDES=-I$(builddir) -I$(builddir)/obj $(BDB_CPPFLAGS) $(BOOST_CPPFLAG BITCOIN_INCLUDES += -I$(srcdir)/secp256k1/include BITCOIN_INCLUDES += -I$(srcdir)/cc/includes -BITCOIN_INCLUDES += -I$(srcdir)/cryptoconditions/include -BITCOIN_INCLUDES += -I$(srcdir)/cryptoconditions/src -BITCOIN_INCLUDES += -I$(srcdir)/cryptoconditions/src/asn BITCOIN_INCLUDES += -I$(srcdir)/univalue/include BITCOIN_INCLUDES += -I$(srcdir)/leveldb/include @@ -57,7 +54,6 @@ LIBBITCOIN_CLI=libbitcoin_cli.a LIBBITCOIN_UTIL=libbitcoin_util.a LIBBITCOIN_CRYPTO=crypto/libbitcoin_crypto.a LIBSECP256K1=secp256k1/libsecp256k1.la -LIBCRYPTOCONDITIONS=cryptoconditions/libcryptoconditions_core.la LIBUNIVALUE=univalue/libunivalue.la LIBZCASH=libzcash.a LIBHUSH=libhush.a @@ -76,9 +72,6 @@ $(LIBSECP256K1): $(wildcard secp256k1/src/*) $(wildcard secp256k1/include/*) $(LIBUNIVALUE): $(wildcard univalue/lib/*) $(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -C $(@D) $(@F) OPTFLAGS="-O2 -march=$(PLATFORM_VARIANT) -g " -$(LIBCRYPTOCONDITIONS): $(wildcard cryptoconditions/src/*) $(wildcard cryptoconditions/include/*) - $(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -C $(@D) $(@F) OPTFLAGS="-O2 -march=$(PLATFORM_VARIANT) -g " - # Make is not made aware of per-object dependencies to avoid limiting building parallelization # But to build the less dependent modules first, we manually select their order here: EXTRA_LIBRARIES += \ @@ -480,7 +473,6 @@ hushd_LDADD = \ $(LIBLEVELDB) \ $(LIBMEMENV) \ $(LIBSECP256K1) \ - $(LIBCRYPTOCONDITIONS) \ $(LIBRANDOMX) if ENABLE_WALLET @@ -558,7 +550,6 @@ wallet_utility_LDADD = \ $(CRYPTO_LIBS) \ $(LIBZCASH) \ $(LIBZCASH_LIBS)\ - $(LIBCRYPTOCONDITIONS) \ $(LIBRANDOMX) endif @@ -581,7 +572,6 @@ hush_tx_LDADD = \ $(LIBHUSH) \ $(LIBBITCOIN_CRYPTO) \ $(LIBZCASH_LIBS) \ - $(LIBCRYPTOCONDITIONS) \ $(LIBRANDOMX) hush_tx_LDADD += $(BOOST_LIBS) $(CRYPTO_LIBS) @@ -633,7 +623,7 @@ endif libzcashconsensus_la_LDFLAGS = $(AM_LDFLAGS) -no-undefined $(RELDFLAGS) libzcashconsensus_la_LIBADD = $(LIBSECP256K1) -libzcashconsensus_la_CPPFLAGS = $(AM_CPPFLAGS) -I$(builddir)/obj -I$(srcdir)/secp256k1/include -I$(srcdir)/cryptoconditions/include -DBUILD_BITCOIN_INTERNAL +libzcashconsensus_la_CPPFLAGS = $(AM_CPPFLAGS) -I$(builddir)/obj -I$(srcdir)/secp256k1/include -DBUILD_BITCOIN_INTERNAL libzcashconsensus_la_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS) endif diff --git a/src/cc/CC_made_easy.md b/src/cc/CC_made_easy.md deleted file mode 100644 index 146b7389c..000000000 --- a/src/cc/CC_made_easy.md +++ /dev/null @@ -1,715 +0,0 @@ -// Copyright (c) 2016-2023 The Hush developers -/****************************************************************************** - * Copyright © 2014-2019 The SuperNET Developers. * - * * - * See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at * - * the top-level directory of this distribution for the individual copyright * - * holder information and the developer policies on copyright and licensing. * - * * - * Unless otherwise agreed in a custom licensing agreement, no part of the * - * SuperNET software, including this file may be copied, modified, propagated * - * or distributed except according to the terms contained in the LICENSE file * - * * - * Removal or modification of this copyright notice is prohibited. * - * * - ******************************************************************************/ - -How to write utxo based CryptoConditions contracts for HUSH chains -by jl777 - -This is not the only smart contracts methodology that is possible to build on top of OP_CHECKCRYPTOCONDITION, just the first one. All the credit for getting OP_CHECKCRYPTOCONDITION working in the Hush codebase goes to @libscott. I am just hooking into the code that he made and tried to make it just a little easier to make new contracts. - -There is probably some fancy marketing name to use, but for now, I will just call it "CC contract" for short, knowing that it is not 100% technically accurate as the CryptoConditions aspect is not really the main attribute. However, the HUSH contracts were built to make the CryptoConditions codebase that was integrated into it to be more accessible. - -Since CC contracts run native C/C++ code, it is turing complete and that means that any contract that is possible to do on any other platform will be possible to create via CC contract. - -utxo based contracts are a bit harder to start writing than for balance based contracts. However, they are much more secure as they leverage the existing bitcoin utxo system. That makes it much harder to have bugs that issue a zillion new coins from a bug, since all the CC contract operations needs to also obey the existing bitcoin utxo protocol. - -This document will be heavily example based so it will utilize many of the existing reference CC contracts. After understanding this document, you should be in a good position to start creating either a new CC contract to be integrated into hushd or to make rpc based dapps directly. - -Chapter 0 - Bitcoin Protocol Basics -There are many aspects of the bitcoin protocol that isnt needed to understand the CC contracts dependence on it. Such details will not be discussed. The primary aspect is the utxo, unspent transaction output. Just a fancy name for txid/vout, so when you sendtoaddress some coins, it creates a txid and the first output is vout.0, combine it and txid/0 is a specific utxo. - -Of course, to understand even this level of detail requires that you understand what a txid is, but there are plenty of reference materials on that. It is basically the 64 char long set of letters and numbers that you get when you send funds. - -Implicit with the utxo is that it prevents double spends. Once you spend a utxo, you cant spend it again. This is quite an important characteristic and while advanced readers will point out chain reorgs can allow a double spend, we will not confuse the issue with such details. The important thing is that given a blockchain at a specific height's blockhash, you can know if a txid/vout has been spent or not. - -There are also the transactions that are in memory waiting to be mined, the mempool. And it is possible for the utxo to be spent by a tx in the mempool. However since it isnt confirmed yet, it is still unspent at the current height, even if we are pretty sure it will be spent in the next block. - -A useful example is to think about a queue of people lined up to get into an event. They need to have a valid ticket and also to get into the queue. After some time passes, they get their ticket stamped and allowed into the event. - -In the utxo case, the ticket is the spending transaction and the event is the confirmed blockchain. The queue is the mempool. - - -Chapter 1 - OP_CHECKCRYPTOCONDITION -In the prior chapter the utxo was explained. However, the specific mechanism used to send a payment was not explained. Contrary to what most people might think, on the blockchain there are not entries that say "pay X amount to address". Instead what exists is a bitcoin script that must be satisfied in order for the funds to be able to be spent. - -Originally, there was the pay to pubkey script: - - -About as simple of a payment script that you can get. Basically the pubkey's signature is checked and if it is valid, you get to spend it. One problem satoshi realized was that with Quantum Computers such payment scripts are vulnerable! So, he made a way to have a cold address, ie. an address whose pubkey isnt known. At least it isnt known until it is spent, so it is only Quantum resistant prior to the first spend. This line of reasoning is why we have one time use addresses and a new change address for each transaction. Maybe in some ways, this is too forward thinking as it makes things a lot more confusing to use and easier to lose track of all the required private keys. - -However, it is here to stay and its script is: - - -With this, the blockchain has what maps to "pay to address", just that the address is actually a base58 encoded (prefix + pubkeyhash). Hey, if it wasnt complicated, it would be easy! - -In order to spend a p2pkh (pay to pubkey hash) utxo, you need to divulge the pubkey in addition to having a valid signature. After the first spend from an address, its security is degraded to p2pk (pay to pubkey) as its pubkey is now known. The net result is that each reused address takes 25 extra bytes on the blockchain, and that is why for addresses that are expected to be reused, I just use the p2pk script. - -Originally, bitcoin allowed any type of script opcodes to be used directly. The problem was some of them caused problems and satoshi decided to disable them and only allow standard forms of payments. Thus the p2pk and p2pkh became 99%+ of bitcoin transactions. However, going from having a fully scriptable language that can create countless payment scripts (and bugs!), to having just 2... well it was a "short term" limitation. It did last for some years but eventually a compromise p2sh script was allowed to be standard. This is a pay to script hash, so it can have a standard format as the normal p2pkh, but have infinitely more flexibility. - -