def send_create_account_tx(self, new_account_id, base_block_hash=None):
self.prep_tx()
new_key = Key(new_account_id, self.key.pk, self.key.sk)
tx = sign_create_account_with_full_access_key_and_balance_tx(
self.key, new_account_id, new_key, 100 * NEAR_BASE, self.nonce,
base_block_hash or self.base_block_hash)
return self.send_tx(tx)
def create_account(source_account, base_block_hash):
nonce = get_nonce_for_pk(source_account.account_id, source_account.pk)
new_account_id = ''.join(
random.choice(string.ascii_lowercase) for _ in range(0, 10))
new_key = Key(new_account_id, source_account.pk, source_account.sk)
tx = sign_create_account_with_full_access_key_and_balance_tx(
source_account, new_account_id, new_key, 100, nonce + 1,
base_block_hash)
send_tx(tx)
def create_account(self, user, node):
status = node.get_status(check_storage=False)
h = base58.b58decode(
status['sync_info']['latest_block_hash'].encode('utf8'))
nonce = node.get_nonce_for_pk(node.signer_key.account_id,
node.signer_key.pk)
create_account_tx = sign_create_account_with_full_access_key_and_balance_tx(
node.signer_key, user.near_account_name, user.near_signer_key,
billion_tokens // 10, nonce + 1, h)
res = node.send_tx(create_account_tx)['result']
while True:
try:
created = node.get_tx(res, user.near_account_name)
if 'status' in created['result']:
# tx is accepted by network
break
except:
time.sleep(1)
# check the result of tx execution
assert_success(created['result']['status']['SuccessValue'])
time.sleep(2)
nodes[1].kill()
print('node1 is killed')
status = nodes[0].get_status()
block_hash = status['sync_info']['latest_block_hash']
cur_height = status['sync_info']['latest_block_height']
num_new_accounts = 10
balance = 50000000000000000000000000000000
account_keys = []
for i in range(num_new_accounts):
signer_key = Key(f'test_account{i}', nodes[0].signer_key.pk,
nodes[0].signer_key.sk)
create_account_tx = sign_create_account_with_full_access_key_and_balance_tx(
nodes[0].signer_key, f'test_account{i}', signer_key,
balance // num_new_accounts, i + 1,
base58.b58decode(block_hash.encode('utf8')))
account_keys.append(signer_key)
res = nodes[0].send_tx_and_wait(create_account_tx, timeout=15)
assert 'error' not in res, res
target_height = 50
while cur_height < target_height:
status = nodes[0].get_status()
cur_height = status['sync_info']['latest_block_height']
time.sleep(1)
status = nodes[0].get_status()
block_hash = status['sync_info']['latest_block_hash']
for signer_key in account_keys:
def main():
node_root = utils.get_near_tempdir('backward', clean=True)
executables = branches.prepare_ab_test()
# Setup local network.
subprocess.check_call([
executables.stable.neard,
"--home=%s" % node_root,
# TODO(#4372): testnet subcommand deprecated since 1.24. Replace with
# localnet after a couple of releases in 2022.
"testnet",
"--v",
"2",
"--prefix",
"test"
])
# Run both binaries at the same time.
config = executables.stable.node_config()
stable_node = cluster.spin_up_node(config, executables.stable.root,
str(node_root / 'test0'), 0)
config = executables.current.node_config()
current_node = cluster.spin_up_node(config,
executables.current.root,
str(node_root / 'test1'),
1,
boot_node=stable_node)
# Check it all works.
BLOCKS = 100
max_height = -1
started = time.time()
# Create account, transfer tokens, deploy contract, invoke function call
block_hash = stable_node.get_latest_block().hash_bytes
new_account_id = 'test_account.test0'
new_signer_key = cluster.Key(new_account_id, stable_node.signer_key.pk,
stable_node.signer_key.sk)
create_account_tx = sign_create_account_with_full_access_key_and_balance_tx(
stable_node.signer_key, new_account_id, new_signer_key, 10**24, 1,
block_hash)
res = stable_node.send_tx_and_wait(create_account_tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
transfer_tx = sign_payment_tx(stable_node.signer_key, new_account_id,
10**25, 2, block_hash)
res = stable_node.send_tx_and_wait(transfer_tx, timeout=20)
assert 'error' not in res, res
block_height = stable_node.get_latest_block().height
nonce = block_height * 1_000_000 - 1
tx = sign_deploy_contract_tx(new_signer_key, utils.load_test_contract(),
nonce, block_hash)
res = stable_node.send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
tx = sign_deploy_contract_tx(stable_node.signer_key,
utils.load_test_contract(), 3, block_hash)
res = stable_node.send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
tx = sign_function_call_tx(new_signer_key, new_account_id,
'write_random_value', [], 10**13, 0, nonce + 1,
block_hash)
res = stable_node.send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
data = json.dumps([{
"create": {
"account_id": "test_account.test0",
"method_name": "call_promise",
"arguments": [],
"amount": "0",
"gas": 30000000000000,
},
"id": 0
}, {
"then": {
"promise_index": 0,
"account_id": "test0",
"method_name": "call_promise",
"arguments": [],
"amount": "0",
"gas": 30000000000000,
},
"id": 1
}])
tx = sign_function_call_tx(stable_node.signer_key,
new_account_id, 'call_promise',
bytes(data, 'utf-8'), 90000000000000, 0,
nonce + 2, block_hash)
res = stable_node.send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
utils.wait_for_blocks(current_node, target=BLOCKS)
def test_changes_with_new_account_with_access_key():
"""
Plan:
1. Create a new account with an access key.
2. Observe the changes in the block where the receipt lands.
3. Remove the access key.
4. Observe the changes in the block where the receipt lands.
"""
# re-use the key as a new account access key
new_key = Key(
account_id='rpc_key_value_changes_full_access',
pk=nodes[1].signer_key.pk,
sk=nodes[1].signer_key.sk,
)
# Step 1
status = nodes[0].get_status()
latest_block_hash = status['sync_info']['latest_block_hash']
create_account_tx = transaction.sign_create_account_with_full_access_key_and_balance_tx(
creator_key=nodes[0].signer_key,
new_account_id=new_key.account_id,
new_key=new_key,
balance=10**24,
nonce=7,
block_hash=base58.b58decode(latest_block_hash.encode('utf8')))
new_account_response = nodes[0].send_tx_and_wait(create_account_tx, 10)
# Step 2
block_hash = new_account_response['result']['receipts_outcome'][0][
'block_hash']
assert_changes_in_block_response(request={"block_id": block_hash},
expected_response={
"block_hash":
block_hash,
"changes": [{
"type":
"account_touched",
"account_id":
new_key.account_id,
}, {
"type":
"access_key_touched",
"account_id":
new_key.account_id,
}]
})
base_request = {
"block_id": block_hash,
"changes_type": "all_access_key_changes",
}
for request in [
# Test empty account_ids
{
**base_request, "account_ids": []
},
# Test an account_id that is a prefix of the original account_id.
{
**base_request, "account_ids": [new_key.account_id[:-1]]
},
# Test an account_id that has the original account_id as a prefix.
{
**base_request, "account_ids": [new_key.account_id + '_extra']
},
]:
assert_changes_response(request=request,
expected_response={
"block_hash": block_hash,
"changes": []
})
# Test happy-path
expected_response = {
"block_hash":
block_hash,
"changes": [{
"cause": {
"type":
"receipt_processing",
"receipt_hash":
new_account_response["result"]["receipts_outcome"][0]["id"],
},
"type": "access_key_update",
"change": {
"account_id": new_key.account_id,
"public_key": new_key.pk,
"access_key": {
"nonce": 0,
"permission": "FullAccess"
},
}
}]
}
for request in [
{
"block_id": block_hash,
"changes_type": "all_access_key_changes",
"account_ids": [new_key.account_id],
},
{
"block_id":
block_hash,
"changes_type":
"all_access_key_changes",
"account_ids": [
new_key.account_id + '_non_existing1', new_key.account_id,
new_key.account_id + '_non_existing2'
],
},
]:
assert_changes_response(request=request,
expected_response=expected_response)
# Step 3
status = nodes[0].get_status()
latest_block_hash = status['sync_info']['latest_block_hash']
delete_access_key_tx = transaction.sign_delete_access_key_tx(
signer_key=new_key,
target_account_id=new_key.account_id,
key_for_deletion=new_key,
nonce=8,
block_hash=base58.b58decode(latest_block_hash.encode('utf8')))
delete_access_key_response = nodes[1].send_tx_and_wait(
delete_access_key_tx, 10)
# Step 4
block_hash = delete_access_key_response['result']['receipts_outcome'][0][
'block_hash']
assert_changes_in_block_response(request={"block_id": block_hash},
expected_response={
"block_hash":
block_hash,
"changes": [{
"type":
"account_touched",
"account_id":
new_key.account_id,
}, {
"type":
"access_key_touched",
"account_id":
new_key.account_id,
}]
})
base_request = {
"block_id": block_hash,
"changes_type": "all_access_key_changes",
}
for request in [
# Test empty account_ids
{
**base_request, "account_ids": []
},
# Test an account_id that is a prefix of the original account_id
{
**base_request, "account_ids": [new_key.account_id[:-1]]
},
# Test an account_id that has the original account_id as a prefix
{
**base_request, "account_ids": [new_key.account_id + '_extra']
},
# Test empty keys in single_access_key_changes request
{
"block_id": block_hash,
"changes_type": "single_access_key_changes",
"keys": []
},
# Test non-existing account_id
{
"block_id":
block_hash,
"changes_type":
"single_access_key_changes",
"keys": [
{
"account_id": new_key.account_id + '_non_existing1',
"public_key": new_key.pk
},
],
},
# Test non-existing public_key for an existing account_id
{
"block_id":
block_hash,
"changes_type":
"single_access_key_changes",
"keys": [
{
"account_id": new_key.account_id,
"public_key": new_key.pk[:-3] + 'aaa'
},
],
},
]:
assert_changes_response(request=request,
expected_response={
"block_hash": block_hash,
"changes": []
})
# Test happy-path
expected_response = {
"block_hash":
block_hash,
"changes": [{
"cause": {
'type':
'transaction_processing',
'tx_hash':
delete_access_key_response['result']['transaction']['hash'],
},
"type": "access_key_update",
"change": {
"account_id": new_key.account_id,
"public_key": new_key.pk,
"access_key": {
"nonce": 8,
"permission": "FullAccess"
},
}
}, {
"cause": {
"type":
"receipt_processing",
"receipt_hash":
delete_access_key_response["result"]["receipts_outcome"][0]
["id"]
},
"type": "access_key_deletion",
"change": {
"account_id": new_key.account_id,
"public_key": new_key.pk,
}
}]
}
for request in [
{
"block_id": block_hash,
"changes_type": "all_access_key_changes",
"account_ids": [new_key.account_id],
},
{
"block_id":
block_hash,
"changes_type":
"all_access_key_changes",
"account_ids": [
new_key.account_id + '_non_existing1', new_key.account_id,
new_key.account_id + '_non_existing2'
],
},
{
"block_id": block_hash,
"changes_type": "single_access_key_changes",
"keys": [{
"account_id": new_key.account_id,
"public_key": new_key.pk
}],
},
{
"block_id":
block_hash,
"changes_type":
"single_access_key_changes",
"keys": [
{
"account_id": new_key.account_id + '_non_existing1',
"public_key": new_key.pk
},
{
"account_id": new_key.account_id,
"public_key": new_key.pk
},
],
},
]:
assert_changes_response(request=request,
expected_response=expected_response)
def main():
node_root = "/tmp/near/upgradable"
if os.path.exists(node_root):
shutil.rmtree(node_root)
subprocess.check_output('mkdir -p /tmp/near', shell=True)
branch = branches.latest_rc_branch()
print(f"Latest rc release branch is {branch}")
near_root, (stable_branch,
current_branch) = branches.prepare_ab_test(branch)
# Setup local network.
print([
"%snear-%s" % (near_root, stable_branch),
"--home=%s" % node_root, "testnet", "--v", "4", "--prefix", "test"
])
subprocess.call([
"%snear-%s" % (near_root, stable_branch),
"--home=%s" % node_root, "testnet", "--v", "4", "--prefix", "test"
])
genesis_config_changes = [("epoch_length", 20),
("num_block_producer_seats", 10),
("num_block_producer_seats_per_shard", [10]),
("block_producer_kickout_threshold", 80),
("chunk_producer_kickout_threshold", 80),
("chain_id", "testnet")]
node_dirs = [os.path.join(node_root, 'test%d' % i) for i in range(4)]
for i, node_dir in enumerate(node_dirs):
cluster.apply_genesis_changes(node_dir, genesis_config_changes)
# Start 3 stable nodes and one current node.
config = {
"local": True,
'near_root': near_root,
'binary_name': "near-%s" % stable_branch
}
nodes = [
cluster.spin_up_node(config, near_root, node_dirs[0], 0, None, None)
]
for i in range(1, 3):
nodes.append(
cluster.spin_up_node(config, near_root, node_dirs[i], i,
nodes[0].node_key.pk, nodes[0].addr()))
if os.getenv('NAYDUCK'):
config["binary_name"] = "near"
else:
config["binary_name"] = "near-%s" % current_branch
nodes.append(
cluster.spin_up_node(config, near_root, node_dirs[3], 3,
nodes[0].node_key.pk, nodes[0].addr()))
time.sleep(2)
# deploy a contract
status = nodes[0].get_status()
hash = status['sync_info']['latest_block_hash']
tx = sign_deploy_contract_tx(
nodes[0].signer_key,
load_binary_file(
'../runtime/near-test-contracts/res/test_contract_rs.wasm'), 1,
base58.b58decode(hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
# write some random value
tx = sign_function_call_tx(nodes[0].signer_key,
nodes[0].signer_key.account_id,
'write_random_value', [], 10**13, 0, 2,
base58.b58decode(hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
wait_for_blocks_or_timeout(nodes[0], 20, 120)
# Restart stable nodes into new version.
for i in range(3):
nodes[i].kill()
nodes[i].binary_name = config['binary_name']
nodes[i].start(nodes[0].node_key.pk, nodes[0].addr())
wait_for_blocks_or_timeout(nodes[3], 60, 120)
status0 = nodes[0].get_status()
status3 = nodes[3].get_status()
protocol_version = status0['protocol_version']
latest_protocol_version = status3["latest_protocol_version"]
assert protocol_version == latest_protocol_version, \
"Latest protocol version %d should match active protocol version %d" % (
latest_protocol_version, protocol_version)
hash = status0['sync_info']['latest_block_hash']
# write some random value again
tx = sign_function_call_tx(nodes[0].signer_key,
nodes[0].signer_key.account_id,
'write_random_value', [], 10**13, 0, 4,
base58.b58decode(hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
# hex_account_id = (b"I'm hex!" * 4).hex()
hex_account_id = '49276d206865782149276d206865782149276d206865782149276d2068657821'
tx = sign_payment_tx(key=nodes[0].signer_key,
to=hex_account_id,
amount=10**25,
nonce=5,
blockHash=base58.b58decode(hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(tx, timeout=20)
# Successfully created a new account on transfer to hex
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
hex_account_balance = int(
nodes[0].get_account(hex_account_id)['result']['amount'])
assert hex_account_balance == 10**25
hash = status0['sync_info']['latest_block_hash']
new_account_id = f'new.{nodes[0].signer_key.account_id}'
new_signer_key = cluster.Key(new_account_id, nodes[0].signer_key.pk,
nodes[0].signer_key.sk)
create_account_tx = sign_create_account_with_full_access_key_and_balance_tx(
nodes[0].signer_key, new_account_id, new_signer_key, 10**24, 6,
base58.b58decode(hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(create_account_tx, timeout=20)
# Successfully created a new account
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
hash = status0['sync_info']['latest_block_hash']
status = nodes[0].get_status()
block_height = status['sync_info']['latest_block_height']
beneficiary_account_id = '1982374698376abd09265034ef35034756298375462323456294875193563756'
tx = sign_delete_account_tx(key=new_signer_key,
to=new_account_id,
beneficiary=beneficiary_account_id,
nonce=block_height * 1_000_000 - 1,
block_hash=base58.b58decode(
hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(tx, timeout=20)
# Successfully deleted an account
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
def main():
node_root = "/tmp/near/backward"
if os.path.exists(node_root):
shutil.rmtree(node_root)
subprocess.check_output('mkdir -p /tmp/near', shell=True)
branch = branches.latest_rc_branch()
near_root, (stable_branch,
current_branch) = branches.prepare_ab_test(branch)
# Setup local network.
subprocess.call([
"%snear-%s" % (near_root, stable_branch),
"--home=%s" % node_root, "testnet", "--v", "2", "--prefix", "test"
])
# Run both binaries at the same time.
config = {
"local": True,
'near_root': near_root,
'binary_name': "near-%s" % stable_branch
}
stable_node = cluster.spin_up_node(config, near_root,
os.path.join(node_root, "test0"), 0,
None, None)
config["binary_name"] = "near-%s" % current_branch
current_node = cluster.spin_up_node(config, near_root,
os.path.join(node_root, "test1"), 1,
stable_node.node_key.pk,
stable_node.addr())
# Check it all works.
BLOCKS = 100
TIMEOUT = 150
max_height = -1
started = time.time()
# Create account, transfer tokens, deploy contract, invoke function call
status = stable_node.get_status()
block_hash = base58.b58decode(
status['sync_info']['latest_block_hash'].encode('utf-8'))
new_account_id = 'test_account'
new_signer_key = cluster.Key(new_account_id, stable_node.signer_key.pk,
stable_node.signer_key.sk)
create_account_tx = sign_create_account_with_full_access_key_and_balance_tx(
stable_node.signer_key, new_account_id, new_signer_key, 10**24, 1,
block_hash)
res = stable_node.send_tx_and_wait(create_account_tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
transfer_tx = sign_payment_tx(stable_node.signer_key, new_account_id,
10**25, 2, block_hash)
res = stable_node.send_tx_and_wait(transfer_tx, timeout=20)
assert 'error' not in res, res
status = stable_node.get_status()
block_height = status['sync_info']['latest_block_height']
nonce = block_height * 1_000_000 - 1
tx = sign_deploy_contract_tx(new_signer_key, load_test_contract(), nonce,
block_hash)
res = stable_node.send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
tx = sign_function_call_tx(new_signer_key, new_account_id,
'write_random_value', [], 10**13, 0, nonce + 1,
block_hash)
res = stable_node.send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
data = json.dumps([{
"create": {
"account_id": "near_2",
"method_name": "call_promise",
"arguments": [],
"amount": "0",
"gas": 30000000000000,
},
"id": 0
}, {
"then": {
"promise_index": 0,
"account_id": "near_3",
"method_name": "call_promise",
"arguments": [],
"amount": "0",
"gas": 30000000000000,
},
"id": 1
}])
tx = sign_function_call_tx(new_signer_key, new_account_id, 'call_promise',
bytes(data, 'utf-8'), 90000000000000, 0,
nonce + 2, block_hash)
res = stable_node.send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
while max_height < BLOCKS:
assert time.time() - started < TIMEOUT
status = current_node.get_status()
cur_height = status['sync_info']['latest_block_height']
if cur_height > max_height:
max_height = cur_height
time.sleep(1)
["chunk_producer_kickout_threshold", 10]], {1: node1_config})
time.sleep(2)
nodes[1].kill()
logger.info('node1 is killed')
block_hash = nodes[0].get_latest_block().hash_bytes
num_new_accounts = 10
balance = 50000000000000000000000000000000
account_keys = []
for i in range(num_new_accounts):
account_name = f'test_account{i}.test0'
signer_key = Key(account_name, nodes[0].signer_key.pk,
nodes[0].signer_key.sk)
create_account_tx = sign_create_account_with_full_access_key_and_balance_tx(
nodes[0].signer_key, account_name, signer_key,
balance // num_new_accounts, i + 1, block_hash)
account_keys.append(signer_key)
res = nodes[0].send_tx_and_wait(create_account_tx, timeout=15)
assert 'error' not in res, res
latest_block = utils.wait_for_blocks(nodes[0], target=50)
cur_height = latest_block.height
block_hash = latest_block.hash_bytes
for signer_key in account_keys:
staking_tx = sign_staking_tx(signer_key, nodes[0].validator_key,
balance // (num_new_accounts * 2),
cur_height * 1_000_000 - 1, block_hash)
res = nodes[0].send_tx_and_wait(staking_tx, timeout=15)
assert 'error' not in res
