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) near_root, (stable_branch, current_branch) = branches.prepare_ab_test("beta") # 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)] 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())) 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())) 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)
def main(): near_root, (stable_branch, current_branch) = branches.prepare_ab_test("1.13.0") node_root = os.path.join(os.path.expanduser("~"), "./near") logging.info(f"The near root is {near_root}...") logging.info(f"The node root is {node_root}...") init_command = [ "%snear-%s" % (near_root, stable_branch), "--home=%s" % node_root, "init", "--fast", ] # Init local node subprocess.call(init_command) # Run stable node for few blocks. config = { "local": True, 'near_root': near_root, 'binary_name': "near-%s" % stable_branch } logging.info("Starting the stable node...") stable_node = cluster.spin_up_node(config, near_root, node_root, 0, None, None) logging.info("Running the stable node...") wait_for_blocks_or_timeout(stable_node, 20, 100) logging.info("Blocks are being produced, sending some tx...") deploy_contract(stable_node) send_some_tx(stable_node) subprocess.call(["cp", "-r", node_root, "/tmp/near"]) stable_node.cleanup() logging.info( "Stable node has produced blocks... Stopping the stable node... ") # Run new node and verify it runs for a few more blocks. config["binary_name"] = "near-%s" % current_branch subprocess.call(["cp", "-r", "/tmp/near", node_root]) logging.info("Starting the current node...") current_node = cluster.spin_up_node(config, near_root, node_root, 0, None, None) logging.info("Running the current node...") wait_for_blocks_or_timeout(current_node, 20, 100) logging.info("Blocks are being produced, sending some tx...") send_some_tx(stable_node) logging.info( "Currnet node has produced blocks... Stopping the current node... ") current_node.cleanup()
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) near_root, (stable_branch, current_branch) = branches.prepare_ab_test("beta") # Setup local network. subprocess.call([ "%snear-%s" % (near_root, stable_branch), "--home=%s" % node_root, "testnet", "--v", "2", "--prefix", "test" ]) with open('/tmp/near/backward/test0/genesis.json') as f: stable_genesis = json.load(f) stable_protocol_version = stable_genesis['protocol_version'] with open( os.path.join(os.path.dirname(__file__), '../../../neard/res/genesis_config.json')) as f: current_genesis = json.load(f) current_protocol_version = current_genesis['protocol_version'] if current_protocol_version > stable_protocol_version: print('Protcol upgrade, does not need backward compatible') exit(0) # 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. # TODO: we should run for at least 2 epochs. # TODO: send some transactions to test that runtime works the same. BLOCKS = 20 TIMEOUT = 150 max_height = 0 started = time.time() while max_height < BLOCKS: assert time.time() - started < TIMEOUT status = current_node.get_status() max_height = status['sync_info']['latest_block_height']
def main(): executables = branches.prepare_ab_test() node_root = utils.get_near_tempdir('db_migration', clean=True) logging.info(f"The near root is {executables.stable.root}...") logging.info(f"The node root is {node_root}...") # Init local node subprocess.call(( executables.stable.neard, "--home=%s" % node_root, "init", "--fast", )) # Run stable node for few blocks. logging.info("Starting the stable node...") config = executables.stable.node_config() node = cluster.spin_up_node(config, executables.stable.root, str(node_root), 0) logging.info("Running the stable node...") utils.wait_for_blocks(node, count=20) logging.info("Blocks are being produced, sending some tx...") deploy_contract(node) send_some_tx(node) node.kill() logging.info( "Stable node has produced blocks... Stopping the stable node... ") # Run new node and verify it runs for a few more blocks. logging.info("Starting the current node...") config = executables.current.node_config() node.binary_name = config['binary_name'] node.start(boot_node=node) logging.info("Running the current node...") utils.wait_for_blocks(node, count=20) logging.info("Blocks are being produced, sending some tx...") send_some_tx(node) logging.info( "Currnet node has produced blocks... Stopping the current node... ") node.kill() logging.info("Restarting the current node...") node.start(boot_node=node) utils.wait_for_blocks(node, count=20)
def main(): node_root = '/tmp/near/state_migration' if os.path.exists(node_root): shutil.rmtree(node_root) subprocess.check_output('mkdir -p /tmp/near', shell=True) near_root, (stable_branch, current_branch) = branches.prepare_ab_test("beta") # Run stable node for few blocks. subprocess.call(["%snear-%s" % (near_root, stable_branch), "--home=%s/test0" % node_root, "init", "--fast"]) stable_protocol_version = json.load(open('%s/test0/genesis.json' % node_root))['protocol_version'] 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) wait_for_blocks_or_timeout(stable_node, 20, 100) # TODO: we should make state more interesting to migrate by sending some tx / contracts. stable_node.cleanup() os.mkdir('%s/test0' % node_root) # Dump state. subprocess.call(["%sstate-viewer-%s" % (near_root, stable_branch), "--home", '%s/test0_finished' % node_root, "dump_state"]) # Migrate. migrations_home = '../scripts/migrations' all_migrations = sorted(os.listdir(migrations_home), key=lambda x: int(x.split('-')[0])) for fname in all_migrations: m = re.match('([0-9]+)\-.*', fname) if m: version = int(m.groups()[0]) if version > stable_protocol_version: exitcode = subprocess.call(['python', os.path.join(migrations_home, fname), '%s/test0_finished' % node_root, '%s/test0_finished' % node_root]) assert exitcode == 0, "Failed to run migration %d" % version os.rename(os.path.join(node_root, 'test0_finished/output.json'), os.path.join(node_root, 'test0/genesis.json')) shutil.copy(os.path.join(node_root, 'test0_finished/config.json'), os.path.join(node_root, 'test0/')) shutil.copy(os.path.join(node_root, 'test0_finished/validator_key.json'), os.path.join(node_root, 'test0/')) shutil.copy(os.path.join(node_root, 'test0_finished/node_key.json'), os.path.join(node_root, 'test0/')) # Run new node and verify it runs for a few more blocks. config["binary_name"] = "near-%s" % current_branch current_node = cluster.spin_up_node(config, near_root, os.path.join(node_root, "test0"), 0, None, None) wait_for_blocks_or_timeout(current_node, 20, 100) # New genesis can be deserialized by new near is verified above (new near can produce blocks) # Also test new genesis protocol_version matches neard/res/genesis_config's new_genesis = json.load(open(os.path.join(node_root, 'test0/genesis.json'))) res_genesis = json.load(open('../neard/res/genesis_config.json')) assert new_genesis['protocol_version'] == res_genesis['protocol_version']
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() print(f"Latest rc release branch is {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. # TODO: we should run for at least 2 epochs. # TODO: send some transactions to test that runtime works the same. BLOCKS = 20 TIMEOUT = 150 max_height = -1 started = time.time() 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 print("Height:", max_height)
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)
stable_node = cluster.spin_up_node(config, near_root, os.path.join(node_root, "test0"), 0, None, None) config["binary_name"] = "near-%s" % new_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. # TODO: we should run for at least 2 epochs. # TODO: send some transactions to test that runtime works the same. BLOCKS = 20 TIMEOUT = 150 max_height = -1 started = time.time() 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 print("Height:", max_height) if __name__ == "__main__": near_root, (stable_branch, new_branch) = branches.prepare_ab_test("beta") main(near_root, stable_branch, new_branch)
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) # TODO(#3285): use proper branch near_root, (stable_branch, current_branch) = branches.prepare_ab_test("1.13.0") # 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())) 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-vm-runner/tests/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 # 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=3, blockHash=base58.b58decode(hash.encode('utf8'))) res = nodes[0].send_tx_and_wait(tx, timeout=20) # Account doesn't exist assert 'error' not in res, res assert 'Failure' in res['result']['status'], res # No account res = nodes[0].get_account(hex_account_id) assert 'error' in res, 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 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
def main(): near_root, (stable_branch, current_branch) = branches.prepare_ab_test("master") node_root = "/tmp/near/db_migration" if os.path.exists(node_root): shutil.rmtree(node_root) subprocess.check_output('mkdir -p /tmp/near', shell=True) logging.info(f"The near root is {near_root}...") logging.info(f"The node root is {node_root}...") init_command = [ "%snear-%s" % (near_root, stable_branch), "--home=%s" % node_root, "init", "--fast", ] # Init local node subprocess.call(init_command) # Run stable node for few blocks. config = { "local": True, 'near_root': near_root, 'binary_name': "near-%s" % stable_branch } logging.info("Starting the stable node...") node = cluster.spin_up_node(config, near_root, node_root, 0, None, None) logging.info("Running the stable node...") wait_for_blocks_or_timeout(node, 20, 100) logging.info("Blocks are being produced, sending some tx...") deploy_contract(node) send_some_tx(node) node.kill() logging.info( "Stable node has produced blocks... Stopping the stable node... ") # Run new node and verify it runs for a few more blocks. config["binary_name"] = "near-%s" % current_branch logging.info("Starting the current node...") node.binary_name = config['binary_name'] node.start(node.node_key.pk, node.addr()) logging.info("Running the current node...") wait_for_blocks_or_timeout(node, 20, 100) logging.info("Blocks are being produced, sending some tx...") send_some_tx(node) logging.info( "Currnet node has produced blocks... Stopping the current node... ") node.kill() logging.info("Restarting the current node...") node.start(node.node_key.pk, node.addr()) wait_for_blocks_or_timeout(node, 20, 100)
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)
def get_executables() -> branches.ABExecutables: global _EXECUTABLES if _EXECUTABLES is None: _EXECUTABLES = branches.prepare_ab_test() logger.info(f"Latest mainnet release is {_EXECUTABLES.release}") return _EXECUTABLES
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() logger.info(f"Latest rc release branch is {branch}") near_root, (stable_branch, current_branch) = branches.prepare_ab_test(branch) # Setup local network. logger.info([ "%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_test_contract(), 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
None, None) config["binary_name"] = "near-%s" % new_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. # TODO: we should run for at least 2 epochs. # TODO: send some transactions to test that runtime works the same. BLOCKS = 20 TIMEOUT = 150 max_height = -1 started = time.time() 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 print("Height:", max_height) if __name__ == "__main__": # TODO(#3285): use proper branch near_root, (stable_branch, new_branch) = branches.prepare_ab_test('1.13.0') main(near_root, stable_branch, new_branch)