def global_freezing(self): self.log.info("Testing global freezing...") n0, n1 = self.nodes[0], self.nodes[1] base_asset_name = "FROZEN_GLOBAL" asset_name = f"${base_asset_name}" qty = 10000 verifier = "true" address = n0.getnewaddress() spl_change_address = n0.getnewaddress() n0.issue(base_asset_name) n0.generate(1) n0.issuerestrictedasset(asset_name, qty, verifier, address) n0.generate(1) # pre-freeze validation assert_does_not_contain(asset_name, n0.listglobalrestrictions()) assert not n0.checkglobalrestriction(asset_name) assert_equal(10000, n0.listassetbalancesbyaddress(address)[asset_name]) change_address = n0.getnewaddress() n0.transferfromaddress(asset_name, address, 1000, n1.getnewaddress(), "", "", "", change_address) n0.generate(1) self.sync_all() assert_equal(9000, n0.listassetbalancesbyaddress(change_address)[asset_name]) assert_equal(1000, n1.listmyassets()[asset_name]) address = change_address # assets have moved assert_raises_rpc_error(None, "Invalid Splendid change address", n0.freezerestrictedasset, asset_name, "garbagechangeaddress") n0.freezerestrictedasset(asset_name, spl_change_address) # Can only freeze once! assert_raises_rpc_error(-26, "Freezing transaction already in mempool", n0.freezerestrictedasset, asset_name, spl_change_address) n0.generate(1) assert_raises_rpc_error(None, "global-freeze-when-already-frozen", n0.freezerestrictedasset, asset_name, spl_change_address) # post-freeze validation assert_contains(asset_name, n0.listglobalrestrictions()) assert n0.checkglobalrestriction(asset_name) assert_raises_rpc_error(-8, "restricted asset has been globally frozen", n0.transferfromaddress, asset_name, address, 1000, n1.getnewaddress()) assert_raises_rpc_error(None, "Invalid Splendid change address", n0.unfreezerestrictedasset, asset_name, "garbagechangeaddress") n0.unfreezerestrictedasset(asset_name, spl_change_address) # Can only un-freeze once! assert_raises_rpc_error(-26, "Unfreezing transaction already in mempool", n0.unfreezerestrictedasset, asset_name, spl_change_address) n0.generate(1) assert_raises_rpc_error(None, "global-unfreeze-when-not-frozen", n0.unfreezerestrictedasset, asset_name, spl_change_address) # post-unfreeze validation assert_does_not_contain(asset_name, n0.listglobalrestrictions()) assert not n0.checkglobalrestriction(asset_name) assert_equal(9000, n0.listassetbalancesbyaddress(address)[asset_name]) change_address = n0.getnewaddress() n0.transferfromaddress(asset_name, address, 1000, n1.getnewaddress(), "", "", "", change_address) n0.generate(1) self.sync_all() assert_equal(8000, n0.listassetbalancesbyaddress(change_address)[asset_name]) assert_equal(2000, n1.listmyassets()[asset_name])
def freezing(self): self.log.info("Testing freezing...") n0, n1 = self.nodes[0], self.nodes[1] base_asset_name = "FROZEN_TM" asset_name = f"${base_asset_name}" qty = 11000 verifier = "true" address = n0.getnewaddress() safe_address = n0.getnewaddress() spl_change_address = n0.getnewaddress() n0.issue(base_asset_name) n0.generate(1) n0.issuerestrictedasset(asset_name, qty, verifier, address) n0.generate(1) # squirrel some away change_address = n0.getnewaddress() n0.transferfromaddress(asset_name, address, 1000, safe_address, "", "", "", change_address) n0.generate(1) address = change_address # pre-freezing verification assert_does_not_contain(asset_name, n0.listaddressrestrictions(address)) assert not n0.checkaddressrestriction(address, address) assert_equal(10000, n0.listassetbalancesbyaddress(address)[asset_name]) # Isolate this test from other freezing on n0... def viewmyrestrictedaddresses(): return list(filter(lambda x: asset_name == x['Asset Name'], n0.viewmyrestrictedaddresses())) # viewmyrestrictedaddresses assert_equal(0, len(viewmyrestrictedaddresses())) change_address = n0.getnewaddress() n0.transferfromaddress(asset_name, address, 1000, n1.getnewaddress(), "", "", "", change_address) n0.generate(1) self.sync_all() assert_equal(9000, n0.listassetbalancesbyaddress(change_address)[asset_name]) assert_equal(1000, n1.listmyassets()[asset_name]) address = change_address # assets have moved assert_raises_rpc_error(None, "Invalid Splendid address", n0.freezeaddress, asset_name, "garbageaddress") assert_raises_rpc_error(None, "Invalid Splendid change address", n0.freezeaddress, asset_name, address, "garbagechangeaddress") n0.freezeaddress(asset_name, address, spl_change_address) n0.generate(1) assert_raises_rpc_error(-32600, "freeze-address-when-already-frozen", n0.freezeaddress, asset_name, address, spl_change_address) # post-freezing verification assert_contains(asset_name, n0.listaddressrestrictions(address)) assert n0.checkaddressrestriction(address, asset_name) # viewmyrestrictedaddresses restrictions = viewmyrestrictedaddresses() assert_equal(1, len(restrictions)) r = restrictions[0] assert_equal(address, r['Address']) assert_equal(asset_name, r['Asset Name']) assert_happening(r['Restricted']) assert_raises_rpc_error(-8, "No asset outpoints are selected from the given address", n0.transferfromaddress, asset_name, address, 1000, n1.getnewaddress()) assert_raises_rpc_error(None, "Invalid Splendid address", n0.unfreezeaddress, asset_name, "garbageaddress") assert_raises_rpc_error(None, "Invalid Splendid change address", n0.unfreezeaddress, asset_name, address, "garbagechangeaddress") n0.unfreezeaddress(asset_name, address, spl_change_address) n0.generate(1) assert_raises_rpc_error(-32600, "unfreeze-address-when-not-frozen", n0.unfreezeaddress, asset_name, address, spl_change_address) # post-unfreezing verification assert_does_not_contain(asset_name, n0.listaddressrestrictions(address)) assert not n0.checkaddressrestriction(address, asset_name) assert_equal(9000, n0.listassetbalancesbyaddress(address)[asset_name]) # viewmyrestrictedaddresses restrictions = viewmyrestrictedaddresses() assert_equal(1, len(restrictions)) r = restrictions[0] assert_equal(address, r['Address']) assert_equal(asset_name, r['Asset Name']) assert_happening(r['Derestricted']) change_address = n0.getnewaddress() n0.transferfromaddress(asset_name, address, 1000, n1.getnewaddress(), "", "", "", change_address) n0.generate(1) self.sync_all() assert_equal(8000, n0.listassetbalancesbyaddress(change_address)[asset_name]) assert_equal(2000, n1.listmyassets()[asset_name])
def run_test(self): nodes = self.nodes # BIP39 list should contain 2048 words assert_equal(len(bip39_english), 2048) # Node 0 has 12 words and a passphrase self.log.info("Testing BIP-44 Word-Lists and passphrases") assert_equal(len(nodes[0].getmywords()['word_list'].split(' ')), 12) # Contains 12 words assert_equal(nodes[0].getmywords()['word_list'], MNEMONIC_0) # Word list matches assert_equal(nodes[0].getmywords()['passphrase'], MNEMONIC_PASS_0) # Passphrase matches # Node 1 has 12 words but no passphrase assert_equal(len(nodes[1].getmywords()['word_list'].split(' ')), 12) # Contains 12 words assert_equal(nodes[1].getmywords()['word_list'], MNEMONIC_1) # Word list matches assert_does_not_contain(str(nodes[1].getmywords()), 'passphrase') # Passphrase does not exist # Node 2 was not created with specific 12 words (using random-auto-generated), and a passphrase assert_equal(len(nodes[2].getmywords()['word_list'].split(' ')), 12) # Contains 12 words assert(nodes[2].getmywords()['word_list'] != nodes[3].getmywords()['word_list']) # auto-generated word-lists should not match assert_equal(nodes[2].getmywords()['passphrase'], MNEMONIC_PASS_2) # Node 3 was not created with specific 12 words (using random-auto-generated), and no passphrase assert_equal(len(nodes[3].getmywords()['word_list'].split(' ')), 12) # Contains 12 words assert_does_not_contain(str(nodes[3].getmywords()), 'passphrase') # Passphrase does not exist # Nodes 4 & 5 are not BIP44 and should not have 12-words or passphrase assert_raises_rpc_error(-4, "Wallet doesn't have 12 words.", nodes[4].getmywords) assert_raises_rpc_error(-4, "Wallet doesn't have 12 words.", nodes[5].getmywords) # Cannot change from a non-BIP44 to a BIP44 wallet self.log.info("Testing that BIP-44 wallets are intransigent") self.stop_node(4) self.stop_node(5) self.start_node(4, extra_args=['-bip44=1', '-mnemonicpassphrase=test4']) self.start_node(5, extra_args=['-bip44=1', '-mnemonic=' + MNEMONIC_0, '-mnemonicpassphrase=' + MNEMONIC_PASS_0]) assert_raises_rpc_error(-4, "Wallet doesn't have 12 words.", nodes[4].getmywords) assert_raises_rpc_error(-4, "Wallet doesn't have 12 words.", nodes[5].getmywords) # Try to add a passphrase to an existing bip44 wallet (should not add passphrase) self.stop_node(3) self.start_node(3, extra_args=['-mnemonicpassphrase=test3']) assert_does_not_contain(str(nodes[3].getmywords()), 'passphrase') # Passphrase does not exist # Cannot change an already created bip44 wallet to a non-bip44 wallet word_list_3 = nodes[3].getmywords()['word_list'] self.stop_node(3) self.start_node(3, extra_args=['-bip44=0']) assert_equal(nodes[3].getmywords()['word_list'], word_list_3) # Word list matches # All 4 bip44 enabled wallets word-lists are in the bip39 word-list self.log.info("Testing that BIP-44 wallets words are valid") word_list_0 = MNEMONIC_0.split(' ') word_list_1 = MNEMONIC_1.split(' ') word_list_2 = nodes[2].getmywords()['word_list'].split(' ') word_list_3 = word_list_3.split(' ') for i in range(0, 12): assert_contains(word_list_0[i], bip39_english) assert_contains(word_list_1[i], bip39_english) assert_contains(word_list_2[i], bip39_english) assert_contains(word_list_3[i], bip39_english) # None of the words should be text-readable in the log files self.log.info("Testing that BIP-44 words aren't text readable") mnemonic_2 = nodes[2].getmywords()['word_list'] mnemonic_3 = nodes[3].getmywords()['word_list'] self.stop_nodes() with open(os.path.join(self.options.tmpdir+"/node0/regtest/", "debug.log"), 'r', encoding='utf8') as f: assert_does_not_contain(MNEMONIC_0, f.read()) with open(os.path.join(self.options.tmpdir+"/node1/regtest/", "debug.log"), 'r', encoding='utf8') as f: assert_does_not_contain(MNEMONIC_1, f.read()) with open(os.path.join(self.options.tmpdir+"/node2/regtest/", "debug.log"), 'r', encoding='utf8') as f: assert_does_not_contain(mnemonic_2, f.read()) with open(os.path.join(self.options.tmpdir+"/node3/regtest/", "debug.log"), 'r', encoding='utf8') as f: assert_does_not_contain(mnemonic_3, f.read()) # But words are readable in a non-encrypted wallet with open(os.path.join(self.options.tmpdir+"/node0/regtest/", "wallet.dat"), 'rb') as f: assert_contains(MNEMONIC_0, str(f.read())) with open(os.path.join(self.options.tmpdir+"/node1/regtest/", "wallet.dat"), 'rb') as f: assert_contains(MNEMONIC_1, str(f.read())) with open(os.path.join(self.options.tmpdir+"/node2/regtest/", "wallet.dat"), 'rb') as f: assert_contains(mnemonic_2, str(f.read())) with open(os.path.join(self.options.tmpdir+"/node3/regtest/", "wallet.dat"), 'rb') as f: assert_contains(mnemonic_3, str(f.read())) # After encryption the words are no longer readable self.log.info("Testing that BIP-44 wallet encryption") self.start_nodes() nodes[0].node_encrypt_wallet("password0") nodes[1].node_encrypt_wallet("password1") nodes[2].node_encrypt_wallet("password2") nodes[3].node_encrypt_wallet("password3") self.stop_nodes() # But words are not readable in an encrypted wallet with open(os.path.join(self.options.tmpdir+"/node0/regtest/", "wallet.dat"), 'rb') as f: assert_does_not_contain(MNEMONIC_0, str(f.read())) with open(os.path.join(self.options.tmpdir+"/node1/regtest/", "wallet.dat"), 'rb') as f: assert_does_not_contain(MNEMONIC_1, str(f.read())) with open(os.path.join(self.options.tmpdir+"/node2/regtest/", "wallet.dat"), 'rb') as f: assert_does_not_contain(mnemonic_2, str(f.read())) with open(os.path.join(self.options.tmpdir+"/node3/regtest/", "wallet.dat"), 'rb') as f: assert_does_not_contain(mnemonic_3, str(f.read())) # But the words are still available using getmywords after entering the passphrase self.start_nodes() assert_raises_rpc_error(-13, "Please enter the wallet passphrase with walletpassphrase first.", nodes[0].getmywords) nodes[0].walletpassphrase("password0", 48) assert_equal(nodes[0].getmywords()['word_list'], MNEMONIC_0) # Word list matches # Words can also be retrieved from the dumpwallet command nodes[0].dumpwallet(os.path.join(self.options.tmpdir+"/node0/regtest/", "dump_wallet_0.txt")) with open(os.path.join(self.options.tmpdir+"/node0/regtest/", "dump_wallet_0.txt"), 'r') as f: assert_contains(MNEMONIC_0, str(f.read()))
def tagging(self): self.log.info("Testing tagging...") n0 = self.nodes[0] tag = "#TAG" address = n0.getnewaddress() change_address = n0.getnewaddress() n0.issuequalifierasset(tag) n0.generate(1) base_asset_name = "TAG_RESTRICTED" asset_name = f"${base_asset_name}" qty = 1000 verifier = tag issue_address = n0.getnewaddress() n0.issue(base_asset_name) assert_raises_rpc_error(-8, "bad-txns-null-verifier-address-failed-verification", n0.issuerestrictedasset, asset_name, qty, verifier, issue_address) # Isolate this test from other tagging on n0... def viewmytaggedaddresses(): return list(filter(lambda x: tag == x['Tag Name'], n0.viewmytaggedaddresses())) assert_equal(0, len(viewmytaggedaddresses())) n0.addtagtoaddress(tag, issue_address, change_address) n0.generate(1) n0.issuerestrictedasset(asset_name, qty, verifier, issue_address) n0.generate(1) # pre-tagging verification assert_does_not_contain(address, n0.listaddressesfortag(tag)) assert_does_not_contain(tag, n0.listtagsforaddress(address)) assert not n0.checkaddresstag(address, tag) # viewmytaggedaddresses tagged = viewmytaggedaddresses() assert_equal(1, len(tagged)) t1 = tagged[0] assert_equal(issue_address, t1['Address']) assert_equal(tag, t1['Tag Name']) assert_contains_key('Assigned', t1) assert_happening(t1['Assigned']) assert_raises_rpc_error(-8, "bad-txns-null-verifier-address-failed-verification", n0.transfer, asset_name, 100, address) # special case: make sure transfer fails if change address(es) are verified even though to address isn't spl_change_address = n0.getnewaddress() asset_change_address = n0.getnewaddress() n0.addtagtoaddress(tag, spl_change_address) n0.addtagtoaddress(tag, asset_change_address) n0.generate(1) assert_raises_rpc_error(-8, "bad-txns-null-verifier-address-failed-verification", n0.transfer, asset_name, 100, address, "", 0, spl_change_address, asset_change_address) n0.removetagfromaddress(tag, spl_change_address) n0.removetagfromaddress(tag, asset_change_address) n0.generate(1) ## assert_raises_rpc_error(None, "Invalid Splendid address", n0.addtagtoaddress, tag, "garbageaddress") assert_raises_rpc_error(None, "Invalid Splendid change address", n0.addtagtoaddress, tag, address, "garbagechangeaddress") n0.addtagtoaddress(tag, address, change_address) n0.generate(1) assert_raises_rpc_error(-32600, "add-qualifier-when-already-assigned", n0.addtagtoaddress, tag, address, change_address) # post-tagging verification assert_contains(address, n0.listaddressesfortag(tag)) assert_contains(tag, n0.listtagsforaddress(address)) assert n0.checkaddresstag(address, tag) # viewmytaggedaddresses tagged = viewmytaggedaddresses() assert_equal(4, len(tagged)) assert_contains(issue_address, list(map(lambda x: x['Address'], tagged))) assert_contains(address, list(map(lambda x: x['Address'], tagged))) for t in tagged: assert_equal(tag, t['Tag Name']) if 'Assigned' in t: assert_happening(t['Assigned']) else: assert_happening(t['Removed']) # special case: make sure transfer fails if the asset change address isn't verified (even if the spl change address is) spl_change_address = n0.getnewaddress() asset_change_address = n0.getnewaddress() assert_raises_rpc_error(-20, "bad-txns-null-verifier-address-failed-verification", n0.transfer, asset_name, 100, address, "", 0, spl_change_address, asset_change_address) n0.addtagtoaddress(tag, spl_change_address) n0.generate(1) assert_raises_rpc_error(-20, "bad-txns-null-verifier-address-failed-verification", n0.transfer, asset_name, 100, address, "", 0, spl_change_address, asset_change_address) n0.removetagfromaddress(tag, spl_change_address) n0.generate(1) # do the transfer already! txid = n0.transfer(asset_name, 100, address) n0.generate(1) assert_equal(64, len(txid[0])) assert_equal(100, n0.listassetbalancesbyaddress(address)[asset_name]) # do another transfer with specified, tagged asset change address asset_change_address = n0.getnewaddress() n0.addtagtoaddress(tag, asset_change_address) n0.generate(1) txid = n0.transfer(asset_name, 1, issue_address, "", 0, "", asset_change_address) n0.generate(1) assert_equal(64, len(txid[0])) assert (n0.listassetbalancesbyaddress(asset_change_address)[asset_name] > 0) assert_raises_rpc_error(None, "Invalid Splendid address", n0.removetagfromaddress, tag, "garbageaddress") assert_raises_rpc_error(None, "Invalid Splendid change address", n0.removetagfromaddress, tag, address, "garbagechangeaddress") n0.removetagfromaddress(tag, address, change_address) n0.generate(1) assert_raises_rpc_error(-32600, "removing-qualifier-when-not-assigned", n0.removetagfromaddress, tag, address, change_address) # TODO: test without specifying change address when there are no valid change addresses (all untagged) # post-untagging verification assert_does_not_contain(address, n0.listaddressesfortag(tag)) assert_does_not_contain(tag, n0.listtagsforaddress(address)) assert not n0.checkaddresstag(address, tag) # viewmytaggedaddresses tagged = viewmytaggedaddresses() assert_equal(6, len(tagged)) # includes removed assert_contains(issue_address, list(map(lambda x: x['Address'], tagged))) assert_contains(address, list(map(lambda x: x['Address'], tagged))) for t in tagged: assert_equal(tag, t['Tag Name']) if issue_address == t['Address']: assert_happening(t['Assigned']) if address == t['Address']: assert_happening(t['Removed']) assert_raises_rpc_error(-8, "bad-txns-null-verifier-address-failed-verification", n0.transfer, asset_name, 100, address)
def test_messaging(self): self.log.info("Testing messaging!") n0, n1 = self.nodes[0], self.nodes[1] spam_name = "SPAM" asset_name = "MESSAGING" owner_name = "MESSAGING!" channel_one = "MESSAGING~ONE" channel_two = "MESSAGING~TWO" ipfs_hash = "QmZPGfJojdTzaqCWJu2m3krark38X1rqEHBo4SjeqHKB26" # need ownership before channels can be created assert_raises_rpc_error(-32600, "Wallet doesn't have asset: " + owner_name, n0.issue, channel_one) n0.issue(asset_name, 100) n0.issue(channel_one) n0.issue(channel_two) n0.issue(spam_name, 100) n0.generate(1) self.sync_all() # you're auto-subscribed to your own channels n0_channels = n0.viewallmessagechannels() assert_contains(owner_name, n0_channels) assert_contains(channel_one, n0_channels) assert_contains(channel_two, n0_channels) # n1 subscribes to owner and channel one assert_equal([], n1.viewallmessagechannels()) n1.subscribetochannel(owner_name) n1.subscribetochannel(channel_one) n1_channels = n1.viewallmessagechannels() assert_contains(owner_name, n1_channels) assert_contains(channel_one, n1_channels) assert_does_not_contain(channel_two, n1_channels) # n0 sends a message on owner n0.sendmessage(owner_name, ipfs_hash) n0.generate(1) self.sync_all() # n1 views then clears messages n1_messages = n1.viewallmessages() assert_equal(1, len(n1_messages)) message = n1_messages[0] assert_contains_pair("Asset Name", owner_name, message) assert_contains_pair("Message", ipfs_hash, message) n1.clearmessages() n1_messages = n1.viewallmessages() assert_equal(0, len(n1_messages)) # n0 sends more messages on channels one and two n0.sendmessage(channel_one, ipfs_hash) n0.sendmessage(channel_two, ipfs_hash) n0.generate(1) self.sync_all() # n1 views then clears messages n1_messages = n1.viewallmessages() assert_equal(1, len(n1_messages)) message = n1_messages[0] assert_contains_pair("Asset Name", channel_one, message) assert_contains_pair("Message", ipfs_hash, message) n1.clearmessages() n1_messages = n1.viewallmessages() assert_equal(0, len(n1_messages)) # n1 unsubscribes n1.unsubscribefromchannel(owner_name) n1.unsubscribefromchannel(channel_one) assert_equal(0, len(n1.viewallmessagechannels())) # auto-subscribe / spam protection (first address use only) addr1 = n1.getnewaddress() n0.transfer(asset_name, 10, addr1) n0.generate(1) self.sync_all() n0.transfer(spam_name, 10, addr1) n1_channels = n1.viewallmessagechannels() assert_equal(1, len(n1_channels)) assert_contains(owner_name, n1_channels) assert_does_not_contain(spam_name, n1_channels) n1.unsubscribefromchannel(owner_name) # pre-existing messages (don't see w/o rescan) assert_equal(0, len(n1.viewallmessages())) n0.sendmessage(channel_two, ipfs_hash) n0.generate(1) self.sync_all() assert_equal(0, len(n1.viewallmessages())) n1.subscribetochannel(channel_two) assert_equal(0, len(n1.viewallmessages())) n0.sendmessage(channel_two, ipfs_hash) n0.generate(1) self.sync_all() assert_equal(1, len(n1.viewallmessages())) assert_contains_pair("Asset Name", channel_two, n1.viewallmessages()[0]) n1.clearmessages() n1.unsubscribefromchannel(channel_two)