def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
resp = testlib.blockstack_name_import( "foo.test", wallets[2].addr, "11" * 20, wallets[1].privkey )
if 'error' in resp:
print json.dumps(resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_import( "foo.test", wallets[3].addr, "22" * 20, wallets[1].privkey )
if 'error' in resp:
print json.dumps(resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_import( "foo.test", wallets[4].addr, "44" * 20, wallets[1].privkey )
resp = testlib.blockstack_name_import( "foo.test", wallets[4].addr, "55" * 20, wallets[1].privkey )
resp = testlib.blockstack_name_import( "foo.test", wallets[4].addr, "33" * 20, wallets[1].privkey )
if 'error' in resp:
print json.dumps(resp, indent=4 )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global last_first_block, first_preorder
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
# NOTE: names expire in 5 * NAMESPACE_LIFETIME_MULTIPLER blocks
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 5, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
first_preorder = testlib.get_current_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
for i in xrange(0, 5 * blockstack_server.config.get_epoch_namespace_lifetime_multiplier( testlib.get_current_block(**kw), "test" )):
testlib.next_block( **kw )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
last_first_block = testlib.get_current_block( **kw )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
resp = testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps( resp )
testlib.next_block( **kw )
# wait for it to expire (takes a day)
for i in xrange(0, 145):
testlib.next_block( **kw )
# re-preorder it
resp = testlib.blockstack_name_preorder( "foo.test", wallets[3].privkey, wallets[4].addr )
if 'error' in resp:
print json.dumps( resp )
testlib.next_block( **kw )
# register it
resp = testlib.blockstack_name_register( "foo.test", wallets[3].privkey, wallets[4].addr )
if 'error' in resp:
print json.dumps( resp )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global snv_block_id, last_consensus
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
snv_block_id = testlib.get_current_block()
resp = testlib.blockstack_name_revoke( "foo.test", wallets[3].privkey )
testlib.next_block( **kw )
last_consensus = testlib.get_consensus_at( testlib.get_current_block() )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
# update and transfer back and forth a few times
for i in xrange(0, 5):
result = testlib.blockstack_name_update( "foo.test", str(i) * 40, wallets[3 + (i%2)].privkey )
update_hashes.append( str(i) * 40 )
testlib.next_block( **kw )
result = testlib.blockstack_name_transfer( "foo.test", wallets[3 + ((i+1)%2)].addr, True, wallets[3 + (i%2)].privkey )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global working_dir
testlib.blockstack_namespace_preorder( "id", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "id", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "id", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "judecn.id", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "judecn.id", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
resp = testlib.blockstack_announce( "hello world!", wallets[3].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_announce( "This should not appear", wallets[4].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# save...
working_dir = testlib.get_working_dir( **kw )
def scenario( wallets, **kw ):
global txids
global consensuses
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.next_block( **kw )
# do a sequence of updates, every other block
for i in xrange( 0, 20 ):
if (i % 2) != 0:
update_hash = ("%02x" % (i)) * 20
resp = testlib.blockstack_name_update( "foo.test", update_hash, wallets[3].privkey )
txids[ update_hash ] = resp['transaction_hash']
consensuses[ update_hash ] = testlib.get_consensus_at( testlib.get_current_block( **kw ), **kw )
testlib.next_block( **kw )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global snv_block_id, last_consensus
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
# NOTE: names expire in 13 blocks
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 13, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
snv_block_id = testlib.get_current_block()
for i in xrange(0, 15):
testlib.next_block( **kw )
last_consensus = testlib.get_consensus_at( testlib.get_current_block() )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 1, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
# preorder, register, expire (multiple times)
for i in xrange(2, 5):
resp = testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
if i == 4:
break
testlib.next_block( **kw )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
# will all be rejected trivially, since the first import must come from the importer's address
testlib.blockstack_name_import( "foo.test", wallets[4].addr, "11" * 20, wallets[2].privkey )
testlib.blockstack_name_import( "bar.test", wallets[2].addr, "22" * 20, wallets[3].privkey )
testlib.blockstack_name_import( "baz.test", wallets[3].addr, "33" * 20, wallets[4].privkey )
testlib.next_block( **kw )
# will be accepted
testlib.blockstack_name_import( "goo.test", wallets[2].addr, "11" * 20, wallets[1].privkey )
# will all be rejected because they weren't sent from a importer-derived key
testlib.blockstack_name_import( "foo.test", wallets[4].addr, "11" * 20, wallets[2].privkey )
testlib.blockstack_name_import( "bar.test", wallets[2].addr, "22" * 20, wallets[3].privkey )
testlib.blockstack_name_import( "baz.test", wallets[3].addr, "33" * 20, wallets[4].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
resp = testlib.blockstack_name_import( "foo.test", addr_reencode("1BKufFedDrueBBFBXtiATB2PSdsBGZxf3N"), "11" * 20, wallets[1].privkey ) # master
if 'error' in resp:
print json.dumps(resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_import( "foo.test", addr_reencode("1ARVjrtKnUVWt2GNrpuFLnNCL2WGUhKdkW"), "33" * 20, wallets[3].privkey ) # derived child 2
if 'error' in resp:
print json.dumps(resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_import( "foo.test", addr_reencode("1PYu4vKB3g2QLDFdurxqYSJ9aJSed7tne1"), "22" * 20, wallets[2].privkey ) # derived child 1
if 'error' in resp:
print json.dumps(resp, indent=4 )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global put_result, wallet_keys, datasets, zonefile_hash, dataset_change
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy( test_proxy )
wallet_keys = blockstack_client.make_wallet_keys( owner_privkey=wallets[3].privkey )
# migrate profile
res = testlib.migrate_profile( "foo.test", proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
else:
zonefile_hash = res['zonefile_hash']
testlib.next_block( **kw )
put_result = blockstack_client.put_mutable( "foo.test", "hello_world_1", datasets[0], proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
testlib.next_block( **kw )
put_result = blockstack_client.put_mutable( "foo.test", "hello_world_2", datasets[1], proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
put_result = blockstack_client.put_mutable( "foo.test", "hello_world_3", datasets[2], proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
# increment version too
datasets[0]['buf'] = []
for i in xrange(0, 5):
datasets[0]["dataset_change"] = dataset_change
datasets[0]['buf'].append(i)
put_result = blockstack_client.put_mutable( "foo.test", "hello_world_1", datasets[0], proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
# wait for a bit...
for i in xrange(0, 10):
testlib.next_block( **kw )
# has to be the same key that registered...
resp = testlib.blockstack_name_renew( "foo.test", wallets[4].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
# wait for a bit...
for i in xrange(0, 10):
testlib.next_block( **kw )
resp = testlib.blockstack_name_renew( "foo.test", wallets[3].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
global snv_consensus, snv_block_id
snv_block_id = testlib.get_current_block()
snv_consensus = testlib.get_consensus_at( snv_block_id )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_update( "foo.test", "11" * 20, wallets[3].privkey )
testlib.next_block( **kw )
consensus_hash = testlib.get_consensus_at( testlib.get_current_block( **kw ), **kw )
# lots of blocks later...
for i in xrange(0, 50):
testlib.next_block( **kw )
# update with stale consensus hash (should fail)
print "\n\nsend update with consensus hash %s\n\n" % consensus_hash
testlib.blockstack_name_update( "foo.test", "22" * 20, wallets[3].privkey, consensus_hash=consensus_hash )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_update( "foo.test", "11" * 20, wallets[3].privkey )
testlib.next_block( **kw )
# should fail--can't give a name to yourself
testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, True, wallets[4].privkey )
testlib.next_block( **kw )
# should fail--can't steal a name
testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, True, wallets[0].privkey )
testlib.next_block( **kw )
def scenario(wallets, **kw):
testlib.blockstack_namespace_preorder("test", wallets[1].addr, wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test",
wallets[1].addr,
52595,
250,
4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey, wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey, wallets[3].addr)
testlib.next_block(**kw)
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 10, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
consensus_hash = testlib.get_consensus_at( testlib.get_current_block(**kw), **kw)
testlib.next_block( **kw )
testlib.next_block( **kw )
# preorder, register, update, expire (multiple times)
for i in xrange(2, 11):
resp = testlib.blockstack_name_preorder( "foo.test", wallets[i].privkey, wallets[(i+1)%11].addr, consensus_hash=consensus_hash )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
consensus_hash = testlib.get_consensus_at( testlib.get_current_block(**kw), **kw)
testlib.next_block( **kw )
testlib.next_block( **kw )
resp = testlib.blockstack_name_register( "foo.test", wallets[i].privkey, wallets[(i+1)%11].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
consensus_hash = testlib.get_consensus_at( testlib.get_current_block(**kw), **kw)
testlib.next_block( **kw )
testlib.next_block( **kw )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[i].addr, True, wallets[(i+1)%11].privkey, consensus_hash=consensus_hash )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
consensus_hash = testlib.get_consensus_at( testlib.get_current_block(**kw), **kw)
testlib.next_block( **kw )
testlib.next_block( **kw )
resp = testlib.blockstack_name_update( "foo.test", ("%02x" % i) * 20, wallets[i].privkey, consensus_hash=consensus_hash )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
consensus_hash = testlib.get_consensus_at( testlib.get_current_block(**kw), **kw)
testlib.next_block( **kw )
testlib.next_block( **kw )
if i == 10:
break
testlib.next_block( **kw )
consensus_hash = testlib.get_consensus_at( testlib.get_current_block(**kw), **kw)
testlib.next_block( **kw )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global wallet_keys, wallet_keys_2, key_names, error
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy( test_proxy )
wallet_keys = blockstack_client.make_wallet_keys( owner_privkey=wallets[3].privkey, data_privkey=wallets[4].privkey )
# migrate profiles
res = testlib.migrate_profile( "foo.test", proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
testlib.next_block( **kw )
# make an account
res = blockstack_client.put_account("foo.test", "serviceFoo", "serviceFooID", "foo://bar.com", proxy=test_proxy, wallet_keys=wallet_keys, foofield="foo!" )
if 'error' in res:
res['test'] = 'Failed to create foo.test account'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
res = blockstack_client.put_account("foo.test", "deletedService", "deletedServiceID", "foo://deleted", proxy=test_proxy, wallet_keys=wallet_keys, barfield="bar!")
if 'error' in res:
res['test'] = 'Failed to create foo.test deletedService account'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# delete an account
res = blockstack_client.delete_account("foo.test", "deletedService", "deletedServiceID", proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in res:
res['test'] = 'Failed to delete foo.test deletedService'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global fail_blocks
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 2, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
# wait for it to expire...
for i in xrange(0, 2 * NAMESPACE_LIFETIME_MULTIPLIER + 1):
testlib.next_block( **kw )
# verify that operations fail
resp = testlib.blockstack_name_update( "foo.test", "11" * 20, wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
fail_blocks.append( testlib.get_current_block( **kw ) )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
# should fail
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, True, wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
fail_blocks.append( testlib.get_current_block( **kw ) )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
# should fail
resp = testlib.blockstack_name_renew( "foo.test", wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
fail_blocks.append( testlib.get_current_block( **kw ) )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
# should fail
resp = testlib.blockstack_name_revoke( "foo.test", wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
fail_blocks.append( testlib.get_current_block( **kw ))
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 4, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
# preorder, register, update, expire (twice; should fail the second time)
for i in xrange(2, 4):
resp = testlib.blockstack_name_preorder( "foo.test", wallets[i].privkey, wallets[(i+1)%11].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_register( "foo.test", wallets[i].privkey, wallets[(i+1)%11].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
if i == 3:
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
testlib.next_block( **kw )
resp = testlib.blockstack_name_update( "foo.test", ("%02x" % i) * 20, wallets[(i+1)%11].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
if i == 3:
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
testlib.next_block( **kw )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[i].addr, True, wallets[(i+1)%11].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
if i == 3:
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
testlib.next_block( **kw )
resp = testlib.blockstack_name_renew( "foo.test", wallets[i].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
if i == 3:
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
if i == 3:
break
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global zonefile_hash
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
wallet = testlib.blockstack_client_initialize_wallet( "0123456789abcdef", wallets[2].privkey, wallets[3].privkey, None )
resp = testlib.blockstack_rpc_register( "foo.test", "0123456789abcdef" )
if 'error' in resp:
print >> sys.stderr, json.dumps(resp, indent=4, sort_keys=True)
return False
# wait for the preorder to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
# wait for the poller to pick it up
print >> sys.stderr, "Waiting 10 seconds for the backend to submit the register"
time.sleep(10)
# wait for the register to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge registration"
time.sleep(10)
# wait for update to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge update"
time.sleep(10)
# transfer to a new address
resp = testlib.blockstack_rpc_transfer( "foo.test", wallets[4].addr, "0123456789abcdef" )
if 'error' in resp:
print >> sys.stderr, "transfer error: %s" % resp['error']
return False
# wait for it to go through
for i in xrange(0, 12):
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge the transfer"
time.sleep(10)
testlib.next_block(**kw)
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
# can't steal test
resp = testlib.blockstack_namespace_reveal( "test", wallets[3].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[4].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
# can't re-create test
resp = testlib.blockstack_namespace_preorder( "test", wallets[3].addr, wallets[4].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_namespace_reveal( "test", wallets[3].addr, 52595, 251, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[4].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_namespace_ready( "test", wallets[4].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# can't re-reveal test
resp = testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 252, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# can't re-ready test
resp = testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHANGE_BEHAVIOR"
sys.stdout.flush()
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
wallet = testlib.blockstack_client_initialize_wallet( "0123456789abcdef", wallets[2].privkey, wallets[3].privkey, wallets[4].privkey )
resp = testlib.blockstack_cli_register( "foo.test", "0123456789abcdef" )
if 'error' in resp:
print >> sys.stderr, json.dumps(resp, indent=4, sort_keys=True)
return False
# wait for the preorder to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
# wait for the poller to pick it up
print >> sys.stderr, "Waiting 10 seconds for the backend to submit the register"
time.sleep(10)
# wait for the register to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge registration"
time.sleep(10)
# wait for update to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge update"
time.sleep(10)
# let's make sure the zonefile propagates...
res = testlib.blockstack_REST_call("GET", "/v1/names/foo.test", None)
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get name bar.test'
print json.dumps(res)
return False
response_json = json.loads(res['raw'])
# assert that we're getting a mainnet address
if response_json['address'] != "1K4SCfqffVHTnHvqsW2whH1Jn57dDjDdQA":
print "Address returned to REST call isn't converted to mainnet!"
print "Returned: {}, Expected: {}".format(response_json['address'], "1K4SCfqffVHTnHvqsW2whH1Jn57dDjDdQA")
return False
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
resp = testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps(resp)
testlib.next_block( **kw )
# no name operations should work on this name, except register
resp = testlib.blockstack_name_update( "foo.test", "11" * 20, wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps(resp)
testlib.next_block( **kw )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
resp = testlib.blockstack_name_renew( "foo.test", wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps(resp)
testlib.next_block( **kw )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, True, wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps(resp)
testlib.next_block( **kw )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
# try both addresses (should both fail)
resp = testlib.blockstack_name_revoke( "foo.test", wallets[4].privkey, safety_checks=False)
if 'error' in resp:
print json.dumps(resp)
testlib.next_block( **kw )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
resp = testlib.blockstack_name_revoke( "foo.test", wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps(resp)
testlib.next_block( **kw )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
def scenario( wallets, **kw ):
global snv_block_id_foo, snv_serial_number_bar, snv_serial_number_baz, last_consensus, snv_txid_bar, snv_txid_baz
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
snv_block_id_foo = testlib.get_current_block()
testlib.next_block( **kw )
testlib.next_block( **kw )
testlib.next_block( **kw )
testlib.next_block( **kw )
testlib.next_block( **kw )
bar_preorder = testlib.blockstack_name_preorder( "bar.test", wallets[4].privkey, wallets[5].addr )
testlib.next_block( **kw )
snv_serial_number_bar = "%s-%s" % (testlib.get_current_block(), 0 )
snv_txid_bar = bar_preorder['transaction_hash']
testlib.blockstack_name_register( "bar.test", wallets[4].privkey, wallets[5].addr )
testlib.next_block( **kw )
testlib.next_block( **kw )
testlib.next_block( **kw )
testlib.next_block( **kw )
testlib.next_block( **kw )
testlib.next_block( **kw )
baz_preorder = testlib.blockstack_name_preorder( "baz.test", wallets[6].privkey, wallets[7].addr )
testlib.next_block( **kw )
snv_serial_number_baz = "%s-%s" % (testlib.get_current_block(), 0 )
snv_txid_baz = baz_preorder['transaction_hash']
testlib.blockstack_name_register( "baz.test", wallets[6].privkey, wallets[7].addr )
testlib.next_block( **kw )
last_consensus = testlib.get_consensus_at( testlib.get_current_block() )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "id", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "id", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "id", wallets[1].privkey )
testlib.next_block( **kw )
wallet = testlib.blockstack_client_initialize_wallet( "0123456789abcdef", wallets[2].privkey, wallets[3].privkey, wallets[4].privkey )
resp = testlib.blockstack_cli_register( "foo.id", "0123456789abcdef",
recipient_address = 'mi8mUNSFC9EoGXmjPF8vKqCUSfGE2fbD4V')
if 'error' in resp:
print >> sys.stderr, json.dumps(resp, indent=4, sort_keys=True)
return False
# wait for the preorder to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
# wait for the poller to pick it up
print >> sys.stderr, "Waiting 10 seconds for the backend to submit the register"
time.sleep(10)
r = blockstack_client.actions.cli_get_registrar_info(None)
assert 'errors' not in r['register'][0]
# wait for the register to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge registration"
time.sleep(10)
# wait for the update to go off
for i in xrange(0, 8):
testlib.next_block( **kw )
# drain the wallet
print >> sys.stderr, "Lets drain the wallet."
testlib.blockstack_cli_withdraw( "0123456789abcdef", 'mi8mUNSFC9EoGXmjPF8vKqCUSfGE2fbD4V' )
print >> sys.stderr, "Drained!"
for i in xrange(0, 11):
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge update"
time.sleep(10)
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
# can't steal test
resp = testlib.blockstack_namespace_reveal( "test", wallets[3].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[4].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
# can't re-create test
resp = testlib.blockstack_namespace_preorder( "test", wallets[3].addr, wallets[4].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_namespace_reveal( "test", wallets[3].addr, 52595, 251, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[4].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_namespace_ready( "test", wallets[4].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# can't re-reveal test
resp = testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 252, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# can't re-ready test
resp = testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global final_consensus
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
resp = testlib.blockstack_name_preorder_multi( ["foo.test", "bar.test", "baz.test"], wallets[2].privkey, [wallets[3].addr, wallets[4].addr, wallets[5].addr] )
if 'error' in resp:
print json.dumps( resp, indent=4 )
sys.exit(1)
testlib.next_block( **kw )
resp = testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
sys.exit(1)
testlib.next_block( **kw )
resp = testlib.blockstack_name_preorder( "goo.test", wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
sys.exit(1)
testlib.next_block( **kw )
resp = testlib.blockstack_name_register( "bar.test", wallets[2].privkey, wallets[4].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
sys.exit(1)
resp = testlib.blockstack_name_register( "goo.test", wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
sys.exit(1)
resp = testlib.blockstack_name_register( "baz.test", wallets[2].privkey, wallets[5].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
sys.exit(1)
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global update_blocks, transfer_blocks, update_hashes, transfer_recipients
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 2, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
# preorder, register, update, expire (multiple times)
for i in xrange(2, 5):
resp = testlib.blockstack_name_preorder( "foo.test", wallets[i].privkey, wallets[(i+1)%11].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_register( "foo.test", wallets[i].privkey, wallets[(i+1)%11].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_update( "foo.test", ("%02x" % i) * 20, wallets[(i+1)%11].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
update_blocks.append( testlib.get_current_block( **kw ))
update_hashes.append( ("%02x" % i) * 20 )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[i].addr, True, wallets[(i+1)%11].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
transfer_blocks.append( testlib.get_current_block( **kw ) )
transfer_recipients.append( wallets[i].addr )
if i == 4:
break
for j in xrange(0, 2 * NAMESPACE_LIFETIME_MULTIPLIER - 1):
testlib.next_block( **kw )
def scenario(wallets, **kw):
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test",
wallets[1].addr,
52595,
250,
4, [6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
version_bits=2)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
namespace_rec = testlib.blockstack_cli_get_namespace_blockchain_record(
"test")
if 'error' in namespace_rec:
print namespace_rec
return False
namespace_balance = testlib.get_balance(namespace_rec['address'])
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
# renew/xfer/update
res = testlib.blockstack_name_renew("foo.test",
wallets[3].privkey,
zonefile_hash="22" * 20,
recipient_addr=wallets[4].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
# renew/update
res = testlib.blockstack_name_renew("foo.test",
wallets[4].privkey,
zonefile_hash="33" * 20,
recipient_addr=wallets[4].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
# renew/xfer
res = testlib.blockstack_name_renew("foo.test",
wallets[4].privkey,
recipient_addr=wallets[1].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
# renew
res = testlib.blockstack_name_renew("foo.test", wallets[1].privkey)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
new_namespace_balance = testlib.get_balance(namespace_rec['address'])
name_rec = testlib.get_name_blockchain_record('foo.test')
name_cost = name_rec['op_fee']
if new_namespace_balance - namespace_balance != name_cost * 5:
print 'address {} did not get credited'.format(
namespace_rec['address'])
print '{} != {} + {}'.format(new_namespace_balance, namespace_balance,
name_cost * 5)
return False
def scenario(wallets, **kw):
global zonefile_hash
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
wallet = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[2].privkey, wallets[3].privkey, None)
resp = testlib.blockstack_cli_register("foo.test", "0123456789abcdef")
if 'error' in resp:
print >> sys.stderr, json.dumps(resp, indent=4, sort_keys=True)
return False
# wait for the preorder to get confirmed
for i in xrange(0, 12):
testlib.next_block(**kw)
# wait for the poller to pick it up
print >> sys.stderr, "Waiting 10 seconds for the backend to submit the register"
time.sleep(10)
# wait for the register to get confirmed
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge registration"
time.sleep(10)
# wait for update to get confirmed
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge update"
time.sleep(10)
# transfer to a new address
resp = testlib.blockstack_cli_transfer("foo.test", wallets[4].addr,
"0123456789abcdef")
if 'error' in resp:
print >> sys.stderr, "transfer error: %s" % resp['error']
return False
# wait for it to go through
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge the transfer"
time.sleep(10)
testlib.next_block(**kw)
def scenario(wallets, **kw):
global snv_block_id_foo, snv_txid_bar, snv_txid_baz, last_consensus
# make a test namespace
resp = testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_name_import("foo.test", wallets[3].addr,
"11" * 20, wallets[1].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
snv_block_id_foo = testlib.get_current_block()
resp = testlib.blockstack_name_import("bar.test", wallets[5].addr,
"33" * 20, wallets[1].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_name_import("baz.test", wallets[6].addr,
"33" * 20, wallets[1].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_namespace_ready("test", wallets[1].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_name_transfer("bar.test", wallets[4].addr, True,
wallets[5].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
snv_txid_bar = resp['transaction_hash']
testlib.next_block(**kw)
resp = testlib.blockstack_name_update("baz.test", "22" * 20,
wallets[6].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
last_consensus = testlib.get_consensus_at(testlib.get_current_block(**kw))
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo1.test", wallets[2].privkey, wallets[3].addr )
testlib.blockstack_name_preorder( "foo2.test", wallets[2].privkey, wallets[3].addr )
testlib.blockstack_name_preorder( "foo3.test", wallets[2].privkey, wallets[3].addr )
testlib.blockstack_name_preorder( "foo4.test", wallets[2].privkey, wallets[3].addr )
testlib.blockstack_name_preorder( "foo5.test", wallets[2].privkey, wallets[3].addr )
testlib.blockstack_name_preorder( "foo6.test", wallets[2].privkey, wallets[3].addr )
testlib.blockstack_name_preorder( "foo7.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
zf_template = "$ORIGIN {}\n$TTL 3600\n{}" # for subdomains
zf_template_1 = "$ORIGIN {}\n$TTL 3600\n_missing TXT \"1\"\n{}"
zf_template_2 = "$ORIGIN {}\n$TTL 3600\n_missing TXT \"2\"\n{}"
zf_template_3 = "$ORIGIN {}\n$TTL 3600\n_missing TXT \"3\"\n{}"
zf_default_url = '_https._tcp URI 10 1 "https://raw.githubusercontent.com/nobody/content/profile.md"'
zonefiles = {
'foo1.test': zf_template_1.format('foo1.test', subdomains.make_subdomain_txt('bar.foo1.test', 'foo1.test', wallets[4].addr, 0, zf_template.format('bar.foo1.test', zf_default_url), wallets[4].privkey)),
'foo2.test': zf_template_2.format('foo2.test', subdomains.make_subdomain_txt('bar.foo2.test', 'foo2.test', wallets[4].addr, 0, zf_template.format('bar.foo2.test', zf_default_url), wallets[4].privkey)),
'foo3.test': zf_template_3.format('foo3.test', subdomains.make_subdomain_txt('bar.foo3.test', 'foo3.test', wallets[4].addr, 0, zf_template.format('bar.foo3.test', zf_default_url), wallets[4].privkey)),
}
testlib.blockstack_name_register( "foo1.test", wallets[2].privkey, wallets[3].addr, zonefile_hash='10' * 20)
testlib.blockstack_name_register( "foo2.test", wallets[2].privkey, wallets[3].addr, zonefile_hash='20' * 20)
testlib.blockstack_name_register( "foo3.test", wallets[2].privkey, wallets[3].addr, zonefile_hash='30' * 20)
testlib.blockstack_name_register( "foo4.test", wallets[2].privkey, wallets[3].addr)
testlib.blockstack_name_register( "foo5.test", wallets[2].privkey, wallets[3].addr)
testlib.blockstack_name_register( "foo6.test", wallets[2].privkey, wallets[3].addr)
testlib.blockstack_name_register( "foo7.test", wallets[2].privkey, wallets[3].addr)
testlib.next_block( **kw )
testlib.blockstack_name_update("foo1.test", storage.get_zonefile_data_hash(zonefiles['foo1.test']), wallets[3].privkey)
testlib.blockstack_name_update("foo2.test", storage.get_zonefile_data_hash(zonefiles['foo2.test']), wallets[3].privkey)
testlib.blockstack_name_update("foo3.test", storage.get_zonefile_data_hash(zonefiles['foo3.test']), wallets[3].privkey)
testlib.next_block(**kw)
assert testlib.blockstack_put_zonefile(zonefiles['foo1.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo2.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo3.test'])
# kick off indexing and check
testlib.next_block(**kw)
def _query_subdomains(subdomain_names, expected_sequence, expected_owner, expect_pending):
# query each subdomain. Should get the latest
for fqn in subdomain_names:
res = client.get_name_record(fqn, hostport='http://localhost:16264')
if 'error' in res:
print res
print 'failed to query {}'.format(fqn)
return False
# should have right sequence
if res['sequence'] != expected_sequence:
print 'wrong sequence; expected {}'.format(expected_sequence)
print res
return False
# should have right owner
if res['address'] != expected_owner:
print 'wrong owner'
print 'expected {}'.format(res['address'])
print res
return False
# do we expect pending?
if res['pending'] != expect_pending:
print 'wrong pending (expected {})'.format(expect_pending)
print res
return False
return True
assert _query_subdomains(['bar.foo1.test', 'bar.foo2.test', 'bar.foo3.test'], 0, wallets[4].addr, False)
expected_owners_before = [wallets[4].addr]
expected_owners_after = [wallets[4].addr]
# update and transfer, but if i % 2 == 0, transfer to a different address
# use a different domain name in each case.
# verify that only transfers on the creator domain are valid.
wallet_schedule = [
(4, 0), # not broadcast initially
(4, 1),
(0, 1), # not broadcast initially
(1, 2),
(1, 3), # not broadcast initially
]
sequence_schedule = [
1,
1,
2,
2,
3,
]
expected_zf_default_url = '_https._tcp URI 10 1 "https://test.com/?index={}"'.format(4)
expect_pending = False
expect_sequence = 0
expect_owner = wallets[4].addr
unsent_zonefiles = []
missing = {
"foo1.test": [1],
"foo2.test": [2],
"foo3.test": [3]
}
# send updates too, and transfer subdomains
for i in range(0, 5):
zf_template_1 = "$ORIGIN {}\n$TTL 3600\n_missing TXT \"" + ",".join([str(m) for m in missing['foo1.test']]) + "\"\n{}"
zf_template_2 = "$ORIGIN {}\n$TTL 3600\n_missing TXT \"" + ",".join([str(m) for m in missing['foo2.test']]) + "\"\n{}"
zf_template_3 = "$ORIGIN {}\n$TTL 3600\n_missing TXT \"" + ",".join([str(m) for m in missing['foo3.test']]) + "\"\n{}"
zf_default_url = '_https._tcp URI 10 1 "https://test.com/?index={}"'.format(i+1)
names = [
'foo1.test',
'foo2.test',
'foo3.test',
]
k = wallet_schedule[i][0]
k2 = wallet_schedule[i][1]
s = sequence_schedule[i]
zonefiles = {
'foo1.test': zf_template_1.format(names[0], subdomains.make_subdomain_txt('bar.foo1.test', names[0], wallets[k2].addr, s, zf_template.format('bar.foo1.test', zf_default_url), wallets[k].privkey)),
'foo2.test': zf_template_2.format(names[1], subdomains.make_subdomain_txt('bar.foo2.test', names[1], wallets[k2].addr, s, zf_template.format('bar.foo2.test', zf_default_url), wallets[k].privkey)),
'foo3.test': zf_template_3.format(names[2], subdomains.make_subdomain_txt('bar.foo3.test', names[2], wallets[k2].addr, s, zf_template.format('bar.foo3.test', zf_default_url), wallets[k].privkey)),
}
testlib.blockstack_name_update(names[0], storage.get_zonefile_data_hash(zonefiles['foo1.test']), wallets[3].privkey)
testlib.blockstack_name_update(names[1], storage.get_zonefile_data_hash(zonefiles['foo2.test']), wallets[3].privkey)
testlib.blockstack_name_update(names[2], storage.get_zonefile_data_hash(zonefiles['foo3.test']), wallets[3].privkey)
testlib.next_block(**kw)
if i % 2 == 1:
# only broadcast periodically
assert testlib.blockstack_put_zonefile(zonefiles['foo1.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo2.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo3.test'])
expect_owner = wallets[k2].addr
expect_sequence += 1
expected_owners_before.append(expect_owner)
else:
expect_pending = True
unsent_zonefiles.append(zonefiles)
expected_owners_after.append(wallets[k2].addr)
if i < 4:
# add more missing
testlib.blockstack_name_update(names[0], '{}'.format(10+i+1) * 20, wallets[3].privkey)
testlib.blockstack_name_update(names[1], '{}'.format(20+i+1) * 20, wallets[3].privkey)
testlib.blockstack_name_update(names[2], '{}'.format(30+i+1) * 20, wallets[3].privkey)
missing['foo1.test'].append(6*(i+1) + 4)
missing['foo2.test'].append(6*(i+1) + 5)
missing['foo3.test'].append(6*(i+1) + 6)
# kick off subdomain indexing
testlib.next_block(**kw)
# verify history
assert _query_subdomains(['bar.foo1.test', 'bar.foo2.test', 'bar.foo3.test'], expect_sequence, expect_owner, expect_pending)
# query subdomain history
for subd in ['bar.foo1.test', 'bar.foo2.test', 'bar.foo3.test']:
res = client.get_name_record(subd, include_history=True, hostport='http://localhost:16264')
if 'error' in res:
print res
return False
if not res['pending']:
print 'not pending, but it should be'
print res
return False
# should be at 2
if res['sequence'] != 2:
print 'wrong sequence'
print res
return False
if virtualchain.address_reencode(str(res['address'])) != virtualchain.address_reencode(expect_owner):
print 'wrong owner'
print res
return False
for i, block_height in enumerate(sorted(res['history'])):
if virtualchain.address_reencode(str(res['history'][block_height][0]['address'])) != virtualchain.address_reencode(expected_owners_before[i]):
print 'wrong owner at {}: expected {}'.format(block_height, expected_owners_before[i])
print json.dumps(res, indent=4, sort_keys=True)
print expected_owners_before
return False
if res['history'][block_height][0]['sequence'] != i:
print 'wrong sequence at {}: expected {}'.format(block_height, i)
print json.dumps(res, indent=4, sort_keys=True)
return False
# send all missing subdomains.
# should cause a cascading owner reorg.
for zfbatch in unsent_zonefiles:
for k in zfbatch:
assert testlib.blockstack_put_zonefile(zfbatch[k])
testlib.next_block(**kw)
# query subdomain history again. pending and owner should change
for subd in ['bar.foo1.test', 'bar.foo2.test', 'bar.foo3.test']:
res = client.get_name_record(subd, include_history=True, hostport='http://localhost:16264')
if 'error' in res:
print res
return False
# despite missing zone files, all of the ones the registrar did not explicitly list as missing are accounted for
if res['pending']:
print 'pending, but it should not be'
print res
return False
if res['sequence'] != 3:
print 'wrong sequence'
print res
return False
if virtualchain.address_reencode(str(res['address'])) != virtualchain.address_reencode(wallets[3].addr):
print 'wrong owner again'
print res
return False
for i, block_height in enumerate(sorted(res['history'])):
if virtualchain.address_reencode(str(res['history'][block_height][0]['address'])) != virtualchain.address_reencode(str(expected_owners_after[i])):
print 'wrong owner at {}: expected {}'.format(block_height, expected_owners_after[i])
print json.dumps(res, indent=4, sort_keys=True)
print expected_owners_after
print expected_owners_before
print [wallets[i].addr for i in range(0, len(wallets))]
return False
if res['history'][block_height][0]['sequence'] != i:
print 'wrong sequence at {}: expected {}'.format(block_height, i)
print json.dumps(res, indent=4, sort_keys=True)
return False
# reindex
assert testlib.check_subdomain_db(**kw)
def scenario( wallets, **kw ):
global fail_blocks
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 10, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_revoke( "foo.test", wallets[3].privkey )
testlib.next_block( **kw )
# can't do anything with the name for another 10 blocks
resp = testlib.blockstack_name_update( "foo.test", "11" * 20, wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
# should fail
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, True, wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
# should fail
resp = testlib.blockstack_name_renew( "foo.test", wallets[3].privkey, safety_checks=False, tx_fee=10000*5 )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
# wait for it to expire...
for i in xrange(0, 8 * NAMESPACE_LIFETIME_MULTIPLIER):
testlib.next_block( **kw )
# verify that operations continue to fail (BUG in 0.13: THIS SUCCEEDS WHEN IT SHOULD FAIL)
resp = testlib.blockstack_name_update( "foo.test", "11" * 20, wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
fail_blocks.append( testlib.get_current_block( **kw ) )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
# should fail
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, True, wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
fail_blocks.append( testlib.get_current_block( **kw ) )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
# should fail
resp = testlib.blockstack_name_renew( "foo.test", wallets[3].privkey, safety_checks=False, tx_fee=10000*5 )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
fail_blocks.append( testlib.get_current_block( **kw ) )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
# re-preorder...
resp = testlib.blockstack_name_preorder( "foo.test", wallets[3].privkey, wallets[4].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# re-register (different user)
resp = testlib.blockstack_name_register( "foo.test", wallets[3].privkey, wallets[4].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHANGE_BEHAVIOR"
sys.stdout.flush()
def scenario(wallets, **kw):
global GAIA_READ_URL
global GAIA_READ_PORT
global GAIA_WRITE_PORT
global GAIA_WRITE_URL
# get gaia hub info
with open(os.path.join(os.environ['BLOCKSTACK_WORKING_DIR'], 'gaia.conf'),
'r') as f:
GAIA_CONF = json.loads(f.read().strip())
try:
GAIA_READ_PORT = urlparse.urlparse(
GAIA_CONF['readURL']).netloc.split(':')[-1]
GAIA_READ_PORT = int(GAIA_READ_PORT)
except:
GAIA_READ_PORT = 80
if os.environ.get('BLOCKSTACK_PUBLIC_TESTNET_GAIA_READ_PORT'):
GAIA_READ_PORT = int(
os.environ['BLOCKSTACK_PUBLIC_TESTNET_GAIA_READ_PORT'])
read_urlinfo = urlparse.urlparse(GAIA_CONF['readURL'])
GAIA_READ_URL = 'http://{}:{}'.format(
read_urlinfo.netloc.split(':')[0], GAIA_READ_PORT)
GAIA_WRITE_PORT = GAIA_CONF['port']
if os.environ.get('BLOCKSTACK_PUBLIC_TESTNET_GAIA_WRITE_PORT'):
GAIA_WRITE_PORT = int(
os.environ['BLOCKSTACK_PUBLIC_TESTNET_GAIA_WRITE_PORT'])
GAIA_WRITE_URL = 'http://{}:{}'.format(GAIA_CONF['servername'],
GAIA_WRITE_PORT)
# fill in URL
tb_conf_path = os.path.join(os.environ['BLOCKSTACK_WORKING_DIR'],
'transaction-broadcaster.conf')
with open(tb_conf_path, 'r') as f:
tb_conf = json.loads(f.read().strip())
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test",
wallets[1].addr,
-1,
250,
4, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
version_bits=3)
testlib.next_block(**kw)
# import a name with the CLI
res = testlib.nodejs_cli('name_import', 'hello_imports.test',
'ID-{}'.format(wallets[3].addr),
'http://*****:*****@Person',
'account': []
}, wallets[3].privkey)
testlib.blockstack_put_profile('hello_imports.test', profile_data,
wallets[3].privkey, 'http://*****:*****@Person',
'account': []
}, wallets[3].privkey)
testlib.blockstack_put_profile('hello2.test', profile_data,
wallets[3].privkey, 'http://localhost:4001')
stop_subdomain_registrar()
def scenario(wallets, **kw):
global debug
resp = testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_namespace_ready("test", wallets[1].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
testlib.next_block(**kw)
resp = testlib.blockstack_name_renew("foo.test", wallets[3].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
testlib.next_block(**kw)
resp = testlib.blockstack_name_transfer("foo.test", wallets[4].addr, True,
wallets[3].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_name_update("foo.test", "11" * 20,
wallets[4].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
testlib.next_block(**kw)
def scenario(wallets, **kw):
global zonefile_hash
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
wallet = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[2].privkey, wallets[3].privkey,
wallets[4].privkey)
resp = testlib.blockstack_rpc_register("foo.test", "0123456789abcdef")
if 'error' in resp:
print >> sys.stderr, json.dumps(resp, indent=4, sort_keys=True)
return False
# wait for the preorder to get confirmed
for i in xrange(0, 12):
testlib.next_block(**kw)
# wait for the poller to pick it up
print >> sys.stderr, "Waiting 10 seconds for the backend to submit the register"
time.sleep(10)
# wait for the register to get confirmed
for i in xrange(0, 12):
testlib.next_block(**kw)
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge registration"
time.sleep(10)
# wait for initial update to get confirmed
for i in xrange(0, 12):
testlib.next_block(**kw)
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge update"
time.sleep(10)
# send an update, changing the zonefile
data_pubkey = wallet['data_pubkey']
zonefile = blockstack_client.user.make_empty_user_zonefile(
"foo.test", data_pubkey)
blockstack_client.user.put_immutable_data_zonefile(
zonefile,
"testdata",
blockstack_client.get_data_hash("testdata"),
data_url="file:///testdata")
zonefile_json = json.dumps(zonefile)
resp = testlib.blockstack_rpc_update("foo.test", zonefile_json,
"0123456789abcdef")
if 'error' in resp:
print >> sys.stderr, "update error: %s" % resp['error']
return False
zonefile_hash = resp['zonefile_hash']
# wait for it to go through
for i in xrange(0, 12):
testlib.next_block(**kw)
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowedge the update"
time.sleep(10)
def scenario(wallets, **kw):
# make a test namespace
resp = testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# import 3 names in the same block: foo.test, bar.test, baz.test
names = ['foo.test', 'bar.test', 'baz.test']
name_preorder_wallets = [wallets[2], wallets[3], wallets[4]]
name_register_wallets = [wallets[5], wallets[6], wallets[7]]
name_transfer_wallets = [wallets[6], wallets[7], wallets[5]]
# derive importer keys and do imports
# NOTE: breaks consensus trace from 0.14.0
private_keychain = keychain.PrivateKeychain.from_private_key(
wallets[1].privkey)
private_keys = [
wallets[1].privkey
] # NOTE: always start with the reveal key, then use children
for i in xrange(0, len(names) - 1):
import_key = private_keychain.child(i).private_key()
print "fund {} (child {})".format(import_key, i)
res = testlib.send_funds(
wallets[1].privkey, 100000000,
virtualchain.BitcoinPrivateKey(import_key).public_key().address())
if 'error' in res:
print json.dumps(res, indent=4, sort_keys=True)
return False
testlib.next_block(**kw)
private_keys.append(import_key)
for i in xrange(0, len(names)):
name = names[i]
register_wallet = name_register_wallets[i]
import_key = private_keys[i]
resp = testlib.blockstack_name_import(name,
register_wallet.addr,
str(9 - i) * 40,
import_key,
safety_checks=False)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# namespace ready...
resp = testlib.blockstack_namespace_ready("test", wallets[1].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# update 3 names in the same block
for i in xrange(0, len(names)):
name = names[i]
register_wallet = name_register_wallets[i]
resp = testlib.blockstack_name_update(name,
str(i + 2) * 40,
register_wallet.privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# update 3 names in the same block, again
for i in xrange(0, len(names)):
name = names[i]
register_wallet = name_register_wallets[i]
resp = testlib.blockstack_name_update(name,
str(i + 1) * 40,
register_wallet.privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# transfer 3 names in the same block
for i in xrange(0, len(names)):
name = names[i]
register_wallet = name_register_wallets[i]
transfer_wallet = name_transfer_wallets[i]
resp = testlib.blockstack_name_transfer(name, transfer_wallet.addr,
True, register_wallet.privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# exchange after transfer...
tmp = name_register_wallets
name_register_wallets = name_transfer_wallets
name_transfer_wallets = tmp
# revoke 3 names in the same block
for i in xrange(0, len(names)):
name = names[i]
register_wallet = name_register_wallets[i]
resp = testlib.blockstack_name_revoke(name, register_wallet.privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
# iterate the blocks a few times
for i in xrange(0, 5):
testlib.next_block(**kw)
def scenario(wallets, **kw):
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test",
wallets[1].addr,
3,
250,
4, [6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
version_bits=2)
testlib.next_block(**kw)
resp = testlib.blockstack_name_import("foo.test", wallets[3].addr,
"11" * 20, wallets[1].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
return False
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
namespace_rec = testlib.blockstack_cli_get_namespace_blockchain_record(
"test")
if 'error' in namespace_rec:
print namespace_rec
return False
namespace_balance = testlib.get_balance(namespace_rec['address'])
burn_balance = testlib.get_balance(
blockstack_client.constants.BLOCKSTACK_BURN_ADDRESS)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw) # expired
res = testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
res = testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw) # expired
res = testlib.blockstack_name_preorder("foo.test", wallets[3].privkey,
wallets[4].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
res = testlib.blockstack_name_register("foo.test", wallets[3].privkey,
wallets[4].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
testlib.next_block(**kw)
res = testlib.blockstack_name_renew("foo.test", wallets[4].privkey)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw) # expired
res = testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
res = testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
new_namespace_balance = testlib.get_balance(namespace_rec['address'])
name_rec = testlib.get_name_blockchain_record('foo.test')
name_cost = name_rec['op_fee']
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw) # expired
if new_namespace_balance - namespace_balance != 4 * name_cost:
print 'address {} did not get credited'.format(
namespace_rec['address'])
print '{} != {} + 4*{}'.format(new_namespace_balance,
namespace_balance, name_cost)
return False
# preorder should send to the null burn address now.
res = testlib.blockstack_name_preorder("foo2.test", wallets[4].privkey,
wallets[0].addr)
if 'error' in res:
print res
return False
# try forcing it to the namespace burn address, to verify that it fails
res = testlib.blockstack_name_preorder("foo_fail.test",
wallets[4].privkey,
wallets[0].addr,
burn_addr=namespace_rec['address'])
if 'error' not in res:
print res
return False
res = testlib.blockstack_name_preorder("foo_fail.test",
wallets[4].privkey,
wallets[0].addr,
burn_addr=namespace_rec['address'],
safety_checks=False,
tx_fee=10000 * 5)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
testlib.expect_snv_fail_at('foo_fail.test',
testlib.get_current_block(**kw))
# should be accepted
res = testlib.blockstack_name_register("foo2.test", wallets[4].privkey,
wallets[0].addr)
if 'error' in res:
print res
return False
# should be rejected
res = testlib.blockstack_name_register("foo_fail.test", wallets[4].privkey,
wallets[0].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
testlib.expect_snv_fail_at('foo_fail.test',
testlib.get_current_block(**kw))
# should have been rejected due to wrong burn address
whois = testlib.blockstack_cli_whois('foo_fail.test')
if 'error' not in whois:
print whois
return False
new_burn_balance = testlib.get_balance(
blockstack_client.constants.BLOCKSTACK_BURN_ADDRESS)
new_namespace_balance = testlib.get_balance(namespace_rec['address'])
name_rec_2 = testlib.get_name_blockchain_record('foo2.test')
name_cost_2 = name_rec_2['op_fee']
# namespace should NOT have gotten the fee for foo_fail. It should only have gotten it for foo.test
if new_namespace_balance - namespace_balance != 4 * name_cost + 3 * 5500:
print 'address {} got credited after fee capture period'.format(
namespace_rec['address'])
print '{} != {} + 4*{}'.format(new_namespace_balance,
namespace_balance, name_cost)
return False
# burn address should have received the fee for the second name
if new_burn_balance - name_cost_2 != burn_balance:
print 'null burn address did not get credited'
print '{} != {} + {}'.format(new_burn_balance, burn_balance,
name_cost_2)
return False
def scenario(wallets, **kw):
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo1.test", wallets[2].privkey,
wallets[3].addr)
testlib.blockstack_name_preorder("foo2.test", wallets[2].privkey,
wallets[3].addr)
testlib.blockstack_name_preorder("foo3.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
zf_template = "$ORIGIN {}\n$TTL 3600\n{}"
zf_default_url = '_https._tcp URI 10 1 "https://raw.githubusercontent.com/nobody/content/profile.md"'
zonefiles = {
'foo1.test':
zf_template.format(
'foo1.test',
subdomains.make_subdomain_txt(
'bar.foo1.test', 'foo1.test', wallets[4].addr, 0,
zf_template.format('bar.foo1.test', zf_default_url),
wallets[4].privkey)),
'foo2.test':
zf_template.format(
'foo2.test',
subdomains.make_subdomain_txt(
'bar.foo2.test', 'foo2.test', wallets[4].addr, 0,
zf_template.format('bar.foo2.test', zf_default_url),
wallets[4].privkey)),
'foo3.test':
zf_template.format(
'foo3.test',
subdomains.make_subdomain_txt(
'bar.foo3.test', 'foo3.test', wallets[4].addr, 0,
zf_template.format('bar.foo3.test', zf_default_url),
wallets[4].privkey)),
}
testlib.blockstack_name_register(
"foo1.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash=storage.get_zonefile_data_hash(zonefiles['foo1.test']))
testlib.blockstack_name_register(
"foo2.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash=storage.get_zonefile_data_hash(zonefiles['foo2.test']))
testlib.blockstack_name_register(
"foo3.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash=storage.get_zonefile_data_hash(zonefiles['foo3.test']))
testlib.next_block(**kw)
# will send these later
initial_zonefiles = zonefiles
# send updates too
for i in range(0, 3):
zf_template = "$ORIGIN {}\n$TTL 3600\n{}"
zf_default_url = '_https._tcp URI 10 1 "https://test.com/?index={}"'.format(
i + 1)
zonefiles = {
'foo1.test':
zf_template.format(
'foo1.test',
subdomains.make_subdomain_txt(
'bar.foo1.test', 'foo1.test', wallets[4].addr, i + 1,
zf_template.format('bar.foo1.test', zf_default_url),
wallets[4].privkey)),
'foo2.test':
zf_template.format(
'foo2.test',
subdomains.make_subdomain_txt(
'bar.foo2.test', 'foo2.test', wallets[4].addr, i + 1,
zf_template.format('bar.foo2.test', zf_default_url),
wallets[4].privkey)),
'foo3.test':
zf_template.format(
'foo3.test',
subdomains.make_subdomain_txt(
'bar.foo3.test', 'foo3.test', wallets[4].addr, i + 1,
zf_template.format('bar.foo3.test', zf_default_url),
wallets[4].privkey)),
}
testlib.blockstack_name_update(
'foo1.test',
storage.get_zonefile_data_hash(zonefiles['foo1.test']),
wallets[3].privkey)
testlib.blockstack_name_update(
'foo2.test',
storage.get_zonefile_data_hash(zonefiles['foo2.test']),
wallets[3].privkey)
testlib.blockstack_name_update(
'foo3.test',
storage.get_zonefile_data_hash(zonefiles['foo3.test']),
wallets[3].privkey)
testlib.next_block(**kw)
assert testlib.blockstack_put_zonefile(zonefiles['foo1.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo2.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo3.test'])
# kick off subdomain indexing (nothing should happen)
testlib.next_block(**kw)
# send initial zonefiles
assert testlib.blockstack_put_zonefile(initial_zonefiles['foo1.test'])
assert testlib.blockstack_put_zonefile(initial_zonefiles['foo2.test'])
assert testlib.blockstack_put_zonefile(initial_zonefiles['foo3.test'])
# now kick it off again
testlib.next_block(**kw)
# query each subdomain
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, hostport='http://localhost:16264')
if 'error' in res:
print res
return False
expected_zonefile = zf_template.format(fqn, zf_default_url)
if base64.b64decode(res['zonefile']) != expected_zonefile:
print 'zonefile mismatch'
print 'expected\n{}'.format(expected_zonefile)
print 'got\n{}'.format(base64.b64decode(res['zonefile']))
return False
# should be in atlas as well
zf = testlib.blockstack_get_zonefile(res['value_hash'], parse=False)
if not zf:
print 'no zone file {} in atlas'.format(res['value_hash'])
return False
if zf != expected_zonefile:
print 'zonefile mismatch in atlas'
print 'expected\n{}'.format(expected_zonefile)
print 'got\n{}'.format(base64.b64decode(res['zonefile']))
return False
# reindex
assert testlib.check_subdomain_db(**kw)
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
resp = testlib.blockstack_name_renew( "foo.test", wallets[3].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
return False
testlib.next_block( **kw )
# whois
res = testlib.blockstack_cli_whois('foo.test')
if 'error' in res:
print res
return False
if res.has_key('zonefile_hash'):
print res
return False
if res['owner_address'] != wallets[3].addr:
print res
return False
resp = testlib.blockstack_name_renew( "foo.test", wallets[3].privkey, zonefile_hash='11' * 20 )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# whois
res = testlib.blockstack_cli_whois('foo.test')
if 'error' in res:
print res
return False
if not res.has_key('zonefile_hash') or res['zonefile_hash'] != '11' * 20:
print res
return False
if res['owner_address'] != wallets[3].addr:
print res
return False
# update/transfer
resp = testlib.blockstack_name_renew( "foo.test", wallets[3].privkey, zonefile_hash='22' * 20, recipient_addr=wallets[0].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# whois
res = testlib.blockstack_cli_whois('foo.test')
if 'error' in res:
print res
return False
if not res.has_key('zonefile_hash') or res['zonefile_hash'] != '22' * 20:
print res
return False
if res['owner_address'] != wallets[0].addr:
print res
return False
# transfer
resp = testlib.blockstack_name_renew( "foo.test", wallets[0].privkey, recipient_addr=wallets[1].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# whois
res = testlib.blockstack_cli_whois('foo.test')
if 'error' in res:
print res
return False
if not res.has_key('zonefile_hash') or res['zonefile_hash'] != '22' * 20:
print res
return False
if res['owner_address'] != wallets[1].addr:
print res
return False
def scenario(wallets, **kw):
global put_result, wallet_keys, datasets, zonefile_hash, dataset_change
wallet = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[2].privkey, wallets[3].privkey,
wallets[4].privkey)
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy(test_proxy)
wallet_keys = blockstack_client.make_wallet_keys(
owner_privkey=wallets[3].privkey, data_privkey=wallets[4].privkey)
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
resp = testlib.blockstack_cli_register("foo.test", "0123456789abcdef")
if 'error' in resp:
print >> sys.stderr, json.dumps(resp, indent=4, sort_keys=True)
return False
# wait for the preorder to get confirmed
for i in xrange(0, 12):
testlib.next_block(**kw)
# wait for the poller to pick it up
print >> sys.stderr, "Waiting for the backend to submit the register"
time.sleep(10)
# wait for the register to get confirmed
for i in xrange(0, 12):
testlib.next_block(**kw)
print >> sys.stderr, "Waiting for the backend to acknowledge registration"
time.sleep(10)
# wait for initial update to get confirmed
for i in xrange(0, 12):
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
print >> sys.stderr, "Waiting for the backend to acknowledge update"
time.sleep(10)
# wait for zonefile/profile replication
for i in xrange(0, 12):
testlib.next_block(**kw)
print >> sys.stderr, "Waiting for the backend to replicate zonefile and profile"
time.sleep(10)
# make a few accounts
res = testlib.blockstack_cli_put_account("foo.test",
"serviceFoo",
"serviceFooID",
"foo://bar.com",
"0123456789abcdef",
extra_data='foofield=foo!',
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to create foo.test serviceFoo account'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
time.sleep(2)
res = testlib.blockstack_cli_put_account("foo.test",
"serviceBar",
"serviceBarID",
"bar://baz.com",
"0123456789abcdef",
extra_data='barfield=bar!',
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to create foo.test serviceBar account'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
time.sleep(2)
# put some data
put_result = testlib.blockstack_cli_put_mutable(
"foo.test",
"hello_world_1",
json.dumps(datasets[0]),
password="******")
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
return False
testlib.next_block(**kw)
time.sleep(2)
put_result = testlib.blockstack_cli_put_mutable( "foo.test", "hello_world_2", json.dumps(datasets[1]), password="******", \
storage_drivers=['blockstack_server'], storage_drivers_exclusive=True)
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
return False
time.sleep(2)
put_result = testlib.blockstack_cli_put_mutable( "foo.test", "hello_world_3", json.dumps(datasets[2]), password="******", \
storage_drivers=['blockstack_server'], storage_drivers_exclusive=True)
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
return False
time.sleep(2)
# increment data version too
datasets[0]['buf'] = []
for i in xrange(0, 5):
datasets[0]["dataset_change"] = dataset_change
datasets[0]['buf'].append(i)
put_result = testlib.blockstack_cli_put_mutable( "foo.test", "hello_world_1", json.dumps(datasets[0]), password="******", \
storage_drivers=['blockstack_server'], storage_drivers_exclusive=True)
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
return False
time.sleep(2)
testlib.next_block(**kw)
def scenario(wallets, **kw):
global pk
testlib.blockstack_namespace_preorder("test1", wallets[1].addr,
wallets[0].privkey)
testlib.blockstack_namespace_preorder("test2", wallets[1].addr,
wallets[0].privkey)
testlib.blockstack_namespace_preorder("test3", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test1",
wallets[1].addr,
52595,
250,
4, [6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
version_bits=1)
testlib.blockstack_namespace_reveal(
"test2",
wallets[1].addr,
52595,
250,
4, [6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
version_bits=2)
testlib.blockstack_namespace_reveal(
"test3",
wallets[1].addr,
52595,
250,
4, [6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
version_bits=3)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test1", wallets[1].privkey)
testlib.blockstack_namespace_ready("test2", wallets[1].privkey)
testlib.blockstack_namespace_ready("test3", wallets[1].privkey)
testlib.next_block(**kw)
# pay for a name in a v1 namespace with Stacks
addr = virtualchain.address_reencode(virtualchain.get_privkey_address(pk))
# calculate the cost of doing so
namespace = testlib.get_state_engine().get_namespace('test1')
stacks_price = blockstack.lib.scripts.price_name_stacks(
'foo', namespace, testlib.get_current_block(**kw))
btc_price = blockstack.lib.scripts.price_name(
'foo', namespace, testlib.get_current_block(**kw))
print ''
print 'price of {} in Stacks is {}'.format('foo.test', stacks_price)
print ''
testlib.blockstack_send_tokens(addr, "STACKS", 3 * stacks_price,
wallets[0].privkey)
testlib.send_funds(
wallets[0].privkey, btc_price - 5500 - 1,
addr) # deliberately insufficient funds for ordering the name in BTC
testlib.next_block(**kw)
wallet_before_burn = testlib.get_balance(wallets[0].addr)
# preorder/register in all three namespaces
testlib.blockstack_name_preorder("foo.test1",
pk,
wallets[3].addr,
price={
'units': 'STACKS',
'amount': stacks_price
})
testlib.blockstack_name_preorder("bar.test1", wallets[1].privkey,
wallets[3].addr)
testlib.blockstack_name_preorder("foo.test2", wallets[1].privkey,
wallets[3].addr)
testlib.blockstack_name_preorder("foo.test3", wallets[1].privkey,
wallets[3].addr)
testlib.next_block(**kw)
wallet_after_burn = testlib.get_balance(wallets[0].addr)
if wallet_after_burn - wallet_before_burn != btc_price:
print 'foo.test2 did not pay {} to {} (but paid {})'.format(
btc_price, wallets[0].addr, wallet_after_burn - wallet_before_burn)
return False
testlib.send_funds(
wallets[0].privkey, btc_price - 5500 - 1,
addr) # deliberately insufficient funds for ordering the name in BTC
testlib.blockstack_name_register("foo.test1", pk,
wallets[3].addr) # paid in Stacks
testlib.blockstack_name_register("bar.test1", wallets[1].privkey,
wallets[3].addr) # paid in BTC
testlib.blockstack_name_register(
"foo.test2", wallets[1].privkey,
wallets[3].addr) # paid in BTC to wallets[0]
testlib.blockstack_name_register("foo.test3", wallets[1].privkey,
wallets[3].addr) # paid in Stacks
testlib.next_block(**kw)
testlib.send_funds(
wallets[0].privkey, btc_price - 5500 - 1,
addr) # deliberately insufficient funds for ordering the name in BTC
wallet_before_burn = testlib.get_balance(wallets[0].addr)
testlib.blockstack_name_renew("foo.test1",
wallets[3].privkey,
price={
'units': 'STACKS',
'amount': stacks_price
}) # paid in Stacks
testlib.blockstack_name_renew("bar.test1",
wallets[3].privkey) # paid in BTC
testlib.blockstack_name_renew(
"foo.test2", wallets[3].privkey) # paid in BTC to wallets[0]
testlib.blockstack_name_renew("foo.test3",
wallets[3].privkey) # paid in Stacks
testlib.next_block(**kw)
wallet_after_burn = testlib.get_balance(wallets[0].addr)
if wallet_after_burn - wallet_before_burn != btc_price:
print 'foo.test2 did not pay {} to {} (but paid {})'.format(
btc_price, wallets[0].addr, wallet_after_burn - wallet_before_burn)
return False
# should all fail--wrong burn addresses
testlib.blockstack_name_renew("foo.test1",
pk,
price={
'units': 'STACKS',
'amount': stacks_price
},
burn_addr=wallets[0].addr,
safety_checks=False,
expect_fail=True)
testlib.blockstack_name_renew("bar.test1",
wallets[3].privkey,
burn_addr=wallets[0].addr,
safety_checks=False,
expect_fail=True)
testlib.blockstack_name_renew("foo.test2",
wallets[3].privkey,
burn_addr=wallets[1].addr,
safety_checks=False,
expect_fail=True)
testlib.blockstack_name_renew("foo.test3",
wallets[3].privkey,
burn_addr=wallets[0].addr,
safety_checks=False,
expect_fail=True)
testlib.next_block(**kw)
testlib.expect_snv_fail_at('foo.test1', testlib.get_current_block(**kw))
testlib.expect_snv_fail_at('bar.test1', testlib.get_current_block(**kw))
testlib.expect_snv_fail_at('foo.test2', testlib.get_current_block(**kw))
testlib.expect_snv_fail_at('foo.test3', testlib.get_current_block(**kw))
def scenario(wallets, **kw):
global debug
resp = testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_name_import("foo.test", wallets[3].addr,
"11" * 20, wallets[1].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_namespace_ready("test", wallets[1].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be None
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] is not None:
print 'wrong consensus hash: expected None'
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
# ping-ping a bit... 3 --> 4 --> 5 --> 4 --> 5 --> 4
resp = testlib.blockstack_name_transfer("foo.test", wallets[4].addr, True,
wallets[3].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_TRANSFER
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != testlib.get_consensus_at(
testlib.get_current_block(**kw) - 1):
print 'wrong consensus hash: expected {}'.format(
testlib.get_consensus_at(testlib.get_current_block(**kw) - 1))
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
resp = testlib.blockstack_name_transfer("foo.test", wallets[5].addr, True,
wallets[4].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_TRANSFER
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != testlib.get_consensus_at(
testlib.get_current_block(**kw) - 1):
print 'wrong consensus hash: expected {}'.format(
testlib.get_consensus_at(testlib.get_current_block(**kw) - 1))
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
resp = testlib.blockstack_name_transfer("foo.test", wallets[4].addr, True,
wallets[5].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_TRANSFER
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != testlib.get_consensus_at(
testlib.get_current_block(**kw) - 1):
print 'wrong consensus hash: expected {}'.format(
testlib.get_consensus_at(testlib.get_current_block(**kw) - 1))
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
resp = testlib.blockstack_name_transfer("foo.test", wallets[5].addr, True,
wallets[4].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_TRANSFER
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != testlib.get_consensus_at(
testlib.get_current_block(**kw) - 1):
print 'wrong consensus hash: expected {}'.format(
testlib.get_consensus_at(testlib.get_current_block(**kw) - 1))
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
resp = testlib.blockstack_name_transfer("foo.test", wallets[4].addr, True,
wallets[5].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_TRANSFER
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != testlib.get_consensus_at(
testlib.get_current_block(**kw) - 1):
print 'wrong consensus hash: expected {}'.format(
testlib.get_consensus_at(testlib.get_current_block(**kw) - 1))
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
# update (4)
resp = testlib.blockstack_name_update("foo.test", "11" * 20,
wallets[4].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != testlib.get_consensus_at(
testlib.get_current_block(**kw) - 1):
print 'wrong consensus hash: expected {}'.format(
testlib.get_consensus_at(testlib.get_current_block(**kw) - 1))
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
update_ch = name_rec['consensus_hash']
# ping-ping a bit... 4 --> 5 --> 4 --> 5 --> 4 --> 5
resp = testlib.blockstack_name_transfer("foo.test", wallets[5].addr, True,
wallets[4].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != update_ch:
print 'wrong consensus hash: expected {}'.format(update_ch)
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
resp = testlib.blockstack_name_transfer("foo.test", wallets[4].addr, True,
wallets[5].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != update_ch:
print 'wrong consensus hash: expected {}'.format(update_ch)
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
resp = testlib.blockstack_name_transfer("foo.test", wallets[5].addr, True,
wallets[4].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != update_ch:
print 'wrong consensus hash: expected {}'.format(update_ch)
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
resp = testlib.blockstack_name_transfer("foo.test", wallets[4].addr, True,
wallets[5].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != update_ch:
print 'wrong consensus hash: expected {}'.format(update_ch)
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
resp = testlib.blockstack_name_transfer("foo.test", wallets[5].addr, True,
wallets[4].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != update_ch:
print 'wrong consensus hash: expected {}'.format(update_ch)
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
# now update (5)
resp = testlib.blockstack_name_update("foo.test", "22" * 20,
wallets[5].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != testlib.get_consensus_at(
testlib.get_current_block(**kw) - 1):
print 'wrong consensus hash: expected {}'.format(
testlib.get_consensus_at(testlib.get_current_block(**kw) - 1))
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
update_ch = testlib.get_consensus_at(testlib.get_current_block(**kw) - 1)
resp = testlib.blockstack_name_transfer("foo.test", wallets[4].addr, True,
wallets[5].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != update_ch:
print 'wrong consensus hash: expected {}'.format(update_ch)
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
resp = testlib.blockstack_name_update("foo.test", "33" * 20,
wallets[4].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != testlib.get_consensus_at(
testlib.get_current_block(**kw) - 1):
print 'wrong consensus hash: expected {}'.format(
testlib.get_consensus_at(testlib.get_current_block(**kw) - 1))
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
update_ch = testlib.get_consensus_at(testlib.get_current_block(**kw) - 1)
resp = testlib.blockstack_name_update("foo.test", "44" * 20,
wallets[4].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != testlib.get_consensus_at(
testlib.get_current_block(**kw) - 1):
print 'wrong consensus hash: expected {}'.format(
testlib.get_consensus_at(testlib.get_current_block(**kw) - 1))
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
update_ch = testlib.get_consensus_at(testlib.get_current_block(**kw) - 1)
resp = testlib.blockstack_name_transfer("foo.test", wallets[5].addr, True,
wallets[4].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != update_ch:
print 'wrong consensus hash: expected {}'.format(
testlib.get_consensus_at(testlib.get_current_block(**kw) - 1))
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
resp = testlib.blockstack_name_transfer("foo.test", wallets[4].addr, True,
wallets[5].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != update_ch:
print 'wrong consensus hash: expected {}'.format(
testlib.get_consensus_at(testlib.get_current_block(**kw) - 1))
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
resp = testlib.blockstack_name_update("foo.test", "55" * 20,
wallets[4].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != testlib.get_consensus_at(
testlib.get_current_block(**kw) - 1):
print 'wrong consensus hash: expected {}'.format(
testlib.get_consensus_at(testlib.get_current_block(**kw) - 1))
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
update_ch = testlib.get_consensus_at(testlib.get_current_block(**kw) - 1)
resp = testlib.blockstack_name_update("foo.test", "66" * 20,
wallets[4].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != testlib.get_consensus_at(
testlib.get_current_block(**kw) - 1):
print 'wrong consensus hash: expected {}'.format(
testlib.get_consensus_at(testlib.get_current_block(**kw) - 1))
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
update_ch = testlib.get_consensus_at(testlib.get_current_block(**kw) - 1)
resp = testlib.blockstack_name_transfer("foo.test", wallets[5].addr, True,
wallets[4].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != update_ch:
print 'wrong consensus hash: expected {}'.format(update_ch)
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
resp = testlib.blockstack_name_update("foo.test", "11" * 20,
wallets[5].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != testlib.get_consensus_at(
testlib.get_current_block(**kw) - 1):
print 'wrong consensus hash: expected {}'.format(
testlib.get_consensus_at(testlib.get_current_block(**kw) - 1))
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
update_ch = testlib.get_consensus_at(testlib.get_current_block(**kw) - 1)
resp = testlib.blockstack_name_transfer("foo.test", wallets[4].addr, True,
wallets[5].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# consensus hash should be the one from the last NAME_UPDATE
db = testlib.get_state_engine()
name_rec = db.get_name('foo.test')
if name_rec['consensus_hash'] != update_ch:
print 'wrong consensus hash: expected {}'.format(update_ch)
print json.dumps(name_rec, indent=4, sort_keys=True)
return False
def scenario(wallets, **kw):
global datasets, zonefile_hashes, put_result, last_hash
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy(test_proxy)
wallet_keys = blockstack_client.make_wallet_keys(
owner_privkey=wallets[3].privkey)
# migrate profile
res = testlib.migrate_profile("foo.test",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
testlib.next_block(**kw)
put_result = blockstack_client.put_immutable("foo.test",
"hello_world_1",
datasets[0],
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
zonefile_hashes.append(put_result['immutable_data_hash'])
testlib.next_block(**kw)
put_result = blockstack_client.put_immutable("foo.test",
"hello_world_2",
datasets[1],
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
zonefile_hashes.append(put_result['immutable_data_hash'])
testlib.next_block(**kw)
put_result = blockstack_client.put_immutable("foo.test",
"hello_world_3",
datasets[2],
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
zonefile_hashes.append(put_result['immutable_data_hash'])
testlib.next_block(**kw)
# should fail (name collision)
datasets[0]['newdata'] = "asdf"
put_result = blockstack_client.put_immutable("foo.test",
"hello_world_1",
datasets[0],
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' not in put_result:
zonefile_hashes[0] = put_result['immutable_data_hash']
del datasets[0]['newdata']
testlib.next_block(**kw)
# delete everything
for i in xrange(0, len(datasets)):
print "delete %s" % zonefile_hashes[i]
put_result = blockstack_client.delete_immutable(
"foo.test", zonefile_hashes[i], wallet_keys=wallet_keys)
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
testlib.next_block(**kw)
last_hash = put_result['zonefile_hash']
