def check(state_engine):
# not revealed, but ready
ns = state_engine.get_namespace_reveal("test")
if ns is not None:
return False
ns = state_engine.get_namespace("test")
if ns is None:
return False
if ns['namespace_id'] != 'test':
return False
# preordered
preorder = state_engine.get_name_preorder(
"foo.test", virtualchain.make_payment_script(wallets[2].addr),
wallets[3].addr)
if preorder is None:
return False
# paid fee
proxy = testlib.make_proxy()
if preorder['op_fee'] < proxy.get_name_cost('foo.test')['satoshis']:
print "{} < {}".format(preorder['op_fee'],
proxy.get_name_cost('foo.test'))
print "Insufficient fee"
return False
return True
def check( state_engine ):
# not revealed, but ready
ns = state_engine.get_namespace_reveal( "test" )
if ns is not None:
return False
ns = state_engine.get_namespace( "test" )
if ns is None:
return False
if ns['namespace_id'] != 'test':
return False
# preordered
preorder = state_engine.get_name_preorder( "foo.test", pybitcoin.make_pay_to_address_script(wallets[2].addr), wallets[3].addr )
if preorder is None:
return False
# paid fee
proxy = testlib.make_proxy()
if preorder['op_fee'] < proxy.get_name_cost( 'foo.test' )['satoshis']:
print "{} < {}".format(preorder['op_fee'], proxy.get_name_cost( 'foo.test' ))
print "Insufficient fee"
return False
return True
def _query_subdomains(subdomain_names, expected_sequence, expected_owner,
expect_pending):
# query each subdomain. Should get the latest
proxy = testlib.make_proxy()
for fqn in subdomain_names:
res = client.get_name_record(fqn, proxy=proxy)
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
def _query_subdomains():
# query each subdomain. Should get the latest
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
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
return True
def _query_subdomains(subdomain_names, expected_zonefiles, expected_sequence, owner_addr):
# query each subdomain. Should get the latest
proxy = testlib.make_proxy()
for (fqn, expected_zonefile) in zip(subdomain_names, expected_zonefiles):
res = client.get_name_record(fqn, proxy=proxy)
if 'error' in res:
print res
print 'failed to query {}'.format(fqn)
return False
if res['sequence'] != expected_sequence:
print 'wrong sequence; expected {}'.format(expected_sequence)
print res
return False
if res['address'] != owner_addr:
print 'wrong owner addr: {}'.format(owner_addr)
print res
return False
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
return True
def scenario( wallets, **kw ):
global zonefile_hash, final_balance, new_expire_block
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):
# 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 initial 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)
# what's the name's renewal block?
proxy = testlib.make_proxy()
res = blockstack_client.get_name_blockchain_record( "foo.test", proxy=proxy )
if 'error' in res:
print >> sys.stderr, json.dumps(res, indent=4, sort_keys=True)
return False
old_expire_block = res['expire_block']
# send an update, changing the zonefile
data_pubkey = wallet['data_pubkey']
zonefile = blockstack_client.zonefile.make_empty_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_cli_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):
# 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 acknowedge the update"
time.sleep(10)
# 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 )
# renew it
resp = testlib.blockstack_cli_renew( "foo.test", "0123456789abcdef" )
if 'error' in resp:
print >> sys.stderr, "Renewal request failed:\n%s" % json.dumps(resp, indent=4, sort_keys=True)
return False
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge the renewal"
time.sleep(10)
# wait for it to go through
for i in xrange(0, 6):
# 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 )
# verify that it's in the queue
queue_state = testlib.blockstack_cli_info()
if 'error' in queue_state:
print json.dumps(queue_state)
return False
if not queue_state.has_key('queues'):
print 'no queues'
print json.dumps(queue_state)
return False
if not queue_state['queues'].has_key('renew'):
print 'no renew queue'
print json.dumps(queue_state)
return False
if len(queue_state['queues']['renew']) != 1:
print 'wrong renew state'
print json.dumps(queue_state)
return False
if queue_state['queues']['renew'][0]['name'] != 'foo.test':
print 'wrong name'
print json.dumps(queue_state)
return False
# wait for it to go through
for i in xrange(0, 6):
# 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 )
proxy = testlib.make_proxy()
res = blockstack_client.get_name_blockchain_record( "foo.test", proxy=proxy )
if 'error' in res:
print >> sys.stderr, json.dumps(res, indent=4, sort_keys=True)
return False
new_expire_block = res['expire_block']
if old_expire_block >= new_expire_block + 12:
# didn't go through
print >> sys.stderr, "Renewal didn't go through: %s --> %s" % (old_expire_block, new_expire_block)
return False
if res['op'] != blockstack_client.config.NAME_REGISTRATION + ":":
print >> sys.stderr, "Renewal didn't go through (last op is %s)" % res['op']
error = True
return False
final_balance = testlib.getbalance( wallets[2].addr )
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_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 initial 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)
# store a new zonefile
data_pubkey = wallet['data_pubkey']
zonefile = blockstack_client.user.make_empty_user_zonefile( "foo.test", data_pubkey )
assert blockstack_client.user.put_immutable_data_zonefile( zonefile, "testdata", blockstack_client.get_data_hash("testdata") )
zonefile_txt = blockstack_zones.make_zone_file( zonefile )
zonefile_hash = blockstack_client.storage.get_zonefile_data_hash( zonefile_txt )
print >> sys.stderr, "\n\nzonefile hash: %s\nzonefile:\n%s\n\n" % (zonefile_hash, zonefile_txt)
# will store to queue
test_proxy = testlib.make_proxy()
config_path = test_proxy.config_path
conf = blockstack_client.config.get_config(config_path)
queuedb_path = conf['queue_path']
# update the zonefile hash, but not the zonefile.
resp = testlib.blockstack_cli_set_zonefile_hash( "foo.test", zonefile_hash )
if 'error' in resp:
print >> sys.stderr, "\nFailed to set zonefile hash: %s\n" % resp
return False
txhash = resp['transaction_hash']
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)
# stop endpoint
print >> sys.stderr, "\nstopping RPC daemon\n"
config_dir = os.path.dirname(test_proxy.config_path)
blockstack_client.rpc.local_rpc_stop(config_dir=config_dir)
time.sleep(3)
# store to queue
res = blockstack_client.backend.queue.queue_append("update", "foo.test", txhash, payment_address=wallets[2].addr, owner_address=wallets[3].addr,
config_path=test_proxy.config_path, zonefile_data=zonefile_txt, zonefile_hash=zonefile_hash, path=queuedb_path )
# verify that we can sync the zonefile, using the in-queue zonefile
resp = testlib.blockstack_cli_sync_zonefile( "foo.test" )
if 'error' in resp:
print >> sys.stderr, "\nfailed to sync zonefile: %s\n" % resp
return False
blockstack_client.backend.queue.queuedb_remove("update", "foo.test", txhash, path=queuedb_path )
print >> sys.stderr, "\nstarting RPC daemon\n"
blockstack_client.actions.start_rpc_endpoint(config_dir, password="******")
time.sleep(3)
# store a new zonefile
zonefile = blockstack_client.user.make_empty_user_zonefile( "foo.test", data_pubkey )
blockstack_client.user.put_immutable_data_zonefile( zonefile, "testdata2", blockstack_client.get_data_hash("testdata") )
zonefile_txt = blockstack_zones.make_zone_file( zonefile )
zonefile_hash = blockstack_client.storage.get_zonefile_data_hash( zonefile_txt )
# store locally
res = blockstack_client.profile.store_name_zonefile("foo.test", zonefile, None, storage_drivers=['disk'])
if 'error' in res:
print >> sys.stderr, "\nFailed to store zonefile: %s\n" % res
return False
# update the zonefile hash, but not the zonefile.
resp = testlib.blockstack_cli_set_zonefile_hash( "foo.test", zonefile_hash )
if 'error' in resp:
print >> sys.stderr, "\nFailed to set zonefile hash: %s\n" % resp
return False
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 )
# verify that we can sync the zonefile, using the on-disk zonefile
resp = testlib.blockstack_cli_sync_zonefile( "foo.test" )
if 'error' in resp:
print >> sys.stderr, "update 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 acknowedge the update"
time.sleep(10)
def scenario(wallets, **kw):
wallet_keys = 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)
zonefile_batches = []
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)),
}
zonefile_batches.append(zonefiles)
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)
# 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)),
}
zonefile_batches.append(zonefiles)
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)
# send all zonefiles at once
for zfbatch in zonefile_batches:
for name in zfbatch:
assert testlib.blockstack_put_zonefile(zfbatch[name])
# kick off subdomain indexing
testlib.next_block(**kw)
# query each subdomain
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
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):
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 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)
# 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)
# regenerate the wallet, with the new owner address
wallet = testlib.blockstack_client_set_wallet("0123456789abcdef",
wallets[2].privkey,
wallets[4].privkey,
wallets[4].privkey)
# renew it, using the same payment key
resp = testlib.blockstack_rpc_renew("foo.test", "0123456789abcdef")
if 'error' in resp:
print >> sys.stderr, "Renewal request failed:\n%s" % json.dumps(
resp, indent=4, sort_keys=True)
return False
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge the renewal"
time.sleep(10)
proxy = testlib.make_proxy()
res = blockstack_client.get_name_blockchain_record("foo.test", proxy=proxy)
if 'error' in res:
print >> sys.stderr, json.dumps(res, indent=4, sort_keys=True)
return False
new_expire_block = res['expire_block']
if old_expire_block >= new_expire_block + 12:
# didn't go through
print >> sys.stderr, "Renewal didn't go through: %s --> %s" % (
old_expire_block, new_expire_block)
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,
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):
# 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 initial 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)
# wait for zonefile posting
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 send zonefile"
time.sleep(10)
# what's the name's renewal block?
proxy = testlib.make_proxy()
res = blockstack_client.get_name_blockchain_record("foo.test", proxy=proxy)
if 'error' in res:
print >> sys.stderr, json.dumps(res, indent=4, sort_keys=True)
return False
old_expire_block = res['expire_block']
# send an update, changing the zonefile
data_pubkey = wallet['data_pubkey']
zonefile = blockstack_client.zonefile.make_empty_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_cli_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):
# 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 acknowedge the update"
time.sleep(10)
# 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)
# revoke it
resp = testlib.blockstack_cli_revoke("foo.test", "0123456789abcdef")
if 'error' in resp:
print >> sys.stderr, "Revoke request failed:\n%s" % json.dumps(
resp, indent=4, sort_keys=True)
return False
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge the revoke"
time.sleep(10)
# wait for it to go through
for i in xrange(0, 12):
testlib.next_block(**kw)
def scenario(wallets, **kw):
test_proxy = testlib.make_proxy()
ysi_client.set_default_proxy(test_proxy)
testlib.ysi_namespace_preorder("test", wallets[1].addr, wallets[0].privkey)
testlib.next_block(**kw) # 689
testlib.ysi_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) # 690
testlib.ysi_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw) # 691
testlib.ysi_name_preorder("foo.test", wallets[2].privkey, wallets[3].addr)
testlib.next_block(**kw) # 692
testlib.ysi_name_register("foo.test", wallets[2].privkey, wallets[3].addr)
testlib.next_block(**kw) # 693
names = ['f' + 'o' * i + '.test' for i in xrange(0, 32)]
names_novowel = ['f' + 'j' * i + '.test' for i in xrange(0, 32)]
names_nonalpha = ['f' + '1' * i + '.test' for i in xrange(0, 32)]
namespaces = ['b' * i for i in xrange(1, 20)]
name_costs = {}
namespace_costs = {}
for n in names + names_novowel + names_nonalpha:
name_cost_info = test_proxy.get_name_cost(n)
price_satoshis = name_cost_info['satoshis']
name_costs[n] = price_satoshis
for ns in namespaces:
namespace_cost_info = test_proxy.get_namespace_cost(ns)
namespace_price_satoshis = namespace_cost_info['satoshis']
namespace_costs[ns] = namespace_price_satoshis
# activate epoch 3
testlib.next_block(**kw) # 694
new_name_costs = {}
new_namespace_costs = {}
for n in names + names_novowel + names_nonalpha:
name_cost_info = test_proxy.get_name_cost(n)
price_satoshis = name_cost_info['satoshis']
new_name_costs[n] = price_satoshis
for ns in namespaces:
namespace_cost_info = test_proxy.get_namespace_cost(ns)
namespace_price_satoshis = namespace_cost_info['satoshis']
new_namespace_costs[ns] = namespace_price_satoshis
for n in names + names_novowel + names_nonalpha:
if new_name_costs[n] * 10 != name_costs[n]:
print 'wrong name cost change for {}: {} * 10 != {}'.format(
n, new_name_costs[n], name_costs[n])
return False
for ns in namespaces:
if new_namespace_costs[ns] * 10 != namespace_costs[ns]:
print 'wrong namespace cost change for {}: {} * 10 != {}'.format(
ns, new_name_costs[ns], name_costs[ns])
return False
# should succeed
resp = testlib.ysi_name_renew("foo.test",
wallets[3].privkey,
zonefile_hash='22' * 20,
recipient_addr=wallets[0].addr)
if 'error' in resp:
print resp
return False
testlib.next_block(**kw) # 695
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"'
zf_default_url_original = zf_default_url
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)
# send these initial ones out
assert testlib.blockstack_put_zonefile(zonefiles['foo1.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo2.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo3.test'])
missing_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)
if i % 2 == 0:
# withhold for now
missing_zonefiles.append(zonefiles)
else:
# send these out
assert testlib.blockstack_put_zonefile(zonefiles['foo1.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo2.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo3.test'])
assert len(missing_zonefiles) == 2
# verify that initial subdomains are present
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
if 'error' in res:
print res
return False
if res['sequence'] != 0:
print 'wrong sequence: expected 0'
print res
return False
expected_zonefile = zf_template.format(fqn, zf_default_url_original)
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
# send first batch of withheld zonefiles
assert testlib.blockstack_put_zonefile(missing_zonefiles[0]['foo1.test'])
assert testlib.blockstack_put_zonefile(missing_zonefiles[0]['foo2.test'])
assert testlib.blockstack_put_zonefile(missing_zonefiles[0]['foo3.test'])
# kick off subdomain indexing
testlib.next_block(**kw)
# verify that we're now up to sequence=2
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
if 'error' in res:
print res
return False
if res['sequence'] != 2:
print 'wrong sequence: expected 2'
print res
return False
zf_default_url = '_https._tcp URI 10 1 "https://test.com/?index=2"'
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
# send second batch of withheld zonefiles
assert testlib.blockstack_put_zonefile(missing_zonefiles[1]['foo1.test'])
assert testlib.blockstack_put_zonefile(missing_zonefiles[1]['foo2.test'])
assert testlib.blockstack_put_zonefile(missing_zonefiles[1]['foo3.test'])
# kick off subdomain indexing
testlib.next_block(**kw)
# query each subdomain (should all be at sequence 3)
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
if 'error' in res:
print res
return False
if res['sequence'] != 3:
print 'wrong sequence: expected 3'
print res
return False
zf_default_url = '_https._tcp URI 10 1 "https://test.com/?index=3"'
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):
test_proxy = testlib.make_proxy()
testlib.ysi_namespace_preorder("test", wallets[1].addr, wallets[0].privkey)
testlib.next_block(**kw)
testlib.ysi_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.ysi_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
namespace_rec = testlib.ysi_cli_get_namespace_blockchain_record("test")
if 'error' in namespace_rec:
print namespace_rec
return False
namespace_balance = testlib.get_balance(namespace_rec['address'])
# should fail safety checks
res = testlib.ysi_name_preorder("foo.test",
wallets[2].privkey,
wallets[3].addr,
burn_addr=wallets[1].addr)
if 'error' not in res:
print res
return False
# should succeed to be transmitted and should be accepted
res = testlib.ysi_name_preorder("foo.test",
wallets[2].privkey,
wallets[3].addr,
burn_addr=wallets[1].addr,
safety_checks=False,
tx_fee=300 * 5)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
res = testlib.ysi_name_register("foo.test",
wallets[2].privkey,
wallets[3].addr,
safety_checks=False,
tx_fee=300 * 5)
if 'error ' in res:
print res
return False
testlib.next_block(**kw)
testlib.expect_snv_fail_at("foo.test", testlib.get_current_block(**kw))
# should NOT have registered (wrong burn address)
name_rec = testlib.get_name_blockchain_record('foo.test')
if 'error' not in name_rec:
print name_rec
return False
# try again, with the right burn address but the same register address (should be rejected)
res = testlib.ysi_name_preorder("foo.test",
wallets[2].privkey,
wallets[3].addr,
burn_addr=wallets[0].addr,
safety_checks=False,
tx_fee=300 * 5)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
nameops = ysi_client.get_nameops_at(testlib.get_current_block(**kw),
proxy=test_proxy)
if 'error' in nameops:
print nameops
return False
if len(nameops) > 0:
print nameops
return False
# try again, but with the right burn address AND a different register address (should be accepted)
res = testlib.ysi_name_preorder("foo.test",
wallets[2].privkey,
wallets[4].addr,
burn_addr=wallets[0].addr,
safety_checks=False,
tx_fee=300 * 5)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
# should succeed
res = testlib.ysi_name_register("foo.test", wallets[2].privkey,
wallets[4].addr)
if 'error ' in res:
print res
return False
testlib.next_block(**kw)
# should have registered
name_rec = testlib.get_name_blockchain_record('foo.test')
if 'error' in name_rec:
print name_rec
return False
new_namespace_balance = testlib.get_balance(namespace_rec['address'])
name_cost = name_rec['op_fee']
if new_namespace_balance - namespace_balance != name_cost * 2:
print 'address {} did not get credited'.format(
namespace_rec['address'])
print '{} != {} + {}'.format(new_namespace_balance, namespace_balance,
name_cost * 2)
return False
def scenario(wallets, **kw):
global first_name_block
test_proxy = testlib.make_proxy()
# make a test namespace
resp = testlib.ysi_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
return False
testlib.next_block(**kw) # end of 689
resp = testlib.ysi_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)
if 'error' in resp:
print json.dumps(resp, indent=4)
return False
testlib.next_block(**kw) # 690
# make a zonefile and a profile
driver_urls = ysi_client.storage.make_mutable_data_urls(
'foo.test', use_only=['dht', 'disk'])
zonefile = ysi_client.zonefile.make_empty_zonefile('foo.test',
wallets[4].pubkey_hex,
urls=driver_urls)
zonefile_txt = ysi_zones.make_zone_file(zonefile,
origin='foo.test',
ttl=4200)
# make a new keyfile as well
user_profile = ysi_client.user.make_empty_user_profile()
'''
res = ysi_client.key_file.make_initial_key_file(user_profile, wallets[3].privkey)
if 'error' in res:
print res
return res
keyfile_txt = res['key_file']
'''
zonefile_hash = ysi_client.get_zonefile_data_hash(zonefile_txt)
resp = testlib.ysi_name_import("foo.test", wallets[3].addr, zonefile_hash,
wallets[1].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
return False
testlib.next_block(**kw) # 691
# broadcast zonefile
res = testlib.ysi_cli_sync_zonefile('foo.test',
zonefile_string=zonefile_txt)
if 'error' in res:
print res
return False
'''
# upload keyfile
res = ysi_client.key_file.key_file_put('foo.test', keyfile_txt)
if 'error' in res:
print res
return False
'''
rc = ysi_client.profile.put_profile('foo.test',
user_profile,
blockchain_id='foo.test',
user_data_privkey=wallets[4].privkey,
user_zonefile=zonefile,
proxy=test_proxy)
if not rc:
print 'failed to put profile'
return False
# try lookup
res = testlib.ysi_cli_lookup('foo.test')
if 'error' in res:
print res
return False
first_name_block = testlib.get_current_block(**kw)
resp = testlib.ysi_namespace_ready("test", wallets[1].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
return False
# try lookup
res = testlib.ysi_cli_lookup('foo.test')
if 'error' in res:
print res
return False
testlib.next_block(**kw) # end of 692
whois = testlib.ysi_cli_whois('foo.test')
if 'error' in whois:
print 'failed to whois foo.test'
print json.dumps(whois, indent=4)
return False
# this should be the second-to-last block
if whois['expire_block'] != testlib.get_current_block(**kw) + 2:
print 'wrong expire block (expect 2 more)'
print whois
return False
# try lookup
res = testlib.ysi_cli_lookup('foo.test')
if 'error' in res:
print res
return False
testlib.next_block(**kw) # end of 693; begin epoch 2
# begin epoch 2
# try lookup
res = testlib.ysi_cli_lookup('foo.test')
if 'error' in res:
print res
return False
testlib.next_block(**kw) # 694
# try lookup
res = testlib.ysi_cli_lookup('foo.test')
if 'error' in res:
print res
return False
whois = testlib.ysi_cli_whois('foo.test')
if 'error' in whois:
print 'failed to whois foo.test'
print json.dumps(whois, indent=4)
return False
# this should be the last block
if whois['expire_block'] != testlib.get_current_block(**kw) + 2:
print 'wrong expire block (expect 2 more)'
print whois
return False
if whois['renewal_deadline'] != testlib.get_current_block(**kw) + 2:
print 'wrong renewal block (expect 2 more)'
print whois
return False
print whois
testlib.next_block(**kw) # 695 (epoch 3 begins)
# try lookup
res = testlib.ysi_cli_lookup('foo.test')
if 'error' in res:
print res
return False
testlib.next_block(**kw) # end of 696
# try lookup (should fail)
res = testlib.ysi_cli_lookup('foo.test')
if 'error' not in res:
print res
return False
if 'expired' not in res['error']:
print res
return False
whois = testlib.ysi_cli_whois('foo.test')
if 'error' in whois:
print whois
return False
# this should be the expire block
if whois['expire_block'] != testlib.get_current_block(**kw):
print 'wrong expire block (now at {})'.format(
testlib.get_current_block(**kw))
print whois
return False
# should now be a grace period
if whois['renewal_deadline'] != testlib.get_current_block(**kw) + 5:
print 'wrong renewal block (now at {})'.format(
testlib.get_current_block(**kw))
print whois
return False
last_transaction_height = whois['last_transaction_height']
# begin epoch 3 (grace period)
testlib.next_block(**kw) # end of 697
# try lookup (should fail)
res = testlib.ysi_cli_lookup('foo.test')
if 'error' not in res:
print res
return False
if 'expired' not in res['error']:
print res
return False
testlib.next_block(**kw) # 698
# try lookup (should fail)
res = testlib.ysi_cli_lookup('foo.test')
if 'error' not in res:
print res
return False
if 'expired' not in res['error']:
print res
return False
testlib.next_block(**kw) # 699
# try lookup (should fail)
res = testlib.ysi_cli_lookup('foo.test')
if 'error' not in res:
print res
return False
if 'expired' not in res['error']:
print res
return False
testlib.next_block(**kw) # 700
# try lookup (should fail)
res = testlib.ysi_cli_lookup('foo.test')
if 'error' not in res:
print res
return False
if 'expired' not in res['error']:
print res
return False
# make a zonefile and a profile
driver_urls = ysi_client.storage.make_mutable_data_urls(
'foo.test', use_only=['dht', 'disk'])
new_zonefile = ysi_client.zonefile.make_empty_zonefile(
'foo.test', wallets[4].pubkey_hex, urls=driver_urls)
new_zonefile_txt = ysi_zones.make_zone_file(new_zonefile,
origin='foo.test',
ttl=4200)
# make a new keyfile as well
new_user_profile = ysi_client.user.make_empty_user_profile()
new_user_profile['new_user'] = True
'''
res = ysi_client.key_file.make_initial_key_file(new_user_profile, wallets[0].privkey)
if 'error' in res:
print res
return res
new_keyfile_txt = res['key_file']
'''
new_zonefile_hash = ysi_client.get_zonefile_data_hash(new_zonefile_txt)
rc = ysi_client.profile.put_profile('foo.test',
new_user_profile,
blockchain_id='foo.test',
user_data_privkey=wallets[4].privkey,
user_zonefile=new_zonefile,
proxy=test_proxy)
if not rc:
print 'failed to put profile'
return False
# renew/xfer/update
resp = testlib.ysi_name_renew('foo.test',
wallets[3].privkey,
zonefile_hash=new_zonefile_hash,
recipient_addr=wallets[0].addr)
if 'error' in resp:
print resp
return False
testlib.next_block(**kw) # end of 701 (end of grace period)
# try lookup (should succeed again)
res = testlib.ysi_cli_lookup('foo.test')
if 'error' in res:
print res
return False
if res['zonefile'] != new_zonefile_txt:
print 'wrong zonefile'
print new_zonefile_txt
print res
return False
testlib.next_block(**kw) # 702 (name can be registered again)
def scenario(wallets, **kw):
global zonefile_hash
testlib.ysi_namespace_preorder("test", wallets[1].addr, wallets[0].privkey)
testlib.next_block(**kw)
testlib.ysi_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.ysi_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
wallet = testlib.ysi_client_initialize_wallet("0123456789abcdef",
wallets[2].privkey,
wallets[3].privkey,
wallets[6].privkey)
resp = testlib.ysi_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(15)
# 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(15)
# 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(15)
# get the current expiration
proxy = testlib.make_proxy()
res = ysi_client.get_name_blockchain_record("foo.test", proxy=proxy)
old_expire_block = res['expire_block']
# send an update, changing the zonefile
data_pubkey = wallet['data_pubkey']
zonefile = ysi_client.zonefile.make_empty_zonefile("foo.test", data_pubkey)
ysi_client.user.put_immutable_data_zonefile(
zonefile,
"testdata",
ysi_client.get_data_hash("testdata"),
data_url="file:///testdata")
zonefile_json = json.dumps(zonefile)
resp = testlib.ysi_cli_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):
# 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 acknowedge the update"
time.sleep(15)
# transfer to a new address
resp = testlib.ysi_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(15)
# regenerate the wallet, with the new owner address
wallet = testlib.ysi_client_set_wallet("0123456789abcdef",
wallets[5].privkey,
wallets[4].privkey,
wallets[6].privkey)
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API: {}'.format(res)
return False
# renew it, using the same payment key
resp = testlib.ysi_cli_renew("foo.test", "0123456789abcdef")
if 'error' in resp:
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
print >> sys.stderr, "Renewal request failed:\n%s" % json.dumps(
resp, indent=4, sort_keys=True)
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 renewal"
time.sleep(15)
res = ysi_client.get_name_blockchain_record("foo.test", proxy=proxy)
if 'error' in res:
print >> sys.stderr, json.dumps(res, indent=4, sort_keys=True)
return False
new_expire_block = res['expire_block']
if old_expire_block >= new_expire_block + 12:
# didn't go through
print >> sys.stderr, "Renewal didn't go through: %s --> %s" % (
old_expire_block, new_expire_block)
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)
working_dir = testlib.get_working_dir(**kw)
sub_zf_template = '$ORIGIN {}\n$TTL 3600\n_http._tcp URI 10 1 "http://www.foo.com"\n{}'
zf_template = '$ORIGIN {}\n$TTL 3600\n_http._tcp URI 10 1 "http://www.foo.com"\n_resolver URI 10 1 "http://resolver.foo"\n{}'
zf_default_url = '_file URI 10 1 "file://' + working_dir + '/{}"'
zf_default_url_2 = '_file URI 20 1 "file://' + working_dir + '/{}"'
subdomain_zonefiles = {
'bar.foo1.test':
sub_zf_template.format('bar.foo1.test',
zf_default_url.format('bar.foo1.test')),
'bar.foo2.test':
sub_zf_template.format('bar.foo2.test',
zf_default_url.format('bar.foo2.test')),
'bar.foo3.test':
sub_zf_template.format('bar.foo3.test',
zf_default_url.format('bar.foo3.test')),
}
zonefiles = {
'foo1.test':
zf_template.format(
'foo1.test',
subdomains.make_subdomain_txt('bar.foo1.test', 'foo1.test',
wallets[4].addr, 0,
subdomain_zonefiles['bar.foo1.test'],
wallets[4].privkey)),
'foo2.test':
zf_template.format(
'foo2.test',
subdomains.make_subdomain_txt('bar.foo2.test', 'foo2.test',
wallets[4].addr, 0,
subdomain_zonefiles['bar.foo2.test'],
wallets[4].privkey)),
'foo3.test':
zf_template.format(
'foo3.test',
subdomains.make_subdomain_txt('bar.foo3.test', 'foo3.test',
wallets[4].addr, 0,
subdomain_zonefiles['bar.foo3.test'],
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)
# sign and put profiles
for subd in ['bar.foo1.test', 'bar.foo2.test', 'bar.foo3.test']:
profile_data = {
'type': 'Person',
'name': subd,
}
profile_jwt = testlib.blockstack_make_profile(profile_data,
wallets[4].privkey)
path = os.path.join(working_dir, subd)
with open(path, 'w') as f:
f.write(profile_jwt)
# whois
for i in xrange(1, 4):
name = 'foo{}.test'.format(i)
res = testlib.blockstack_cli_whois(name)
if 'error' in res:
print res
return False
if not res.has_key('zonefile_hash') or res[
'zonefile_hash'] != storage.get_zonefile_data_hash(
zonefiles[name]):
print res
return False
if res['owner_address'] != wallets[3].addr:
print res
return False
# upload zonefile
assert testlib.blockstack_put_zonefile(zonefiles[name])
subdomain_zonefiles_2 = {
'bar.foo1.test':
zf_template.format('bar.foo1.test',
zf_default_url_2.format('bar.foo1.test')),
'bar.foo2.test':
zf_template.format('bar.foo2.test',
zf_default_url_2.format('bar.foo2.test')),
'bar.foo3.test':
zf_template.format('bar.foo3.test',
zf_default_url_2.format('bar.foo3.test')),
}
zonefiles = {
'foo1.test':
zf_template.format(
'foo1.test',
subdomains.make_subdomain_txt('bar.foo1.test', 'foo1.test',
wallets[4].addr, 1,
subdomain_zonefiles['bar.foo1.test'],
wallets[4].privkey)),
'foo2.test':
zf_template.format(
'foo2.test',
subdomains.make_subdomain_txt('bar.foo2.test', 'foo2.test',
wallets[4].addr, 1,
subdomain_zonefiles['bar.foo2.test'],
wallets[4].privkey)),
'foo3.test':
zf_template.format(
'foo3.test',
subdomains.make_subdomain_txt('bar.foo3.test', 'foo3.test',
wallets[4].addr, 1,
subdomain_zonefiles['bar.foo3.test'],
wallets[4].privkey)),
}
# update zone files
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
testlib.next_block(**kw)
# start API daemon
print 'starting API daemon'
wallet_keys = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[0].privkey, wallets[1].privkey,
wallets[2].privkey)
# authenticate
pk = keylib.ECPrivateKey(wallets[-1].privkey).to_hex()
res = testlib.blockstack_cli_app_signin("foo.test", pk, 'register.app', [
'names', 'register', 'prices', 'zonefiles', 'blockchain', 'node_read',
'user_read'
])
if 'error' in res:
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
ses = res['token']
# query each subdomain
proxy = testlib.make_proxy()
# test 301 redirects.
res = testlib.blockstack_REST_call('GET',
'/v1/names/baz.foo1.test',
ses,
allow_redirects=False)
if 'error' in res:
res['test'] = 'Failed to query non-registered name.'
print json.dumps(res)
return False
if res['http_status'] != 301:
res['test'] = 'Failed to get a redirect.'
print json.dumps(res)
return False
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
# test REST whois
res = testlib.blockstack_REST_call('GET', '/v1/names/{}'.format(fqn),
ses)
if 'error' in res:
res['test'] = 'Failed to query name'
print json.dumps(res)
return False
if res['http_status'] != 200 and res['http_status'] != 404:
res['test'] = 'HTTP status {}, response = {} on name lookup'.format(
res['http_status'], res['response'])
print json.dumps(res)
return False
if res['response']['zonefile'] != subdomain_zonefiles[fqn]:
print 'wrong zone file'
print res
print 'expected'
print zonefiles['foo{}.test'.format(i)]
return False
if res['response']['status'] != 'registered_subdomain':
print 'wrong status'
print res
return False
# test CLI lookup
res = testlib.blockstack_cli_lookup(fqn)
if 'error' in res:
print res
return False
print res
if res['profile'] != {'type': 'Person', 'name': fqn}:
print 'wrong profile'
print res['profile']
return False
# test REST lookup
res = testlib.blockstack_REST_call("GET", "/v1/users/{}".format(fqn),
ses)
if 'error' in res:
res['test'] = 'Failed to query name profile'
print json.dumps(res)
return False
if res['http_status'] != 200 and res['http_status'] != 404:
res['test'] = 'HTTP status {}, response = {} on name profile lookup'.format(
res['http_status'], res['response'])
print json.dumps(res)
return False
print res
if res['response'] != {'type': 'Person', 'name': fqn}:
print 'wrong profile on REST call'
print res
return False
# test CLI lookup by address
res = testlib.blockstack_cli_get_names_owned_by_address(
wallets[4].addr)
if 'error' in res:
print 'failed to get subdomains owned by {}'.format(
wallets[4].addr)
print res
return False
if fqn not in res:
print '{} not in list'.format(fqn)
print res
return False
# test REST lookup by address
res = testlib.blockstack_REST_call(
'GET', '/v1/addresses/bitcoin/{}'.format(wallets[4].addr), ses)
if 'error' in res:
res['test'] = 'Failed to query names owned by address'
print json.dumps(res)
return False
if res['http_status'] != 200 and res['http_status'] != 404:
res['test'] = 'HTTP status {}, response = {} on address lookup'.format(
res['http_status'], res['response'])
print json.dumps(res)
return False
if fqn not in res['response']['names']:
print '{} not in REST list'.format(fqn)
print res
return False
# test REST get name history
res = testlib.blockstack_REST_call('GET',
'/v1/names/{}/history'.format(fqn),
ses)
if 'error' in res:
res['test'] = 'Failed to query subdomain history'
print json.dumps(res)
return False
if res['http_status'] != 200 and res['http_status'] != 404:
res['test'] = 'HTTP status {}, response = {} on subdomain history lookup'.format(
res['http_status'], res['response'])
print json.dumps(res)
return False
blocks = res['response']
if len(blocks.keys()) != 2:
print 'expected two updates'
print blocks
return False
# get each historic zone file
for block_height in blocks:
for prev_state in blocks[block_height]:
value_hash = prev_state['value_hash']
res = testlib.blockstack_REST_call(
'GET', '/v1/names/{}/zonefile/{}'.format(fqn, value_hash),
ses)
if 'error' in res:
print 'failed to query zone file {} for {}'.format(
value_hash, fqn)
print json.dumps(res)
return False
# reindex
assert testlib.check_subdomain_db(**kw)
def scenario(wallets, **kw):
global zonefile_hash
testlib.ysi_namespace_preorder("test", wallets[1].addr, wallets[0].privkey)
testlib.next_block(**kw)
testlib.ysi_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.ysi_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
wallet = testlib.ysi_client_initialize_wallet("0123456789abcdef",
wallets[2].privkey,
wallets[3].privkey,
wallets[4].privkey)
resp = testlib.ysi_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 initial 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)
# store a new zonefile
data_pubkey = wallet['data_pubkey']
zonefile = ysi_client.zonefile.make_empty_zonefile("foo.test", data_pubkey)
assert ysi_client.user.put_immutable_data_zonefile(
zonefile, "testdata", ysi_client.get_data_hash("testdata"))
zonefile_txt = ysi_zones.make_zone_file(zonefile)
zonefile_hash = ysi_client.storage.get_zonefile_data_hash(zonefile_txt)
print >> sys.stderr, "\n\nzonefile hash: %s\nzonefile:\n%s\n\n" % (
zonefile_hash, zonefile_txt)
# will store to queue
test_proxy = testlib.make_proxy()
config_path = test_proxy.config_path
conf = ysi_client.config.get_config(config_path)
queuedb_path = conf['queue_path']
# update the zonefile hash, but not the zonefile.
resp = testlib.ysi_cli_set_zonefile_hash("foo.test", zonefile_hash)
if 'error' in resp:
print >> sys.stderr, "\nFailed to set zonefile hash: %s\n" % resp
return False
txhash = resp['transaction_hash']
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)
# stop endpoint
print >> sys.stderr, "\nstopping RPC daemon\n"
testlib.stop_api()
time.sleep(3)
# store to queue
res = ysi_client.backend.queue.queue_append(
"update",
"foo.test",
txhash,
payment_address=wallets[2].addr,
owner_address=wallets[3].addr,
config_path=test_proxy.config_path,
zonefile_data=zonefile_txt,
zonefile_hash=zonefile_hash,
path=queuedb_path)
# verify that we can sync the zonefile, using the in-queue zonefile
resp = testlib.ysi_cli_sync_zonefile("foo.test")
if 'error' in resp:
print >> sys.stderr, "\nfailed to sync zonefile: %s\n" % resp
return False
ysi_client.backend.queue.queuedb_remove("update",
"foo.test",
txhash,
path=queuedb_path)
print >> sys.stderr, "\nstarting RPC daemon\n"
testlib.start_api("0123456789abcdef")
# store a new zonefile
zonefile = ysi_client.zonefile.make_empty_zonefile("foo.test", data_pubkey)
ysi_client.user.put_immutable_data_zonefile(
zonefile, "testdata2", ysi_client.get_data_hash("testdata"))
zonefile_txt = ysi_zones.make_zone_file(zonefile)
zonefile_hash = ysi_client.storage.get_zonefile_data_hash(zonefile_txt)
# store locally
res = ysi_client.zonefile.store_name_zonefile("foo.test",
zonefile,
None,
storage_drivers=['disk'])
if 'error' in res:
print >> sys.stderr, "\nFailed to store zonefile: %s\n" % res
return False
# update the zonefile hash, but not the zonefile.
resp = testlib.ysi_cli_set_zonefile_hash("foo.test", zonefile_hash)
if 'error' in resp:
print >> sys.stderr, "\nFailed to set zonefile hash: %s\n" % resp
return False
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)
# verify that we can sync the zonefile, using the on-disk zonefile
resp = testlib.ysi_cli_sync_zonefile("foo.test")
if 'error' in resp:
print >> sys.stderr, "update 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 acknowedge the update"
time.sleep(10)
def scenario(wallets, **kw):
wallet = testlib.ysi_client_initialize_wallet("0123456789abcdef",
wallets[2].privkey,
wallets[3].privkey,
wallets[4].privkey)
testlib.ysi_namespace_preorder("test", wallets[1].addr, wallets[0].privkey)
testlib.next_block(**kw)
testlib.ysi_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.ysi_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.ysi_name_preorder("foo1.test", wallets[2].privkey, wallets[3].addr)
testlib.ysi_name_preorder("foo2.test", wallets[2].privkey, wallets[3].addr)
testlib.ysi_name_preorder("foo3.test", wallets[2].privkey, wallets[3].addr)
testlib.next_block(**kw)
# make zonefiles:
# one with a data key
# one without a data key
# one with a nonstandard zonefile
zf1 = ysi_client.zonefile.make_empty_zonefile('foo1.test',
wallets[4].pubkey_hex)
zf1_txt = ysi_zones.make_zone_file(zf1)
zf2 = ysi_client.zonefile.make_empty_zonefile('foo2.test', None)
zf2_txt = ysi_zones.make_zone_file(zf2)
zf3_txt = '\x00\x01\x02\x03\x04\x05'
testlib.ysi_name_register(
"foo1.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash=ysi_client.get_zonefile_data_hash(zf1_txt))
testlib.ysi_name_register(
"foo2.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash=ysi_client.get_zonefile_data_hash(zf2_txt))
testlib.ysi_name_register(
"foo3.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash=ysi_client.get_zonefile_data_hash(zf3_txt))
testlib.next_block(**kw)
# replicate zonefiles
proxy = testlib.make_proxy()
res = ysi_client.proxy.put_zonefiles("localhost:{}".format(
ysi.RPC_SERVER_PORT), [
base64.b64encode(zf1_txt),
base64.b64encode(zf2_txt),
base64.b64encode(zf3_txt)
],
proxy=proxy)
if 'error' in res:
print res
return False
for s in res['saved']:
if s != 1:
print res
return False
print 'waiting for zonefiles to be saved...'
time.sleep(5)
# store signed profile for each
working_dir = os.environ['VIRTUALCHAIN_WORKING_DIR']
for name in ['foo1.test', 'foo2.test', 'foo3.test']:
profile = ysi_client.user.make_empty_user_profile()
profile['name'] = name
profile_path = os.path.join(working_dir, '{}.profile'.format(name))
with open(profile_path, 'w') as f:
f.write(json.dumps(profile))
print 'sign profile for {}'.format(name)
jwt = testlib.ysi_cli_sign_profile(name, profile_path)
if 'error' in jwt:
print jwt
return False
jwt_path = os.path.join(working_dir, '{}.profile.jwt'.format(name))
with open(jwt_path, 'w') as f:
f.write(jwt)
print 'verify profile for {}'.format(name)
res = testlib.ysi_cli_verify_profile(name, jwt_path)
if 'error' in res:
print res
return False
print 'store profile for {}'.format(name)
# store the jwt to the right place
res = ysi_client.storage.put_mutable_data(name,
jwt,
sign=False,
profile=True,
raw=True)
if not res:
print res
return False
print 'lookup profile for {}'.format(name)
# lookup
res = testlib.ysi_cli_lookup(name)
if name != 'foo3.test':
if 'error' in res:
print res
return False
if res['profile'] != profile:
print 'profile mismatch:'
print res
print profile
return False
else:
if 'error' not in res:
print res
return False
def scenario(wallets, **kw):
zonefile_batches = []
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{}"
zf_default_url = '_https._tcp URI 10 1 "https://raw.githubusercontent.com/nobody/content/profile.md"'
# send initial subdomain zone files
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)),
}
zonefile_batches.append(zonefiles)
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.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)
# send updates too, but only via a sequence of foo's
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)
update_foo = 'foo{}.test'.format(i + 4)
zonefiles = {
'foo1.test':
zf_template.format(
update_foo,
subdomains.make_subdomain_txt(
'bar.foo1.test', update_foo, wallets[4].addr, i + 1,
zf_template.format('bar.foo1.test', zf_default_url),
wallets[4].privkey)),
'foo2.test':
zf_template.format(
update_foo,
subdomains.make_subdomain_txt(
'bar.foo2.test', update_foo, wallets[4].addr, i + 1,
zf_template.format('bar.foo2.test', zf_default_url),
wallets[4].privkey)),
'foo3.test':
zf_template.format(
update_foo,
subdomains.make_subdomain_txt(
'bar.foo3.test', update_foo, wallets[4].addr, i + 1,
zf_template.format('bar.foo3.test', zf_default_url),
wallets[4].privkey)),
}
zonefile_batches.append(zonefiles)
testlib.blockstack_name_update(
update_foo, storage.get_zonefile_data_hash(zonefiles['foo1.test']),
wallets[3].privkey)
testlib.blockstack_name_update(
update_foo, storage.get_zonefile_data_hash(zonefiles['foo2.test']),
wallets[3].privkey)
testlib.blockstack_name_update(
update_foo, storage.get_zonefile_data_hash(zonefiles['foo3.test']),
wallets[3].privkey)
testlib.next_block(**kw)
# send zonefiles in reverse order, and reindex at each batch
for zfbatch in reversed(zonefile_batches):
for name in zfbatch:
assert testlib.blockstack_put_zonefile(zfbatch[name])
testlib.next_block(**kw)
# query each subdomain
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
if 'error' in res:
print res
return False
# should all have domain foo6.test
if res['domain'] != 'foo6.test':
print 'wrong domain'
print res
return False
# should all have sequence 3
if res['sequence'] != 3:
print 'wrong sequence'
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("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)
def _query_subdomains(subdomain_names, expected_sequence, expected_owner):
# query each subdomain. Should get the latest
proxy = testlib.make_proxy()
for fqn in subdomain_names:
res = client.get_name_record(fqn, proxy=proxy)
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
return True
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)
assert _query_subdomains(
['bar.foo1.test', 'bar.foo2.test', 'bar.foo3.test'], 0,
wallets[4].addr)
expected_owners = [wallets[4].addr]
# send updates too, and transfer subdomains
for i in range(0, 6):
zf_template = "$ORIGIN {}\n$TTL 3600\n{}"
zf_default_url = '_https._tcp URI 10 1 "https://test.com/?index={}"'.format(
i + 1)
j = (4 + i) % 5
k = (4 + i + 1) % 5
expected_owners.append(wallets[k].addr)
zonefiles = {
'foo1.test':
zf_template.format(
'foo1.test',
subdomains.make_subdomain_txt(
'bar.foo1.test', 'foo1.test', wallets[k].addr, i + 1,
zf_template.format('bar.foo1.test', zf_default_url),
wallets[j].privkey)),
'foo2.test':
zf_template.format(
'foo2.test',
subdomains.make_subdomain_txt(
'bar.foo2.test', 'foo2.test', wallets[k].addr, i + 1,
zf_template.format('bar.foo2.test', zf_default_url),
wallets[j].privkey)),
'foo3.test':
zf_template.format(
'foo3.test',
subdomains.make_subdomain_txt(
'bar.foo3.test', 'foo3.test', wallets[k].addr, i + 1,
zf_template.format('bar.foo3.test', zf_default_url),
wallets[j].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
testlib.next_block(**kw)
# verify history
assert _query_subdomains(
['bar.foo1.test', 'bar.foo2.test', 'bar.foo3.test'], i + 1,
wallets[k].addr)
# query subdomain history
proxy = testlib.make_proxy()
for subd in ['bar.foo1.test', 'bar.foo2.test', 'bar.foo3.test']:
res = client.get_name_record(subd, include_history=True, proxy=proxy)
if 'error' in res:
print res
return False
for i, block_height in enumerate(sorted(res['history'])):
if res['history'][block_height][0]['address'] != expected_owners[i]:
print 'wrong owner at {}: expected {}'.format(
block_height, expected_owners[i])
print json.dumps(res, indent=4, sort_keys=True)
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):
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{}"
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.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)
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
proxy = testlib.make_proxy()
for fqn in subdomain_names:
res = client.get_name_record(fqn, proxy=proxy)
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),
]
sequence_schedule = [
1,
1,
2,
2,
]
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 = []
# send updates too, and transfer subdomains
for i in range(0, 4):
zf_template = "$ORIGIN {}\n$TTL 3600\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.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.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.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)
# 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
proxy = testlib.make_proxy()
for subd in ['bar.foo1.test', 'bar.foo2.test', 'bar.foo3.test']:
res = client.get_name_record(subd, include_history=True, proxy=proxy)
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
proxy = testlib.make_proxy()
for subd in ['bar.foo1.test', 'bar.foo2.test', 'bar.foo3.test']:
res = client.get_name_record(subd, include_history=True, proxy=proxy)
if 'error' in res:
print res
return False
if res['pending']:
print 'pending, but it should not be'
print res
return False
if res['sequence'] != 2:
print 'wrong sequence'
print res
return False
if virtualchain.address_reencode(str(
res['address'])) != virtualchain.address_reencode(
wallets[1].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 ):
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{}"
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.blockstack_name_register( "foo4.test", wallets[2].privkey, wallets[3].addr, zonefile_hash='11' * 20)
testlib.blockstack_name_register( "foo5.test", wallets[2].privkey, wallets[3].addr, zonefile_hash='11' * 20)
testlib.blockstack_name_register( "foo6.test", wallets[2].privkey, wallets[3].addr, zonefile_hash='11' * 20)
testlib.blockstack_name_register( "foo7.test", wallets[2].privkey, wallets[3].addr, zonefile_hash='11' * 20)
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'])
# 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), # won't be accepted due to domain independence
(4, 1), # will be accepted
(1, 2), # won't be accepted due to domain independence
(1, 3), # will be accepted
]
sequence_schedule = [
1, # won't be accepted due to domain independence
1, # will be accepted
2, # won't be accepted due to domain independence
2, # will be accepted
]
expected_zf_default_url = '_https._tcp URI 10 1 "https://test.com/?index={}"'.format(4)
for i in range(0, 4):
zf_template = "$ORIGIN {}\n$TTL 3600\n{}"
zf_default_url = '_https._tcp URI 10 1 "https://test.com/?index={}"'.format(i+1)
if i % 2 == 0:
names = [
'foo{}.test'.format(i+4),
'foo{}.test'.format(i+4),
'foo{}.test'.format(i+4),
]
else:
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.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.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.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)
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
testlib.next_block(**kw)
# query each subdomain
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
if 'error' in res:
print res
return False
if res['sequence'] != 2:
print 'wrong sequence'
print res
return False
if virtualchain.address_reencode(str(res['address'])) != virtualchain.address_reencode(wallets[3].addr):
print 'wrong owner'
print res
return False
expected_zonefile = zf_template.format(fqn, expected_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
# there should only be three history items per name
hist = client.get_name_record(fqn, proxy=proxy, include_history=True)
if 'error' in hist:
print res
return False
if len(hist['history']) != 3:
print 'wrong history length'
print res
return False
# reindex
assert testlib.check_subdomain_db(**kw)
def scenario( wallets, **kw ):
global zonefile_hash, final_balance, new_expire_block
testlib.ysi_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.ysi_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.ysi_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
wallet = testlib.ysi_client_initialize_wallet( "0123456789abcdef", wallets[2].privkey, wallets[3].privkey, wallets[4].privkey )
resp = testlib.ysi_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)
# what's the name's renewal block?
proxy = testlib.make_proxy()
res = ysi_client.get_name_blockchain_record( "foo.test", proxy=proxy )
if 'error' in res:
print >> sys.stderr, json.dumps(res, indent=4, sort_keys=True)
return False
old_expire_block = res['expire_block']
new_zonefile = ysi_client.zonefile.make_empty_zonefile('foo.test', None)
new_zonefile_txt = ysi_zones.make_zone_file(new_zonefile)
print 'renew with:'
print new_zonefile_txt
# renew it
resp = testlib.ysi_cli_renew( "foo.test", "0123456789abcdef", new_zonefile_txt=new_zonefile_txt )
if 'error' in resp:
print >> sys.stderr, "Renewal request failed:\n%s" % json.dumps(resp, indent=4, sort_keys=True)
return False
# wait for it to go through
for i in xrange(0, 6):
# 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 )
# verify that it's in the queue
queue_state = testlib.ysi_cli_info()
if 'error' in queue_state:
print json.dumps(queue_state)
return False
if not queue_state.has_key('queues'):
print 'no queues'
print json.dumps(queue_state)
return False
if not queue_state['queues'].has_key('renew'):
print 'no renew queue'
print json.dumps(queue_state)
return False
if len(queue_state['queues']['renew']) != 1:
print 'wrong renew state'
print json.dumps(queue_state)
return False
if queue_state['queues']['renew'][0]['name'] != 'foo.test':
print 'wrong name'
print json.dumps(queue_state)
return False
# wait for it to go through
for i in xrange(0, 6):
# 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 )
proxy = testlib.make_proxy()
res = ysi_client.get_name_blockchain_record( "foo.test", proxy=proxy )
if 'error' in res:
print >> sys.stderr, json.dumps(res, indent=4, sort_keys=True)
return False
zonefile_hash = res['value_hash']
zf = testlib.ysi_cli_get_name_zonefile("foo.test")
if 'error' in zf:
print zf
return False
print zf
if zf != new_zonefile_txt:
print 'zonefile mismatch'
print 'expected:'
print new_zonefile_txt
print 'got:'
print zf
return False
new_expire_block = res['expire_block']
if old_expire_block >= new_expire_block + 12:
# didn't go through
print >> sys.stderr, "Renewal didn't go through: %s --> %s" % (old_expire_block, new_expire_block)
return False
if res['op'] != ysi_client.config.NAME_REGISTRATION + ":":
print >> sys.stderr, "Renewal didn't go through (last op is %s)" % res['op']
error = True
return False
final_balance = testlib.getbalance( wallets[2].addr )
def scenario( wallets, **kw ):
global zonefile_hash, final_balance, new_expire_block
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):
# 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 initial 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)
# what's the name's renewal block?
proxy = testlib.make_proxy()
res = blockstack_client.get_name_blockchain_record( "foo.test", proxy=proxy )
if 'error' in res:
print >> sys.stderr, json.dumps(res, indent=4, sort_keys=True)
return False
old_expire_block = res['expire_block']
# send an update, changing the zonefile
data_pubkey = wallet['data_pubkey']
zonefile = blockstack_client.zonefile.make_empty_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_cli_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):
# 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 acknowedge the update"
time.sleep(10)
# 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 )
# renew it
resp = testlib.blockstack_cli_renew( "foo.test", "0123456789abcdef" )
if 'error' in resp:
print >> sys.stderr, "Renewal request failed:\n%s" % json.dumps(resp, indent=4, sort_keys=True)
return False
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge the renewal"
time.sleep(10)
# wait for it to go through
for i in xrange(0, 6):
# 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 )
# verify that it's in the queue
queue_state = testlib.blockstack_cli_info()
if 'error' in queue_state:
print json.dumps(queue_state)
return False
if not queue_state.has_key('queues'):
print 'no queues'
print json.dumps(queue_state)
return False
if not queue_state['queues'].has_key('renew'):
print 'no renew queue'
print json.dumps(queue_state)
return False
if len(queue_state['queues']['renew']) != 1:
print 'wrong renew state'
print json.dumps(queue_state)
return False
if queue_state['queues']['renew'][0]['name'] != 'foo.test':
print 'wrong name'
print json.dumps(queue_state)
return False
# wait for it to go through
for i in xrange(0, 6):
# 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 )
proxy = testlib.make_proxy()
res = blockstack_client.get_name_blockchain_record( "foo.test", proxy=proxy )
if 'error' in res:
print >> sys.stderr, json.dumps(res, indent=4, sort_keys=True)
return False
new_expire_block = res['expire_block']
if old_expire_block >= new_expire_block + 12:
# didn't go through
print >> sys.stderr, "Renewal didn't go through: %s --> %s" % (old_expire_block, new_expire_block)
return False
if res['op'] != blockstack_client.config.NAME_REGISTRATION + ":":
print >> sys.stderr, "Renewal didn't go through (last op is %s)" % res['op']
error = True
return False
final_balance = testlib.getbalance( wallets[2].addr )
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 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)
# 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)
# regenerate the wallet, with the new owner address
wallet = testlib.blockstack_client_set_wallet( "0123456789abcdef", wallets[2].privkey, wallets[4].privkey, wallets[4].privkey )
# renew it, using the same payment key
resp = testlib.blockstack_rpc_renew( "foo.test", "0123456789abcdef" )
if 'error' in resp:
print >> sys.stderr, "Renewal request failed:\n%s" % json.dumps(resp, indent=4, sort_keys=True)
return False
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge the renewal"
time.sleep(10)
proxy = testlib.make_proxy()
res = blockstack_client.get_name_blockchain_record( "foo.test", proxy=proxy )
if 'error' in res:
print >> sys.stderr, json.dumps(res, indent=4, sort_keys=True)
return False
new_expire_block = res['expire_block']
if old_expire_block >= new_expire_block + 12:
# didn't go through
print >> sys.stderr, "Renewal didn't go through: %s --> %s" % (old_expire_block, new_expire_block)
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"'
zf_default_url_initial = zf_default_url
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)),
}
initial_zonefiles = zonefiles
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)
zf_template = "$ORIGIN {}\n$TTL 3600\n{}"
zf_default_url = '_https._tcp URI 10 1 "https://invalid.com"'
zf_default_url_invalid = zf_default_url
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)),
}
# send updates for invalid initial subdomain records
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.
testlib.next_block(**kw)
# must all be pending
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
if not res['pending']:
print 'not pending: {}'.format(fqn)
print res
return False
# broadcast initial zonefiles and re-do subdomain indexing
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'])
testlib.next_block(**kw)
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
if 'error' in res:
print res
return False
# right subdomain zonefile
expected_zonefile = zf_template.format(fqn, zf_default_url_initial)
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):
# disable subdomains at first
subdomaindb_path = None
blockstack_opts = blockstack.lib.config.get_blockstack_opts()
assert 'subdomaindb_path' in blockstack_opts
subdomaindb_path = blockstack_opts['subdomaindb_path']
del blockstack_opts['subdomaindb_path']
blockstack.lib.config.set_blockstack_opts(blockstack_opts)
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{}"
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)),
}
# register initial subdomains
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.blockstack_name_register("foo4.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash='11' * 20)
testlib.blockstack_name_register("foo5.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash='11' * 20)
testlib.blockstack_name_register("foo6.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash='11' * 20)
testlib.blockstack_name_register("foo7.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash='11' * 20)
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'])
# send updates, but only on foo1.test.
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)
name = 'foo{}.test'.format(i + 4)
zonefiles = {
'foo1.test':
zf_template.format(
name,
subdomains.make_subdomain_txt(
'bar.foo1.test', name, wallets[4].addr, i + 1,
zf_template.format('bar.foo1.test', zf_default_url),
wallets[4].privkey)),
'foo2.test':
zf_template.format(
name,
subdomains.make_subdomain_txt(
'bar.foo2.test', name, wallets[4].addr, i + 1,
zf_template.format('bar.foo2.test', zf_default_url),
wallets[4].privkey)),
'foo3.test':
zf_template.format(
name,
subdomains.make_subdomain_txt(
'bar.foo3.test', name, wallets[4].addr, i + 1,
zf_template.format('bar.foo3.test', zf_default_url),
wallets[4].privkey)),
}
testlib.blockstack_name_update(
name, storage.get_zonefile_data_hash(zonefiles['foo1.test']),
wallets[3].privkey)
testlib.blockstack_name_update(
name, storage.get_zonefile_data_hash(zonefiles['foo2.test']),
wallets[3].privkey)
testlib.blockstack_name_update(
name, 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'])
# subdomains should not exist---we haven't indexed them yet
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
if 'error' not in res:
print 'got a subdomain'
print res
return False
# wait until they exist
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
blockstack_opts['subdomaindb_path'] = subdomaindb_path
blockstack.lib.config.set_blockstack_opts(blockstack_opts)
testlib.next_block(**kw)
# query each subdomain
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
if 'error' in res:
print res
return False
# domain should be foo6.test
if res['domain'] != 'foo6.test':
print 'wrong domain'
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(firstblock=256, **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{}"
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)),
}
# send initial subdomains
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.blockstack_name_register("foo4.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash='11' * 20)
testlib.blockstack_name_register("foo5.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash='11' * 20)
testlib.blockstack_name_register("foo6.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash='11' * 20)
testlib.blockstack_name_register("foo7.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash='11' * 20)
testlib.next_block(**kw)
# will send these later
initial_zonefiles = zonefiles
# send updates too, but all on the same name
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)
name = 'foo{}.test'.format(i + 4)
zonefiles = {
'foo1.test':
zf_template.format(
name,
subdomains.make_subdomain_txt(
'bar.foo1.test', name, wallets[4].addr, i + 1,
zf_template.format('bar.foo1.test', zf_default_url),
wallets[4].privkey)),
'foo2.test':
zf_template.format(
name,
subdomains.make_subdomain_txt(
'bar.foo2.test', name, wallets[4].addr, i + 1,
zf_template.format('bar.foo2.test', zf_default_url),
wallets[4].privkey)),
'foo3.test':
zf_template.format(
name,
subdomains.make_subdomain_txt(
'bar.foo3.test', name, wallets[4].addr, i + 1,
zf_template.format('bar.foo3.test', zf_default_url),
wallets[4].privkey)),
}
testlib.blockstack_name_update(
name, storage.get_zonefile_data_hash(zonefiles['foo1.test']),
wallets[3].privkey)
testlib.blockstack_name_update(
name, storage.get_zonefile_data_hash(zonefiles['foo2.test']),
wallets[3].privkey)
testlib.blockstack_name_update(
name, 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
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
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("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)
# whois
for i in xrange(1, 4):
name = 'foo{}.test'.format(i)
res = testlib.blockstack_cli_whois(name)
if 'error' in res:
print res
return False
if not res.has_key('zonefile_hash') or res[
'zonefile_hash'] != storage.get_zonefile_data_hash(
zonefiles[name]):
print res
return False
if res['owner_address'] != wallets[3].addr:
print res
return False
# upload zonefile
assert testlib.blockstack_put_zonefile(zonefiles[name])
# kick off subdomain indexing
testlib.next_block(**kw)
# query each subdomain
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
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("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)
assert testlib.blockstack_put_zonefile(zonefiles['foo1.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo2.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo3.test'])
# send two sequence=1 updates, but withhold the first batch. send the second batch now, and then send the first batch later to confirm
# that each subdomain's history gets reorganized.
# first sequence=1 update (withheld)
zf_template = "$ORIGIN {}\n$TTL 3600\n{}"
zf_default_url = '_https._tcp URI 10 1 "https://test.com/withheld?index={}"'.format(
1)
zf_default_url_reorg = zf_default_url
zonefiles = {
'foo1.test':
zf_template.format(
'foo1.test',
subdomains.make_subdomain_txt(
'bar.foo1.test', 'foo1.test', wallets[4].addr, 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, 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, 1,
zf_template.format('bar.foo3.test', zf_default_url),
wallets[4].privkey)),
}
zonefiles_reorg = zonefiles
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)
# second sequence=1 update (sent now)
zf_template = "$ORIGIN {}\n$TTL 3600\n{}"
zf_default_url = '_https._tcp URI 10 1 "https://test.com/?index={}"'.format(
1)
zf_default_url_seq1 = zf_default_url
zonefiles = {
'foo1.test':
zf_template.format(
'foo1.test',
subdomains.make_subdomain_txt(
'bar.foo1.test', 'foo1.test', wallets[4].addr, 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, 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, 1,
zf_template.format('bar.foo3.test', zf_default_url),
wallets[4].privkey)),
}
zonefiles_seq1 = zonefiles
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'])
# sequence=2 (send now)
zf_template = "$ORIGIN {}\n$TTL 3600\n{}"
zf_default_url = '_https._tcp URI 10 1 "https://test.com/?index={}"'.format(
1)
zonefiles = {
'foo1.test':
zf_template.format(
'foo1.test',
subdomains.make_subdomain_txt(
'bar.foo1.test', 'foo1.test', wallets[4].addr, 2,
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, 2,
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, 2,
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'])
def _query_subdomains():
# query each subdomain. Should get the latest
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
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
return True
# kick off subdomain indexing
testlib.next_block(**kw)
assert _query_subdomains()
# query each subdomain history. sequence=1 should have test.com, but not 'withheld'
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
proxy = testlib.make_proxy()
res = client.get_name_record(fqn, proxy=proxy, include_history=True)
if 'error' in res:
print res
return False
# expect zonefile
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
# find historic
historic_blocks = res['history'].keys()
historic_blocks.sort()
historic_zfhash = res['history'][str(
historic_blocks[1])][0]['value_hash']
# historic zone file (sequence=1) should NOT be withheld
zf = testlib.blockstack_get_zonefile(historic_zfhash, parse=False)
if not zf:
print 'no zone file {} for sequence=1 in atlas'.format(
res['value_hash'])
return False
expected_zonefile = zf_template.format(fqn, zf_default_url_seq1)
if zf != expected_zonefile:
print 'zonefile mismatch in atlas at sequence=1'
print 'expected\n{}'.format(expected_zonefile)
print 'got\n{}'.format(base64.b64decode(res['zonefile']))
return False
# reorg each zonefile's history
assert testlib.blockstack_put_zonefile(zonefiles_reorg['foo1.test'])
assert testlib.blockstack_put_zonefile(zonefiles_reorg['foo2.test'])
assert testlib.blockstack_put_zonefile(zonefiles_reorg['foo3.test'])
# kick off subdomain indexing
testlib.next_block(**kw)
assert _query_subdomains()
# query each subdomain history. sequence=1 should have test.com, but with 'withheld' present in the URL
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
proxy = testlib.make_proxy()
res = client.get_name_record(fqn, proxy=proxy, include_history=True)
if 'error' in res:
print res
return False
# expect zonefile
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
# find historic
historic_blocks = res['history'].keys()
historic_blocks.sort()
historic_zfhash = res['history'][str(
historic_blocks[1])][0]['value_hash']
# historic zone file (sequence=1) should NOT be withheld
zf = testlib.blockstack_get_zonefile(historic_zfhash, parse=False)
if not zf:
print 'no zone file {} for sequence=1 in atlas'.format(
res['value_hash'])
return False
expected_zonefile = zf_template.format(fqn, zf_default_url_reorg)
if zf != expected_zonefile:
print 'zonefile mismatch in atlas at sequence=1'
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 ):
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)
# store a new 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") )
zonefile_json = json.dumps(zonefile)
zonefile_hash = blockstack_client.storage.hash_zonefile( zonefile )
# will store to queue
test_proxy = testlib.make_proxy()
config_path = test_proxy.config_path
conf = blockstack_client.config.get_config(config_path)
queuedb_path = conf['queue_path']
# update the zonefile hash, but not the zonefile.
resp = testlib.blockstack_rpc_set_zonefile_hash( "foo.test", zonefile_hash )
if 'error' in resp:
print >> sys.stderr, "\nFailed to set zonefile hash: %s\n" % resp
return False
txhash = resp['transaction_hash']
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)
# stop endpoint
print >> sys.stderr, "\nstopping RPC daemon\n"
config_dir = os.path.dirname(test_proxy.config_path)
blockstack_client.rpc.local_rpc_stop(config_dir=config_dir)
time.sleep(3)
# store to queue
res = blockstack_client.backend.queue.queue_append("update", "foo.test", txhash, payment_address=wallets[2].addr, owner_address=wallets[3].addr,
config_path=test_proxy.config_path, zonefile=zonefile, zonefile_hash=zonefile_hash, path=queuedb_path )
# verify that we can sync the zonefile, using the in-queue zonefile
resp = testlib.blockstack_rpc_sync_zonefile( "foo.test" )
if 'error' in resp:
print >> sys.stderr, "\nfailed to sync zonefile: %s\n" % resp
return False
blockstack_client.backend.queue.queuedb_remove("update", "foo.test", txhash, path=queuedb_path )
print >> sys.stderr, "\nstarting RPC daemon\n"
blockstack_client.actions.start_rpc_endpoint(config_dir, password="******")
time.sleep(3)
# store a new zonefile
zonefile = blockstack_client.user.make_empty_user_zonefile( "foo.test", data_pubkey )
blockstack_client.user.put_immutable_data_zonefile( zonefile, "testdata2", blockstack_client.get_data_hash("testdata") )
zonefile_json = json.dumps(zonefile)
zonefile_hash = blockstack_client.storage.hash_zonefile( zonefile )
# store locally
res = blockstack_client.profile.store_name_zonefile("foo.test", zonefile, None, storage_drivers=['disk'])
if 'error' in res:
print >> sys.stderr, "\nFailed to store zonefile: %s\n" % res
return False
# update the zonefile hash, but not the zonefile.
resp = testlib.blockstack_rpc_set_zonefile_hash( "foo.test", zonefile_hash )
if 'error' in resp:
print >> sys.stderr, "\nFailed to set zonefile hash: %s\n" % resp
return False
for i in xrange(0, 12):
testlib.next_block( **kw )
# verify that we can sync the zonefile, using the on-disk zonefile
resp = testlib.blockstack_rpc_sync_zonefile( "foo.test" )
if 'error' in resp:
print >> sys.stderr, "update 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 acknowedge the update"
time.sleep(10)
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_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 initial 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)
# what's the name's renewal block?
proxy = testlib.make_proxy()
res = blockstack_client.get_name_blockchain_record( "foo.test", proxy=proxy )
if 'error' in res:
print >> sys.stderr, json.dumps(res, indent=4, sort_keys=True)
return False
old_expire_block = res['expire_block']
# send an update, changing the zonefile
data_pubkey = wallet['data_pubkey']
zonefile = blockstack_client.zonefile.make_empty_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_cli_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):
# 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 acknowedge the update"
time.sleep(10)
# 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 )
# revoke it
resp = testlib.blockstack_cli_revoke( "foo.test", "0123456789abcdef" )
if 'error' in resp:
print >> sys.stderr, "Revoke request failed:\n%s" % json.dumps(resp, indent=4, sort_keys=True)
return False
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge the revoke"
time.sleep(10)
# wait for it to go through
for i in xrange(0, 12):
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("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{}"
subdomain_zonefile_pattern = '$ORIGIN {}\n$TTL 3600\n_https._tcp URI 10 1 "https://raw.githubusercontent.com/bar{}/profile.md'
zonefiles = {
'foo1.test':
make_subdomain_zone_file('foo1.test', 'bar{}.foo1.test',
subdomain_zonefile_pattern, 0, 100, 40960,
wallets[4].privkey),
'foo2.test':
make_subdomain_zone_file('foo2.test', 'bar{}.foo2.test',
subdomain_zonefile_pattern, 0, 100, 40960,
wallets[4].privkey),
'foo3.test':
make_subdomain_zone_file('foo3.test', 'bar{}.foo3.test',
subdomain_zonefile_pattern, 0, 100, 40960,
wallets[4].privkey)
}
# register initial subdomains
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.blockstack_name_register("foo4.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash='11' * 20)
testlib.blockstack_name_register("foo5.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash='11' * 20)
testlib.blockstack_name_register("foo6.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash='11' * 20)
testlib.blockstack_name_register("foo7.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash='11' * 20)
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'])
# send updates on different names.
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)
name = 'foo{}.test'.format(i + 4)
zonefiles = {
'foo1.test':
make_subdomain_zone_file(name, 'bar{}.foo1.test',
subdomain_zonefile_pattern, i + 1, 100,
40960, wallets[4].privkey),
'foo2.test':
make_subdomain_zone_file(name, 'bar{}.foo2.test',
subdomain_zonefile_pattern, i + 1, 100,
40960, wallets[4].privkey),
'foo3.test':
make_subdomain_zone_file(name, 'bar{}.foo3.test',
subdomain_zonefile_pattern, i + 1, 100,
40960, wallets[4].privkey),
}
testlib.blockstack_name_update(
name, storage.get_zonefile_data_hash(zonefiles['foo1.test']),
wallets[3].privkey)
testlib.blockstack_name_update(
name, storage.get_zonefile_data_hash(zonefiles['foo2.test']),
wallets[3].privkey)
testlib.blockstack_name_update(
name, 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
testlib.next_block(**kw)
# query each subdomain
proxy = testlib.make_proxy()
for domain in zonefiles:
for i in range(0, 100):
fqn = 'bar{}.{}'.format(i, domain)
res = client.get_name_record(fqn, proxy=proxy)
if 'error' in res:
print res
return False
# domain should be foo6.test
if res['domain'] != 'foo6.test':
print 'wrong domain'
print res
return False
expected_zonefile = subdomain_zonefile_pattern.format(fqn, i)
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)