def scenario( wallets, **kw ):
testlib.ysi_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
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, version_bits=2)
testlib.next_block( **kw )
resp = testlib.ysi_name_import( "foo.test", wallets[3].addr, "11" * 20, wallets[1].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
return False
testlib.next_block( **kw )
testlib.ysi_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
# expire it
for i in xrange(0, 4):
testlib.next_block(**kw)
whois = testlib.ysi_cli_whois('foo.test')
if 'error' not in whois:
print whois
return False
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'])
res = testlib.ysi_name_preorder( "foo.test", wallets[2].privkey, wallets[4].addr )
if 'error' in res:
print res
return False
testlib.next_block( **kw )
res = testlib.ysi_name_register( "foo.test", wallets[2].privkey, wallets[4].addr, zonefile_hash='22' * 20 )
if 'error' in res:
print res
return False
testlib.next_block( **kw )
new_namespace_balance = testlib.get_balance(namespace_rec['address'])
name_rec = testlib.get_name_blockchain_record('foo.test')
name_cost = name_rec['op_fee']
if new_namespace_balance - namespace_balance != name_cost:
print 'address {} did not get credited'.format(namespace_rec['address'])
print '{} != {} + {}'.format(new_namespace_balance, namespace_balance, name_cost)
return False
if name_rec['value_hash'] != '22' * 20:
print 'wrong value hash'
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,
version_bits=2)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
namespace_rec = testlib.blockstack_cli_get_namespace_blockchain_record(
"test")
if 'error' in namespace_rec:
print namespace_rec
return False
namespace_balance = testlib.get_balance(namespace_rec['address'])
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
new_namespace_balance = testlib.get_balance(namespace_rec['address'])
name_rec = testlib.get_name_blockchain_record('foo.test')
name_cost = name_rec['op_fee']
if new_namespace_balance - namespace_balance != name_cost:
print 'address {} did not get credited'.format(
namespace_rec['address'])
print '{} != {} + {}'.format(new_namespace_balance, namespace_balance,
name_cost)
return False
def scenario( wallets, **kw ):
testlib.ysi_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
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, version_bits=2)
testlib.next_block( **kw )
resp = testlib.ysi_name_import( "foo.test", wallets[3].addr, "11" * 20, wallets[1].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
return False
testlib.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'])
testlib.ysi_name_renew("foo.test", wallets[3].privkey)
testlib.next_block(**kw)
new_namespace_balance = testlib.get_balance(namespace_rec['address'])
name_rec = testlib.get_name_blockchain_record('foo.test')
name_cost = name_rec['op_fee']
if new_namespace_balance - namespace_balance != name_cost:
print 'address {} did not get credited'.format(namespace_rec['address'])
print '{} != {} + {}'.format(new_namespace_balance, namespace_balance, name_cost)
return False
testlib.ysi_name_renew("foo.test", wallets[3].privkey, recipient_addr=wallets[4].addr, zonefile_hash='22' * 20)
testlib.next_block(**kw)
new_namespace_balance = testlib.get_balance(namespace_rec['address'])
name_rec = testlib.get_name_blockchain_record('foo.test')
name_cost = name_rec['op_fee']
if new_namespace_balance - namespace_balance != 2*name_cost:
print 'address {} did not get credited'.format(namespace_rec['address'])
print '{} != {} + {}'.format(new_namespace_balance, namespace_balance, 2*name_cost)
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,
version_bits=2)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
namespace_rec = testlib.blockstack_cli_get_namespace_blockchain_record(
"test")
if 'error' in namespace_rec:
print namespace_rec
return False
namespace_balance = testlib.get_balance(namespace_rec['address'])
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
# renew/xfer/update
res = testlib.blockstack_name_renew("foo.test",
wallets[3].privkey,
zonefile_hash="22" * 20,
recipient_addr=wallets[4].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
# renew/update
res = testlib.blockstack_name_renew("foo.test",
wallets[4].privkey,
zonefile_hash="33" * 20)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
# renew/xfer
res = testlib.blockstack_name_renew("foo.test",
wallets[4].privkey,
recipient_addr=wallets[1].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
# renew
res = testlib.blockstack_name_renew("foo.test", wallets[1].privkey)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
new_namespace_balance = testlib.get_balance(namespace_rec['address'])
name_rec = testlib.get_name_blockchain_record('foo.test')
name_cost = name_rec['op_fee']
if new_namespace_balance - namespace_balance != name_cost * 5:
print 'address {} did not get credited'.format(
namespace_rec['address'])
print '{} != {} + {}'.format(new_namespace_balance, namespace_balance,
name_cost * 5)
return False
def scenario(wallets, **kw):
print '\nactivating segwit\n'
virtualchain.set_features("segwit", True)
print '\nsegwit state: {}\n'.format(virtualchain.get_features('segwit'))
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[5].privkey)
testlib.blockstack_namespace_preorder("mult", wallets[2].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[5].privkey)
testlib.blockstack_namespace_reveal(
"mult",
wallets[2].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)
private_keychain = keychain.PrivateKeychain.from_private_key(
wallets[2].privkey)
private_keys = [
wallets[2].privkey
] # NOTE: always start with the reveal key, then use children
for i in xrange(0, 4):
import_key = private_keychain.child(i).private_key()
print "fund {} (child {})".format(import_key, i)
res = testlib.send_funds(
wallets[1].privkey, 100000000,
virtualchain.BitcoinPrivateKey(import_key).public_key().address())
if 'error' in res:
print json.dumps(res, indent=4, sort_keys=True)
return False
testlib.next_block(**kw)
private_keys.append(import_key)
# should succeed
resp = testlib.blockstack_name_import("foo.mult", wallets[2].addr,
'00' * 20, private_keys[0])
if 'error' in resp:
print json.dumps(resp, indent=4, sort_keys=True)
return False
testlib.next_block(**kw)
# should succeed
resp = testlib.blockstack_name_import("bar.mult", wallets[3].addr,
"11" * 20, private_keys[1])
if 'error' in resp:
print json.dumps(resp, indent=4, sort_keys=True)
return False
# should succeed
resp = testlib.blockstack_name_import("baz.mult", wallets[4].addr,
"22" * 20, private_keys[2])
if 'error' in resp:
print json.dumps(resp, indent=4, sort_keys=True)
return False
# should succeed
resp = testlib.blockstack_name_import("goo.mult", wallets[5].addr,
"33" * 20, private_keys[3])
if 'error' in resp:
print json.dumps(resp, indent=4, sort_keys=True)
return False
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.blockstack_namespace_ready("mult", wallets[2].privkey)
testlib.next_block(**kw)
namespace_balance = testlib.get_balance(wallets[0].addr)
# get prices
hello_cost = testlib.blockstack_get_name_cost('hello.mult')
world_cost = testlib.blockstack_get_name_cost('world.mult')
foo_cost = testlib.blockstack_get_name_cost('foo.mult')
# register/renew
res = testlib.blockstack_name_preorder("hello.mult", wallets[1].privkey,
wallets[2].addr)
if 'error' in res:
print res
return False
res = testlib.blockstack_name_preorder('world.mult',
wallets[6].privkey,
wallets[7].addr,
wallet=wallets[7])
if 'error' in res:
print res
return False
res = testlib.blockstack_name_renew('foo.mult', wallets[2].privkey)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
new_namespace_balance = testlib.get_balance(wallets[0].addr)
if new_namespace_balance != namespace_balance + hello_cost + world_cost + foo_cost:
print 'wrong balance'
print new_namespace_balance
print namespace_balance
print hello_cost
print foo_cost
return False
res = testlib.blockstack_name_register("hello.mult", wallets[1].privkey,
wallets[2].addr)
if 'error' in res:
print res
return False
res = testlib.blockstack_name_register('world.mult',
wallets[6].privkey,
wallets[7].addr,
wallet=wallets[7],
zonefile_hash='44' * 20)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
def scenario(wallets, **kw):
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test",
wallets[1].addr,
52595,
250,
4, [6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
version_bits=2)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
namespace_rec = testlib.blockstack_cli_get_namespace_blockchain_record(
"test")
if 'error' in namespace_rec:
print namespace_rec
return False
namespace_balance = testlib.get_balance(namespace_rec['address'])
burn_balance = testlib.get_balance(
blockstack_client.constants.BLOCKSTACK_BURN_ADDRESS)
res = testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
res = testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
new_namespace_balance = testlib.get_balance(namespace_rec['address'])
name_rec = testlib.get_name_blockchain_record('foo.test')
name_cost = name_rec['op_fee']
if new_namespace_balance - namespace_balance != name_cost:
print 'address {} did not get credited'.format(
namespace_rec['address'])
print '{} != {} + {}'.format(new_namespace_balance, namespace_balance,
name_cost)
return False
# should send to null burn address
res = testlib.blockstack_name_preorder("foo2.test", wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print res
return False
# preorder should send to the null burn address now.
# try forcing it to the namespace burn address, to verify that it fails
res = testlib.blockstack_name_preorder("foo_fail.test",
wallets[2].privkey,
wallets[3].addr,
burn_addr=namespace_rec['address'])
if 'error' not in res:
print res
return False
res = testlib.blockstack_name_preorder("foo_fail.test",
wallets[2].privkey,
wallets[3].addr,
burn_addr=namespace_rec['address'],
safety_checks=False,
tx_fee=10000 * 5)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
# should be rejected
res = testlib.blockstack_name_register("foo_fail.test", wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print res
return False
# should be accepted
res = testlib.blockstack_name_register("foo2.test", wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
testlib.expect_snv_fail_at('foo_fail.test',
testlib.get_current_block(**kw))
# should have been rejected due to wrong burn address
whois = testlib.blockstack_cli_whois('foo_fail.test')
if 'error' not in whois:
print whois
return False
new_burn_balance = testlib.get_balance(
blockstack_client.constants.BLOCKSTACK_BURN_ADDRESS)
new_namespace_balance = testlib.get_balance(namespace_rec['address'])
name_rec_2 = testlib.get_name_blockchain_record('foo2.test')
name_cost_2 = name_rec_2['op_fee']
# namespace should NOT have gotten the fee for foo_fail. It should only have gotten it for foo.test
if new_namespace_balance - namespace_balance != name_cost + 5500:
print 'address {} got credited after fee capture period'.format(
namespace_rec['address'])
print '{} != {} + {}'.format(new_namespace_balance, namespace_balance,
name_cost)
return False
# burn address should have received the fee for the second name
if new_burn_balance - name_cost_2 != burn_balance:
print 'null burn address did not get credited'
print '{} != {} + {}'.format(new_burn_balance, burn_balance,
name_cost_2)
return False
def scenario(wallets, **kw):
# pass 100 stacks around in a circle.
new_keys = [wallets[0].privkey] + [
virtualchain.lib.ecdsalib.ecdsa_private_key().to_hex()
for i in range(0, 4)
]
for k in range(0, 4):
for j in range(0, len(new_keys)):
i = j
new_addr = virtualchain.get_privkey_address(
new_keys[(i + 1) % len(new_keys)])
cur_addr = virtualchain.get_privkey_address(
new_keys[i % len(new_keys)])
initial_new_balance_info = json.loads(
testlib.nodejs_cli('balance', new_addr))
initial_cur_balance_info = json.loads(
testlib.nodejs_cli('balance', cur_addr))
print '\n initial new balance info: {} \n'.format(
initial_new_balance_info)
if 'STACKS' not in initial_new_balance_info:
initial_new_balance_info['STACKS'] = 0
if i > 0:
testlib.send_funds(wallets[0].privkey, 500000, cur_addr)
testlib.send_funds(wallets[0].privkey, 500000, new_addr)
testlib.blockstack_send_tokens(new_addr,
'STACKS',
100,
new_keys[i % len(new_keys)],
safety_checks=False)
# consolidate
utxos = testlib.get_utxos(wallets[0].addr)
if len(utxos) > 1:
balance = testlib.get_balance(wallets[0].addr)
testlib.send_funds(wallets[0].privkey,
balance - 5500,
wallets[0].addr,
change=False)
utxos = testlib.get_utxos(new_addr)
if len(utxos) > 1:
balance = testlib.get_balance(new_addr)
testlib.send_funds(new_keys[(i + 1) % len(new_keys)],
balance - 5500,
new_addr,
change=False)
testlib.next_block(**kw)
for j in range(0, len(new_keys)):
i = j
new_addr = virtualchain.get_privkey_address(
new_keys[(i + 1) % len(new_keys)])
cur_addr = virtualchain.get_privkey_address(
new_keys[i % len(new_keys)])
if j == len(new_keys) - 1:
if (i + 1) % len(new_keys) != 0:
# last address should have 100 stacks, unless new_addr is wallets[0]
balance_info = json.loads(
testlib.nodejs_cli('balance', new_addr))
assert int(balance_info['STACKS']) == 100
else:
if i % len(new_keys) != 0:
# every other address, except wallets[0], should have 0 balance
balance_info = json.loads(
testlib.nodejs_cli('balance', cur_addr))
assert int(balance_info['STACKS']) == 0
# consolidate
for j in range(0, len(new_keys)):
cur_addr = virtualchain.get_privkey_address(
new_keys[i % len(new_keys)])
utxos = testlib.get_utxos(cur_addr)
if len(utxos) > 1:
balance = testlib.get_balance(cur_addr)
testlib.send_funds(new_keys[i % len(new_keys)],
balance - 5500,
cur_addr,
change=False)
testlib.next_block(**kw)
# each *new* address has 4 history items -- four spends, four receives
for new_key in new_keys[1:]:
new_addr = virtualchain.get_privkey_address(new_key)
history = requests.get(
'http://localhost:16268/v1/accounts/{}/history?page=0'.format(
new_addr)).json()
# should have gotten 4 debits for 100, and 4 credits for 100
assert int(history[0]['credit_value']) == 400, history
assert int(history[0]['debit_value']) == 400, history
assert len(history) == 8, history
def scenario(wallets, **kw):
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)
resp = testlib.ysi_name_import("foo.test", wallets[3].addr, "11" * 20,
wallets[1].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
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'])
burn_balance = testlib.get_balance(
ysi_client.constants.BLOCKSTACK_BURN_ADDRESS)
# should send to namespace burn address
res = testlib.ysi_name_renew('foo.test', wallets[3].privkey)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
# should send to namespace burn address
res = testlib.ysi_name_renew('foo.test', wallets[3].privkey)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
new_namespace_balance = testlib.get_balance(namespace_rec['address'])
name_rec = testlib.get_name_blockchain_record('foo.test')
name_cost = name_rec['op_fee']
if new_namespace_balance - namespace_balance != 2 * name_cost:
print 'address {} did not get credited'.format(
namespace_rec['address'])
print '{} != {} + {}'.format(new_namespace_balance, namespace_balance,
name_cost)
return False
# should be rejected if not burned
res = testlib.ysi_name_renew('foo.test',
wallets[3].privkey,
burn_addr=namespace_rec['address'])
if 'error' not in res:
print res
return False
res = testlib.ysi_name_renew('foo.test',
wallets[3].privkey,
burn_addr=namespace_rec['address'],
safety_checks=False,
tx_fee=10000 * 5)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
# should have been rejected
name_rec_2 = testlib.get_name_blockchain_record('foo.test')
if name_rec_2['last_renewed'] != name_rec['last_renewed']:
print 'accidentally renewed'
return False
# renew, but correctly (with proper burn address)
res = testlib.ysi_name_renew('foo.test', wallets[3].privkey)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
name_rec_2 = testlib.get_name_blockchain_record('foo.test')
if name_rec_2['last_renewed'] <= name_rec['last_renewed']:
print 'did not renew'
return False
# must have burned
new_burn_balance = testlib.get_balance(
ysi_client.constants.BLOCKSTACK_BURN_ADDRESS)
if new_burn_balance - name_cost != burn_balance:
print 'did not burn fee'
print '{} != {} + {}'.format(new_burn_balance, burn_balance, name_cost)
return False
def scenario( wallets, **kw ):
global wallet_keys, wallet_keys_2, error, index_file_data, resource_data, wallet_balance
wallet_keys = testlib.blockstack_client_initialize_wallet( "0123456789abcdef", wallets[5].privkey, wallets[3].privkey, wallets[0].privkey )
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy( test_proxy )
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr, wallet=wallets[3])
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr, wallet=wallets[3] )
testlib.next_block( **kw )
testlib.blockstack_client_set_wallet( "0123456789abcdef", wallets[5].privkey, wallets[3].privkey, wallets[0].privkey )
# migrate profiles
res = testlib.migrate_profile( "foo.test", proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
config_path = os.environ.get("BLOCKSTACK_CLIENT_CONFIG", None)
config_dir = os.path.dirname(config_path)
conf = blockstack_client.get_config(config_path)
assert conf
api_pass = conf['api_password']
# make sure we can do REST calls
res = testlib.blockstack_REST_call('GET', '/v1/blockchains/bitcoin/pending', None, api_pass=api_pass )
if 'error' in res:
res['test'] = 'Failed to get queues'
print json.dumps(res)
return False
# make sure we can do REST calls with different app names and user names
res = testlib.blockstack_REST_call('GET', '/v1/blockchains/bitcoin/pending', None, api_pass=api_pass )
if 'error' in res:
res['test'] = 'Failed to get queues'
print json.dumps(res)
return False
# what's the balance?
res = testlib.blockstack_REST_call('GET', '/v1/wallet/balance', None, api_pass=api_pass )
if res['http_status'] != 200:
res['test'] = 'failed to query wallet'
print json.dumps(res)
return False
wallet_balance = res['response']['balance']['satoshis']
balance_before = testlib.get_balance(wallets[3].addr)
# can we move the funds?
res = testlib.blockstack_REST_call('POST', '/v1/wallet/balance', None, api_pass=api_pass, data={'address': wallets[3].addr} )
if res['http_status'] != 200:
res['test'] = 'failed to transfer funds'
print json.dumps(res)
return False
if not res['response'].has_key('transaction_hash'):
res['test'] = 'missing tx hash'
print json.dumps(res)
return False
# confirm it
for i in xrange(0, 10):
testlib.next_block(**kw)
new_balance = testlib.get_balance(wallets[5].addr)
balance_after = testlib.get_balance(wallets[3].addr)
if new_balance != 0:
print 'new balance of {} is {}'.format(wallets[5].addr, new_balance)
return False
if abs(balance_before + wallet_balance - balance_after) > 10000:
print "{} + {} !~= {}".format(balance_before, wallet_balance, balance_after)
return False
def scenario(wallets, **kw):
global pk
testlib.blockstack_namespace_preorder("test1", wallets[1].addr,
wallets[0].privkey)
testlib.blockstack_namespace_preorder("test2", wallets[1].addr,
wallets[0].privkey)
testlib.blockstack_namespace_preorder("test3", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test1",
wallets[1].addr,
52595,
250,
4, [6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
version_bits=1)
testlib.blockstack_namespace_reveal(
"test2",
wallets[1].addr,
52595,
250,
4, [6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
version_bits=2)
testlib.blockstack_namespace_reveal(
"test3",
wallets[1].addr,
52595,
250,
4, [6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
version_bits=3)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test1", wallets[1].privkey)
testlib.blockstack_namespace_ready("test2", wallets[1].privkey)
testlib.blockstack_namespace_ready("test3", wallets[1].privkey)
testlib.next_block(**kw)
# pay for a name in a v1 namespace with Stacks
addr = virtualchain.address_reencode(virtualchain.get_privkey_address(pk))
# calculate the cost of doing so
namespace = testlib.get_state_engine().get_namespace('test1')
stacks_price = blockstack.lib.scripts.price_name_stacks(
'foo', namespace, testlib.get_current_block(**kw))
btc_price = blockstack.lib.scripts.price_name(
'foo', namespace, testlib.get_current_block(**kw))
print ''
print 'price of {} in Stacks is {}'.format('foo.test', stacks_price)
print ''
testlib.blockstack_send_tokens(addr, "STACKS", 3 * stacks_price,
wallets[0].privkey)
testlib.send_funds(
wallets[0].privkey, btc_price - 5500 - 1,
addr) # deliberately insufficient funds for ordering the name in BTC
testlib.next_block(**kw)
wallet_before_burn = testlib.get_balance(wallets[0].addr)
# preorder/register in all three namespaces
testlib.blockstack_name_preorder("foo.test1",
pk,
wallets[3].addr,
price={
'units': 'STACKS',
'amount': stacks_price
})
testlib.blockstack_name_preorder("bar.test1", wallets[1].privkey,
wallets[3].addr)
testlib.blockstack_name_preorder("foo.test2", wallets[1].privkey,
wallets[3].addr)
testlib.blockstack_name_preorder("foo.test3", wallets[1].privkey,
wallets[3].addr)
testlib.next_block(**kw)
wallet_after_burn = testlib.get_balance(wallets[0].addr)
if wallet_after_burn - wallet_before_burn != btc_price:
print 'foo.test2 did not pay {} to {} (but paid {})'.format(
btc_price, wallets[0].addr, wallet_after_burn - wallet_before_burn)
return False
testlib.send_funds(
wallets[0].privkey, btc_price - 5500 - 1,
addr) # deliberately insufficient funds for ordering the name in BTC
testlib.blockstack_name_register("foo.test1", pk,
wallets[3].addr) # paid in Stacks
testlib.blockstack_name_register("bar.test1", wallets[1].privkey,
wallets[3].addr) # paid in BTC
testlib.blockstack_name_register(
"foo.test2", wallets[1].privkey,
wallets[3].addr) # paid in BTC to wallets[0]
testlib.blockstack_name_register("foo.test3", wallets[1].privkey,
wallets[3].addr) # paid in Stacks
testlib.next_block(**kw)
testlib.send_funds(
wallets[0].privkey, btc_price - 5500 - 1,
addr) # deliberately insufficient funds for ordering the name in BTC
wallet_before_burn = testlib.get_balance(wallets[0].addr)
testlib.blockstack_name_renew("foo.test1",
wallets[3].privkey,
price={
'units': 'STACKS',
'amount': stacks_price
}) # paid in Stacks
testlib.blockstack_name_renew("bar.test1",
wallets[3].privkey) # paid in BTC
testlib.blockstack_name_renew(
"foo.test2", wallets[3].privkey) # paid in BTC to wallets[0]
testlib.blockstack_name_renew("foo.test3",
wallets[3].privkey) # paid in Stacks
testlib.next_block(**kw)
wallet_after_burn = testlib.get_balance(wallets[0].addr)
if wallet_after_burn - wallet_before_burn != btc_price:
print 'foo.test2 did not pay {} to {} (but paid {})'.format(
btc_price, wallets[0].addr, wallet_after_burn - wallet_before_burn)
return False
# should all fail--wrong burn addresses
testlib.blockstack_name_renew("foo.test1",
pk,
price={
'units': 'STACKS',
'amount': stacks_price
},
burn_addr=wallets[0].addr,
safety_checks=False,
expect_fail=True)
testlib.blockstack_name_renew("bar.test1",
wallets[3].privkey,
burn_addr=wallets[0].addr,
safety_checks=False,
expect_fail=True)
testlib.blockstack_name_renew("foo.test2",
wallets[3].privkey,
burn_addr=wallets[1].addr,
safety_checks=False,
expect_fail=True)
testlib.blockstack_name_renew("foo.test3",
wallets[3].privkey,
burn_addr=wallets[0].addr,
safety_checks=False,
expect_fail=True)
testlib.next_block(**kw)
testlib.expect_snv_fail_at('foo.test1', testlib.get_current_block(**kw))
testlib.expect_snv_fail_at('bar.test1', testlib.get_current_block(**kw))
testlib.expect_snv_fail_at('foo.test2', testlib.get_current_block(**kw))
testlib.expect_snv_fail_at('foo.test3', testlib.get_current_block(**kw))
def scenario(wallets, **kw):
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test",
wallets[1].addr,
3,
250,
4, [6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
version_bits=2)
testlib.next_block(**kw)
resp = testlib.blockstack_name_import("foo.test", wallets[3].addr,
"11" * 20, wallets[1].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
return False
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
namespace_rec = testlib.blockstack_cli_get_namespace_blockchain_record(
"test")
if 'error' in namespace_rec:
print namespace_rec
return False
namespace_balance = testlib.get_balance(namespace_rec['address'])
burn_balance = testlib.get_balance(
blockstack.lib.config.BLOCKSTACK_BURN_ADDRESS)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw) # expired
res = testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr) # +name_cost
if 'error' in res:
print res
return False
testlib.next_block(**kw)
res = testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw) # expired
res = testlib.blockstack_name_preorder("foo.test", wallets[3].privkey,
wallets[4].addr) # +name_cost
if 'error' in res:
print res
return False
testlib.next_block(**kw)
res = testlib.blockstack_name_register("foo.test", wallets[3].privkey,
wallets[4].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
testlib.next_block(**kw)
res = testlib.blockstack_name_renew("foo.test",
wallets[4].privkey) # +name_cost
if 'error' in res:
print res
return False
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw) # expired
res = testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr) # +name_cost
if 'error' in res:
print res
return False
testlib.next_block(**kw)
res = testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
new_namespace_balance = testlib.get_balance(namespace_rec['address'])
name_rec = testlib.get_name_blockchain_record('foo.test')
name_cost = name_rec['op_fee']
testlib.next_block(**kw)
testlib.next_block(**kw) # stop fee collection
testlib.next_block(**kw)
testlib.next_block(**kw) # expired
if new_namespace_balance - namespace_balance != 4 * name_cost:
print 'address {} did not get credited'.format(
namespace_rec['address'])
print '{} != {} + 4*{}'.format(new_namespace_balance,
namespace_balance, name_cost)
return False
# preorder should send to the null burn address now.
res = testlib.blockstack_name_preorder(
"foo2.test", wallets[4].privkey,
wallets[0].addr) # does not pay to namespace
if 'error' in res:
print res
return False
# try forcing it to the namespace burn address, to verify that it fails
res = testlib.blockstack_name_preorder(
"foo_fail.test",
wallets[4].privkey,
wallets[0].addr,
burn_addr=namespace_rec['address'],
expect_fail=True) # does not pay to namespace (command fails)
if 'error' not in res:
print res
return False
res = testlib.blockstack_name_preorder("foo_fail.test",
wallets[4].privkey,
wallets[0].addr,
burn_addr=namespace_rec['address'],
price={
'units': 'BTC',
'amount': name_cost
},
safety_checks=False,
tx_fee=10000 * 5) # +name_cost
if 'error' in res:
print res
return False
testlib.next_block(**kw)
testlib.expect_snv_fail_at('foo_fail.test',
testlib.get_current_block(**kw))
# should be accepted
res = testlib.blockstack_name_register("foo2.test", wallets[4].privkey,
wallets[0].addr)
if 'error' in res:
print res
return False
# should be rejected
res = testlib.blockstack_name_register("foo_fail.test",
wallets[4].privkey,
wallets[0].addr,
safety_checks=False)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
testlib.expect_snv_fail_at('foo_fail.test',
testlib.get_current_block(**kw))
# should have been rejected due to wrong burn address
whois = testlib.blockstack_cli_whois('foo_fail.test')
if 'error' not in whois:
print whois
return False
new_burn_balance = testlib.get_balance(
blockstack.lib.config.BLOCKSTACK_BURN_ADDRESS)
new_namespace_balance = testlib.get_balance(namespace_rec['address'])
name_rec_2 = testlib.get_name_blockchain_record('foo2.test')
name_cost_2 = name_rec_2['op_fee']
# namespace should NOT have gotten the fee for foo_fail. It should only have gotten it for foo.test
if new_namespace_balance - namespace_balance < 5 * name_cost or new_namespace_balance - namespace_balance > 6 * name_cost:
print 'address {} got credited after fee capture period'.format(
namespace_rec['address'])
print '{} != {} + 5*{}'.format(new_namespace_balance,
namespace_balance, name_cost)
return False
# burn address should have received the fee for the second name
if new_burn_balance - name_cost_2 != burn_balance:
print 'null burn address did not get credited'
print '{} != {} + {}'.format(new_burn_balance, burn_balance,
name_cost_2)
return False
def scenario(wallets, **kw):
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 wallet_keys, wallet_keys_2, error, index_file_data, resource_data, wallet_balance
wallet_keys = testlib.blockstack_client_initialize_wallet( "0123456789abcdef", wallets[5].privkey, wallets[3].privkey, wallets[4].privkey )
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy( test_proxy )
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
# migrate profiles
res = testlib.migrate_profile( "foo.test", proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
config_path = os.environ.get("BLOCKSTACK_CLIENT_CONFIG", None)
config_dir = os.path.dirname(config_path)
conf = blockstack_client.get_config(config_path)
assert conf
api_pass = conf['api_password']
# make sure we can do REST calls
res = testlib.blockstack_REST_call('GET', '/v1/blockchains/bitcoin/pending', None, api_pass=api_pass )
if 'error' in res:
res['test'] = 'Failed to get queues'
print json.dumps(res)
return False
# make sure we can do REST calls with different app names and user names
res = testlib.blockstack_REST_call('GET', '/v1/blockchains/bitcoin/pending', None, api_pass=api_pass )
if 'error' in res:
res['test'] = 'Failed to get queues'
print json.dumps(res)
return False
# what's the balance?
res = testlib.blockstack_REST_call('GET', '/v1/wallet/balance', None, api_pass=api_pass )
if res['http_status'] != 200:
res['test'] = 'failed to query wallet'
print json.dumps(res)
return False
wallet_balance = res['response']['balance']['satoshis']
balance_before = testlib.get_balance(wallets[8].addr)
# can we move the funds?
res = testlib.blockstack_REST_call('POST', '/v1/wallet/balance', None, api_pass=api_pass, data={'address': wallets[8].addr, 'amount': wallet_balance / 2, 'message': "hello world!"})
if res['http_status'] != 200:
res['test'] = 'failed to transfer funds'
print json.dumps(res)
return False
if not res['response'].has_key('transaction_hash'):
res['test'] = 'missing tx hash'
print json.dumps(res)
return False
print "\n\nTransaction: {}\n\n".format(res['response']['transaction_hash'])
# confirm it
for i in xrange(0, 12):
testlib.next_block(**kw)
new_balance = testlib.get_balance(wallets[5].addr)
balance_after = testlib.get_balance(wallets[8].addr)
print "wallet balance: {}".format(wallet_balance)
print "new balance {}: {}".format(wallets[5].addr, new_balance)
print "balance after {}: {}".format(wallets[8].addr, balance_after)
print "balance before {}: {}".format(wallets[8].addr, balance_before)
if new_balance > wallet_balance / 2:
print 'new balance of {} is {}'.format(wallets[5].addr, new_balance)
return False
if abs(balance_after - balance_before) > abs(wallet_balance / 2) + 54500:
print "{} - {} != {}".format(balance_after, balance_before, wallet_balance / 2)
return False
def do_GET(self):
if self.path == '/blockHeight':
ret = self.server.get_cached_chain_tip()
return self.reply_json(ret, 30)
if self.path == "/operations":
ret = self.server.get_cached_last_block()
return self.reply_json(ret, 30)
if self.path == "/atlas-neighbors":
ret = self.server.get_cached_atlas_neighbors()
return self.reply_json(ret, 30)
if self.path == '/config':
ret = {
'gaiaReadURL': GAIA_READ_URL,
'gaiaWriteURL': GAIA_WRITE_URL,
'subdomainRegistrarURL': SUBDOMAIN_REGISTRAR_URL,
'transactionBroadcasterURL': TRANSACTION_BROADCASTER_URL,
'bitcoinJSONRPCURL': BITCOIN_JSONRPC_URL,
'bitcoinP2PURL': BITCOIN_P2P_URL,
}
return self.reply_json(ret, 3600)
# /balance/{}
if self.path.startswith('/balance'):
try:
addr = self.path.strip('/').split('/')[-1]
addr = virtualchain.address_reencode(addr, network='testnet')
except:
traceback.print_exc()
return self.error_page(400, 'Invalid address or path')
try:
btc_balance = testlib.get_balance(addr)
stacks_balance = blockstack.lib.client.get_account_balance(addr, 'STACKS', hostport='http://localhost:16264')
assert isinstance(stacks_balance, (int,long))
except:
traceback.print_exc()
return self.error_page(500, 'Failed to query balance')
ret = {
'btc': '{}'.format(btc_balance),
'stacks': '{}'.format(stacks_balance),
}
return self.reply_json(ret)
# /names/page
if self.path.startswith('/names/'):
try:
page = int(self.path.strip('/').split('/')[-1])
except:
traceback.print_exc()
return self.error_page(400, 'Invalid page')
names = blockstack.lib.client.get_all_names(offset=page * 100, count=100, hostport='http://localhost:16264')
return self.reply_json(names, 30)
# /namespaces/page
if self.path.startswith('/namespaces/'):
try:
page = int(self.path.strip('/').split('/')[-1])
except:
traceback.print_exc()
return self.error_page(400, 'Invalid page')
names = blockstack.lib.client.get_all_namespaces(offset=page * 100, count=100, hostport='http://localhost:16264')
return self.reply_json(names, 30)
return self.error_page(404, 'The server that serves the testnet panel must be down')
