def get_test_accounts_from_args(argv):
node_account_id = argv[1]
pk = argv[2]
sk = argv[3]
rpc_nodes = argv[4].split(',')
num_nodes = int(argv[5])
max_tps = float(argv[6])
logger.info(f'rpc_nodes: {rpc_nodes}')
node_account_key = key.Key(node_account_id, pk, sk)
test_account_keys = [
key.Key(mocknet.load_testing_account_id(node_account_id, i), pk, sk)
for i in range(mocknet.NUM_ACCOUNTS)
]
base_block_hash = mocknet_helpers.get_latest_block_hash()
rpc_infos = [(rpc_addr, mocknet_helpers.RPC_PORT) for rpc_addr in rpc_nodes]
node_account = account.Account(node_account_key,
mocknet_helpers.get_nonce_for_pk(
node_account_key.account_id,
node_account_key.pk),
base_block_hash,
rpc_infos=rpc_infos)
accounts = [
account.Account(key,
mocknet_helpers.get_nonce_for_pk(
key.account_id, key.pk),
base_block_hash,
rpc_infos=rpc_infos) for key in test_account_keys
]
max_tps_per_node = max_tps / num_nodes
return node_account, accounts, max_tps_per_node
def send_random_transactions(node_account, test_accounts, max_tps_per_node):
logger.info("===========================================")
logger.info("New iteration of 'send_random_transactions'")
base_block_hash = mocknet_helpers.get_latest_block_hash()
pmap(
lambda index_and_account: random_transaction(index_and_account[1],
index_and_account[0],
node_account,
max_tps_per_node,
base_block_hash=
base_block_hash),
enumerate(test_accounts))
def get_test_accounts_from_args(argv):
assert len(argv) == 7
node_account_id = argv[1]
pk = argv[2]
sk = argv[3]
assert argv[4]
rpc_nodes = argv[4].split(',')
logger.info(f'rpc_nodes: {rpc_nodes}')
max_tps = float(argv[5])
need_deploy = (argv[6] == 'deploy')
logger.info(f'need_deploy: {need_deploy}')
rpc_infos = [(rpc_addr, mocknet_helpers.RPC_PORT) for rpc_addr in rpc_nodes]
node_account_key = key_mod.Key(node_account_id, pk, sk)
test_account_keys = [
key_mod.Key(load_testing_account_id(node_account_id, i), pk, sk)
for i in range(NUM_ACCOUNTS)
]
base_block_hash = mocknet_helpers.get_latest_block_hash()
node_account = account_mod.Account(node_account_key,
mocknet_helpers.get_nonce_for_pk(
node_account_key.account_id,
node_account_key.pk),
base_block_hash,
rpc_infos=rpc_infos)
if need_deploy:
init_ft(node_account)
accounts = []
for key in test_account_keys:
account = account_mod.Account(key,
mocknet_helpers.get_nonce_for_pk(
key.account_id, key.pk),
base_block_hash,
rpc_infos=rpc_infos)
accounts.append(account)
if need_deploy:
logger.info(f'Deploying contract for account {key.account_id}')
tx_res = account.send_deploy_contract_tx('betanet_state.wasm')
logger.info(f'Deploying result: {tx_res}')
init_ft_account(node_account, account)
logger.info(
f'Account {key.account_id} balance after initialization: {account.get_amount_yoctonear()}'
)
mocknet_helpers.wait_at_least_one_block()
return node_account, accounts, max_tps
def do_ping(account, rpc_server):
account_id = account.key.account_id
base_block_hash = mocknet_helpers.get_latest_block_hash(addr=rpc_server[0],
port=rpc_server[1])
balance = mocknet_helpers.retry_and_ignore_errors(
lambda: mocknet_helpers.get_amount_yoctonear(
account_id, addr=rpc_server[0], port=rpc_server[1]))
if balance is not None:
balance_gauge.labels(account=account_id).set(balance)
logger.info(f'Sending 0 tokens from {account_id} to itself')
tx_res = mocknet_helpers.retry_and_ignore_errors(
lambda: account.send_transfer_tx(
account_id, transfer_amount=0, base_block_hash=base_block_hash))
logger.info(
f'Sending 0 tokens from {account_id} to itself, tx result: {tx_res}')
def send_resigned_transactions(tx_path, home_dir):
with open(os.path.join(home_dir, 'node0/', 'node_key.json'), 'r') as fin:
key_pair_json = json.load(fin)
key_pair = Key(key_pair_json['account_id'], key_pair_json['public_key'],
key_pair_json['secret_key'])
base_block_hash = mocknet_helpers.get_latest_block_hash(addr=LOCALHOST)
my_account = Account(key_pair,
init_nonce=0,
base_block_hash=base_block_hash,
rpc_infos=[(LOCALHOST, "3030")])
schema = dict(tx_schema + crypto_schema + bridge_schema)
with open(tx_path) as fin:
txs = json.load(fin, object_pairs_hook=OrderedDict)
for original_signed_tx in txs:
tx = convert_json_rust_instance_to_py_object(
original_signed_tx['transaction'], Transaction)
if hasattr(tx, 'blockHash'):
tx.blockHash = base_block_hash
if hasattr(tx, 'actions'):
try:
tx.actions = [
convert_json_action_to_py_action(action_dict)
for action_dict in tx.actions
]
except ValueError:
continue
tx.publicKey = PublicKey()
tx.publicKey.keyType = 0
tx.publicKey.data = key_pair.decoded_pk()
msg = BinarySerializer(schema).serialize(tx)
hash_ = hashlib.sha256(msg).digest()
signature = Signature()
signature.keyType = 0
signature.data = key_pair.sign_bytes(hash_)
resigned_tx = SignedTransaction()
resigned_tx.transaction = tx
resigned_tx.signature = signature
resigned_tx.hash = hash_
my_account.send_tx(BinarySerializer(schema).serialize(resigned_tx))
type=str,
default='storage',
help="""# Contract types:
# - storage - tries to do maximum amount of reads & writes (increments a large vector)
# - compute - tries to do maximum amount of compute (infinite loop)
# - write - tries to write a lot of data to the contract state.""")
args = parser.parse_args()
accounts = [args.account_ids.split(",")] if args.account_ids else [
f"shard{i}" for i in range(args.num_accounts)
]
validator_key = key.Key.from_json_file(
join(args.home, args.sender_key_file))
base_block_hash = mocknet_helpers.get_latest_block_hash(addr=args.host)
nonce = mocknet_helpers.get_nonce_for_key(validator_key, addr=args.host)
my_account = account.Account(validator_key,
init_nonce=nonce,
base_block_hash=base_block_hash,
rpc_infos=[(args.host, "3030")])
# First - 'reset' the counters in the contract.
for y in accounts:
my_account.send_call_contract_raw_tx(
contract_id=y,
method_name="reset_increment_many",
args=f'{{"how_many": 400}}'.encode("utf-8"),
deposit=0)
def get_test_accounts_from_args(argv):
node_account_id = argv[1]
pk = argv[2]
sk = argv[3]
assert argv[4]
rpc_nodes = argv[4].split(',')
logger.info(f'rpc_nodes: {rpc_nodes}')
num_nodes = int(argv[5])
max_tps = float(argv[6])
leader_account_id = sys.argv[7]
upk = sys.argv[8]
usk = sys.argv[9]
node_account_key = key.Key(node_account_id, pk, sk)
test_account_keys = [
key.Key(mocknet.load_testing_account_id(node_account_id, i), pk, sk)
for i in range(mocknet.NUM_ACCOUNTS)
]
base_block_hash = mocknet_helpers.get_latest_block_hash()
rpc_infos = [(rpc_addr, mocknet_helpers.RPC_PORT) for rpc_addr in rpc_nodes]
node_account = account.Account(node_account_key,
mocknet_helpers.get_nonce_for_pk(
node_account_key.account_id,
node_account_key.pk),
base_block_hash,
rpc_infos=rpc_infos)
accounts = [
account.Account(key,
mocknet_helpers.get_nonce_for_pk(
key.account_id, key.pk),
base_block_hash,
rpc_infos=rpc_infos) for key in test_account_keys
]
max_tps_per_node = max_tps / num_nodes
special_account_keys = [
key.Key(mocknet.SKYWARD_ACCOUNT, upk, usk),
key.Key(mocknet.TOKEN1_ACCOUNT, upk, usk),
key.Key(mocknet.TOKEN2_ACCOUNT, upk, usk),
key.Key(mocknet.ACCOUNT1_ACCOUNT, upk, usk),
key.Key(mocknet.TOKEN2_OWNER_ACCOUNT, upk, usk),
]
global special_accounts
special_accounts = [
account.Account(key,
mocknet_helpers.get_nonce_for_pk(
key.account_id, key.pk),
base_block_hash,
rpc_infos=rpc_infos) for key in special_account_keys
]
start_time = time.monotonic()
if node_account_id == leader_account_id:
initialize_skyward_contract(node_account_id, pk, sk)
elapsed = time.monotonic() - start_time
if elapsed < SKYWARD_INIT_TIME:
logger.info(f'Leader sleeps for {SKYWARD_INIT_TIME-elapsed}sec')
time.sleep(SKYWARD_INIT_TIME - elapsed)
else:
logger.info(f'Non-leader sleeps for {SKYWARD_INIT_TIME}sec')
time.sleep(SKYWARD_INIT_TIME)
return node_account, accounts, max_tps_per_node
parser.add_argument('--num_accounts', type=int, default=5)
parser.add_argument('--contract_dir',
type=str,
default='pytest/tests/loadtest/contract')
args = parser.parse_args()
print("Compiling contract")
subprocess.check_call(args=[
"cargo", "build", "--target", "wasm32-unknown-unknown", "--release"
],
cwd=args.contract_dir)
for i in range(args.num_accounts):
account_name = f"shard{i}"
shard_key = key.Key.from_json_file(join(args.home,
f"shard{i}_key.json"))
base_block_hash = mocknet_helpers.get_latest_block_hash()
nonce = mocknet_helpers.get_nonce_for_key(shard_key)
shard_account = account.Account(shard_key,
init_nonce=nonce,
base_block_hash=base_block_hash,
rpc_infos=[("localhost", "3030")])
shard_account.send_deploy_contract_tx(
join(
args.contract_dir,
"target/wasm32-unknown-unknown/release/loadtest_contract.wasm"))
args = parser.parse_args()
assert args.ips
ips = args.ips.split(',')
assert args.accounts
account_ids = args.accounts.split(',')
assert len(account_ids) == len(
ips), 'List of test accounts must match the list of node IP addresses'
interval_sec = args.interval_sec
assert interval_sec > 1, 'Need at least 1 second between pings'
port = args.port
pk, sk = args.public_key, args.private_key
rpc_server = (args.rpc_server_addr, args.rpc_server_port)
keys = [key_mod.Key(account_id, pk, sk) for account_id in account_ids]
base_block_hash = mocknet_helpers.get_latest_block_hash(addr=rpc_server[0],
port=rpc_server[1])
accounts = []
for ip, key in zip(ips, keys):
nonce = mocknet_helpers.get_nonce_for_pk(key.account_id,
key.pk,
addr=rpc_server[0],
port=rpc_server[1])
accounts.append(
account_mod.Account(key,
nonce,
base_block_hash,
rpc_infos=[(ip, port)]))
prometheus_client.start_http_server(args.metrics_port)
with ThreadPoolExecutor() as executor:
