def test_sign_verify_good(key_hex: str, pub_key_hex: str,
rev_address: str) -> None:
key = PrivateKey.from_hex(key_hex)
pub_key = PublicKey.from_hex(pub_key_hex)
message = 'hello rchain'.encode()
signature = key.sign(message)
pub_key.verify(signature, message)
def faucetPost(faucetRequest: FaucetRequest, request: Request):
address = faucetRequest.address
ip = ipaddress.ip_address(request.client.host)
if ip.is_private:
host = request.headers.get('X-Real-IP')
if host:
addr = ipaddress.ip_address(host)
else:
addr = request.client.host
else:
addr = request.client.host
request_before = request_faucet_TTCache.get(addr)
if request_before:
return FaucetResponse(deployID=request_before[1],
message='IP:{}, Your request for testnet rev to {} is too high. Try later'.format(
addr, request_before[0]))
else:
try:
with RClient(setting.TARGET_TESTNET_HOST, setting.TARGET_TESTNET_PORT) as client:
vault = VaultAPI(client)
private = PrivateKey.from_hex(setting.TESTNET_FAUCET_PRIVATE_KEY)
deployId = vault.transfer_ensure(private.get_public_key().get_rev_address(), address,
setting.TESTNET_FAUCET_AMOUNT, private)
request_faucet_TTCache[addr] = (address, deployId, request.client.host)
return FaucetResponse(deployID=deployId,
message="Transfer to your address is done. You will receive the rev in some time")
except RClientException as e:
return FaucetResponse(deployID='',
message="There is something with server {}. "
"Please contact the maintainer to solve it.".format(e))
def sign_deploy(private_key: str, term: str, phlo_price: int, phlo_limit: int,
valid_after_block_number: int, timestamp: int,
sig_algorithm: str) -> None:
pri = PrivateKey.from_hex(private_key)
signed_deploy = create_deploy_data(pri, term, phlo_price, phlo_limit,
valid_after_block_number, timestamp)
click.echo(signed_deploy.sig.hex())
def __init__(self, config):
self.setup_error_log(config['error_logs'])
logging.info("Initialing dispatcher")
self._config = config
self.clients = {}
for server in config['servers']:
for host_name, host_config in server.items():
self.clients[host_name] = init_client(host_name, host_config)
logging.info("Read the deploying contract {}".format(
config['deploy']['contract']))
with open(config['deploy']['contract']) as f:
self.contract = f.read()
logging.info("Checking if deploy key is valid.")
self.deploy_key = PrivateKey.from_hex(config['deploy']['deploy_key'])
self.phlo_limit = int(config['deploy']['phlo_limit'])
self.phlo_price = int(config['deploy']['phlo_price'])
self.wait_timeout = int(config['waitTimeout'])
self.wait_interval = int(config['waitInterval'])
self.error_node_records = config['error_node_records']
self.init_queue()
self._running = False
def faucet(address: str, request: Request):
request_before = request_faucet_TTCache.get(request.client.host)
if request_before:
return FaucetResponse(
deployID='',
message='Your request for testnet rev is too high. Try later.')
else:
try:
with RClient(setting.TARGET_TESTNET_HOST,
setting.TARGET_TESTNET_PORT) as client:
vault = VaultAPI(client)
private = PrivateKey.from_hex(
setting.TESTNET_FAUCET_PRIVATE_KEY)
deployId = vault.transfer(
private.get_public_key().get_rev_address(), address,
setting.TESTNET_FAUCET_AMOUNT, private)
request_faucet_TTCache[request.client.host] = address
return FaucetResponse(
deployID=deployId,
message=
"Transfer to your address is done. You will receive the rev in some time"
)
except RClientException as e:
return FaucetResponse(
deployID='',
message="There is something with server {}. "
"Please contact the maintainer to solve it.".format(e))
def test_publickey_from_hex(key_hex: str, pub_key_hex: str,
rev_address: str) -> None:
key = PrivateKey.from_hex(key_hex)
pub_key = PublicKey.from_hex(pub_key_hex)
expected_pub_key_bytes = key.get_public_key().to_bytes()
actual_pub_key_bytes = pub_key.to_bytes()
assert expected_pub_key_bytes == actual_pub_key_bytes
def test_sign_block_hash_verify_good(key_hex: str, pub_key_hex: str,
rev_address: str) -> None:
key = PrivateKey.from_hex(key_hex)
pub_key = PublicKey.from_hex(pub_key_hex)
message = 'hello rchain'.encode()
digest = blake2b_32(message).digest()
signature = key.sign_block_hash(digest)
pub_key.verify_block_hash(signature, digest)
def test_make_wallets_file_lines() -> None:
wallets_map = {
PrivateKey.from_hex("80366db5fbb8dad7946f27037422715e4176dda41d582224db87b6c3b783d709"):
40,
PrivateKey.from_hex("120d42175739387af0264921bb117e4c4c05fbe2ce5410031e8b158c6e414bb5"):
45,
PrivateKey.from_hex("1f52d0bce0a92f5c79f2a88aae6d391ddf853e2eb8e688c5aa68002205f92dad"):
26
}
output = make_wallets_file_lines(wallets_map)
assert output == [
'26218db6e5a2eed1901f72cea58fda7ef1f602c6,40,0',
'42c828c183163cb50f6ad5207a10899b59aae91c,45,0',
'2a11fd494610330f3b522562f7204670f8928133,26,0',
]
def test_sign_verify_bad(key_hex: str, pub_key_hex: str,
rev_address: str) -> None:
key = PrivateKey.from_hex(key_hex)
pub_key = PublicKey.from_hex(pub_key_hex)
sign_message = 'hello rchain'.encode()
verify_message = 'hello world'.encode()
signature = key.sign(sign_message)
with pytest.raises(BadSignatureError):
pub_key.verify(signature, verify_message)
def test_sign_block_hash_verify_bad(key_hex: str, pub_key_hex: str,
rev_address: str) -> None:
key = PrivateKey.from_hex(key_hex)
pub_key = PublicKey.from_hex(pub_key_hex)
sign_message = 'hello rchain'.encode()
verify_message = 'hello world'.encode()
block_hash = blake2b_32(sign_message).digest()
signature = key.sign_block_hash(block_hash)
verify_digest = blake2b_32(verify_message).digest()
with pytest.raises(BadSignatureError):
pub_key.verify_block_hash(signature, verify_digest)
def get_rev_addr(input_type: str, input: str) -> None:
if input_type == 'eth':
click.echo(generate_rev_addr_from_eth(input))
elif input_type == 'public':
pub = PublicKey.from_hex(input)
click.echo(pub.get_rev_address())
elif input_type == 'private':
private = PrivateKey.from_hex(input)
click.echo(private.get_public_key().get_rev_address())
else:
raise NotImplementedError("Not supported type {}".format(input_type))
def faucetPost(faucetRequest: FaucetRequest, request: Request):
address = faucetRequest.address
realIp = request.headers.get('X-Real-IP')
if realIp:
addr = ipaddress.ip_address(realIp)
else:
addr = request.client.host
request_before = request_faucet_TTCache.get(addr)
if request_before:
return FaucetResponse(
deployID=request_before[1],
message=
'IP:{}, Your request for testnet rev to {} is too high. Try later'.
format(addr, request_before[0]))
else:
try:
with RClient(setting.TARGET_TESTNET_HOST,
setting.TARGET_TESTNET_PORT) as client:
private = PrivateKey.from_hex(
setting.TESTNET_FAUCET_PRIVATE_KEY)
contract = render_contract_template(
TRANSFER_ENSURE_TO_RHO_TPL, {
'from': private.get_public_key().get_rev_address(),
'to': address,
'amount': str(setting.TESTNET_FAUCET_AMOUNT)
})
timestamp_mill = int(time.time() * 1000)
deployId = client.deploy_with_vabn_filled(
private, contract, TRANSFER_PHLO_PRICE,
TRANSFER_PHLO_LIMIT, timestamp_mill,
setting.TESTNET_FAUCET_SHARDID)
request_faucet_TTCache[addr] = (address, deployId,
request.client.host)
return FaucetResponse(
deployID=deployId,
message=
"Transfer to your address is done. You will receive the rev in some time"
)
except RClientException as e:
return FaucetResponse(
deployID='',
message="There is something with server {}. "
"Please contact the maintainer to solve it.".format(e))
#!/usr/bin/python
import time
from rchain.client import RClient
from rchain.crypto import PrivateKey
from pyrgov.rgov import rgovAPI
RCHAIN_SERVER = ['localhost', 'rhobot']
admin = PrivateKey.from_hex(
'28a5c9ac133b4449ca38e9bdf7cacdce31079ef6b3ac2f0a080af83ecff98b36')
alpha = PrivateKey.from_hex(
'7139b72b9939334ff76e1479072c0558dca2c3620971c2bb233a7b25a690d610')
bravo = PrivateKey.from_hex(
'dd0dd23cd51460e6c42a154623df19372be332f0a61a51755603ab897f6ede39')
#alpha = PrivateKey.generate()
#bravo = PrivateKey.generate()
charlie = PrivateKey.generate()
def print_balances(rgov: rgovAPI):
# get balance of vault
admin_balance = rgov.checkBalance(admin.get_public_key().get_rev_address())
print("admin Balance ", admin_balance, " REV ",
admin.get_public_key().get_rev_address())
charlie_balance = rgov.checkBalance(
charlie.get_public_key().get_rev_address())
print("charlie Balance ", charlie_balance, " REV ",
charlie.get_public_key().get_rev_address())
from .conftest import (
testing_context, )
from .rnode import (
Node,
started_bootstrap_with_network,
)
from .common import (
TestingContext,
TransderFundsError,
)
from .wait import (wait_for_log_match_result, wait_for_log_match_result_raise,
wait_for_approved_block_received_handler_state,
WaitTimeoutError)
ALICE_KEY = PrivateKey.from_hex(
"b2527b00340a83e302beae2a8daf6d654e8e57541acfa261cc1b5635eb16aa15")
BOB_KEY = PrivateKey.from_hex(
"9a801debae8bb97fe54c99389cafa576c60612503348578125b65ab182ff5850")
CHARLIE_KEY = PrivateKey.from_hex(
"567ea426deaeb8233f134c3a266149fb196d6eea7d28b447dfefff92002cb400")
def wait_transfer_result(context: TestingContext, node: Node,
transfer_funds_result_pattern: Pattern) -> None:
transfer_result_match = wait_for_log_match_result_raise(
context, node, transfer_funds_result_pattern)
reason = transfer_result_match.group('reason')
if reason != "Nil":
raise TransderFundsError(reason)
# Requires the following line in wallets.txt
#
# 0x06a441c277bf454c5d159b0e5bdafca69b296733,1000000,0
import grpc
from rchain.crypto import PrivateKey
from rchain.client import RClient
from rchain.vault import VaultAPI
alice_key = PrivateKey.from_hex(
"2a6cd3b196a0b154446a23443cee70629cdb3db0398ea6fb099175708f47f590")
alice_public_key = alice_key.get_public_key()
print("Private key is " + alice_key.to_hex())
print("Public key is " + alice_public_key.to_hex())
print("Eth address is " + alice_public_key.get_eth_address())
print("Rev address is " + alice_public_key.get_rev_address())
with grpc.insecure_channel('localhost:10401') as channel:
client = RClient(channel)
alice_vault_api = VaultAPI(client, alice_key)
alice_vault_api.bond(amount=100)
alice_bal_deploy_id = alice_vault_api.deploy_get_balance()
client.propose()
alice_bal = alice_vault_api.get_balance_from_deploy_id(alice_bal_deploy_id)
assert alice_bal == 999900
from .common import (
CommandLineOptions,
)
from .rnode import (
started_peer,
started_bootstrap_with_network,
)
from .wait import (
wait_for_block_approval,
wait_for_approved_block_received_handler_state,
wait_for_sent_approved_block,
)
CEREMONY_MASTER_KEYPAIR = PrivateKey.from_hex("80366db5fbb8dad7946f27037422715e4176dda41d582224db87b6c3b783d709")
VALIDATOR_A_KEYPAIR = PrivateKey.from_hex("120d42175739387af0264921bb117e4c4c05fbe2ce5410031e8b158c6e414bb5")
VALIDATOR_B_KEYPAIR = PrivateKey.from_hex("1f52d0bce0a92f5c79f2a88aae6d391ddf853e2eb8e688c5aa68002205f92dad")
VALIDATOR_C_KEYPAIR = PrivateKey.from_hex("5322dbb1828bdb44cb3275d35672bb3453347ee249a1f32d3c035e5ec3bfad1a")
READONLY_A_KEYPAIR = PrivateKey.from_hex("632a21e0176c4daed1ca78f08f98885f61d2050e0391e31eae59ff1a35ccca7f")
def test_successful_genesis_ceremony(command_line_options: CommandLineOptions, random_generator: Random, docker_client: DockerClient) -> None:
"""
https://docs.google.com/document/d/1Z5Of7OVVeMGl2Fw054xrwpRmDmKCC-nAoIxtIIHD-Tc/
"""
bootstrap_cli_options = {
'--deploy-timestamp' : '1',
'--required-signatures': '2',
'--approve-duration' : '1min',
'--approve-interval' : '10sec',
#!/usr/bin/python
import time
from rchain.client import RClient
from rchain.crypto import PrivateKey
from rchain.util import create_deploy_data
from pyrgov.rgov import rgovAPI
RCHAIN_SERVER = ['localhost', 'rhobot', 'testnet', 'demo', 'mainnet']
TRANSFER_PHLO_LIMIT = 10000000
TRANSFER_PHLO_PRICE = 1
admin = PrivateKey.from_hex('28a5c9ac133b4449ca38e9bdf7cacdce31079ef6b3ac2f0a080af83ecff98b36')
alpha = PrivateKey.from_hex('7139b72b9939334ff76e1479072c0558dca2c3620971c2bb233a7b25a690d610')
bravo = PrivateKey.from_hex('dd0dd23cd51460e6c42a154623df19372be332f0a61a51755603ab897f6ede39')
charlie = PrivateKey.from_hex('79cf7604de08deee525ac9f500e118eef6036c56b175adf5afac94bb9542c5c1')
def print_balances(rgov: rgovAPI):
# get balance of vault
admin_balance = rgov.checkBalance(admin.get_public_key().get_rev_address())
print("admin Balance ", admin_balance, " REV ", admin.get_public_key().get_rev_address())
bravo_balance = rgov.checkBalance(bravo.get_public_key().get_rev_address())
print("bravo Balance ", bravo_balance, " REV ", bravo.get_public_key().get_rev_address())
rgov = rgovAPI(RCHAIN_SERVER[0])
result = rgov.newInbox(alpha)
'node1.root-shard.mainnet.rchain.coop',
'node2.root-shard.mainnet.rchain.coop',
'node3.root-shard.mainnet.rchain.coop',
'node4.root-shard.mainnet.rchain.coop',
'node5.root-shard.mainnet.rchain.coop',
'node6.root-shard.mainnet.rchain.coop',
'node7.root-shard.mainnet.rchain.coop',
'node8.root-shard.mainnet.rchain.coop'
]
READONLY_SERVER = [
'observer-asia.services.mainnet.rchain.coop',
'observer-us.services.mainnet.rchain.coop',
'observer-eu.services.mainnet.rchain.coop'
]
alice = PrivateKey.from_hex(
'61e594124ca6af84a5468d98b34a4f3431ef39c54c6cf07fe6fbf8b079ef64f6')
bob = PrivateKey.generate()
exploratory_term = 'new return in{return!("a")}'
with RClient(READONLY_SERVER[0], 40401) as client:
vault = VaultAPI(client)
# get the balance of a vault
# get balance can only perform in the read-only node
bob_balance = vault.get_balance(bob.get_public_key().get_rev_address())
with RClient(MAINNET_SERVER[0], 40401) as client:
# because transfer need a valid deploy
# the transfer need the private to perform signing
vault = VaultAPI(client)
deployId = vault.transfer(alice.get_public_key().get_rev_address(),
import grpc
import logging
import sys
from rchain.crypto import PrivateKey
from rchain.client import RClient
import time
import subprocess
root = logging.getLogger()
root.setLevel(logging.DEBUG)
config_path = str(sys.argv[3])
with grpc.insecure_channel('localhost:40401') as channel:
client = RClient(channel)
with open(sys.argv[2]) as file:
data = file.read()
start_time = time.time()
client.deploy_with_vabn_filled(PrivateKey.from_hex(sys.argv[1]), data,
1, 1000000000)
dur = time.time() - start_time
subprocess.run([
'python3', 'reportInfluxDBMetric.py', 'pyrchain.deploytime',
str(dur), config_path
])
import pytest
from rchain.crypto import PrivateKey
from . import conftest
from .common import (
CommandLineOptions,
SynchronyConstraintError,
)
from .rnode import (
bootstrap_connected_peer,
ready_bootstrap_with_network,
)
from .wait import (
wait_for_node_sees_block, )
BOOTSTRAP_NODE_KEYS = PrivateKey.from_hex(
"80366db5fbb8dad7946f27037422715e4176dda41d582224db87b6c3b783d709")
BONDED_VALIDATOR_KEY_1 = PrivateKey.from_hex(
"120d42175739387af0264921bb117e4c4c05fbe2ce5410031e8b158c6e414bb5")
BONDED_VALIDATOR_KEY_2 = PrivateKey.from_hex(
"f7bfb2b3f2be909dd50beac05bece5940b1e7266816d7294291a2ff66a5d660b")
BONDED_VALIDATOR_KEY_3 = PrivateKey.from_hex(
"2b173084083291ac6850cb734dffb69dfcb280aeb152f0d5be979bea7827c03a")
def test_synchrony_constraint(command_line_options: CommandLineOptions,
random_generator: Random,
docker_client: DockerClient) -> None:
"""
Create a network with 4 validators.
Validator config situation:
from random import Random
import os
import re
from docker.client import DockerClient
from rchain.crypto import PrivateKey
from .common import (
CommandLineOptions,
random_string,
)
from .conftest import testing_context
from .rnode import ready_bootstrap_with_network
from .wait import wait_for_log_match
USER_KEY = PrivateKey.from_hex(
"3596e2e5fd14b24a6d84af04b7f0a8f13e3e68ee2ca91dc4b19550f12e61502c")
def test_data_is_stored_and_served_by_node(
command_line_options: CommandLineOptions, docker_client: DockerClient,
random_generator: Random) -> None:
wallets_map = {USER_KEY: 100000000}
with testing_context(command_line_options,
random_generator,
docker_client,
wallets_dict=wallets_map) as context:
with ready_bootstrap_with_network(context=context) as bootstrap_node:
store_data_contract = os.path.join('resources/storage',
"store-data.rho")
read_data_contract = os.path.join('resources/storage',
"read-data.rho")
from random import Random
from typing import Generator
import pytest
from rchain.crypto import PrivateKey
from docker.client import DockerClient
from .common import CommandLineOptions
from .conftest import testing_context
from .rnode import (SynchronyConstraintError, started_bootstrap_with_network,
started_peer)
from .test_wallets import get_vault_balance
from .wait import (wait_for_approved_block_received_handler_state,
wait_for_peers_count_at_least)
CEREMONY_MASTER_PRIVATE = PrivateKey.from_hex(
"80366db5fbb8dad7946f27037422715e4176dda41d582224db87b6c3b783d709")
VALIDATOR_A_PRIVATE = PrivateKey.from_hex(
"120d42175739387af0264921bb117e4c4c05fbe2ce5410031e8b158c6e414bb5")
VALIDATOR_B_PRIVATE = PrivateKey.from_hex(
"1f52d0bce0a92f5c79f2a88aae6d391ddf853e2eb8e688c5aa68002205f92dad")
@contextlib.contextmanager
def temp_rnode_data() -> Generator[str, None, None]:
with tempfile.TemporaryDirectory() as temp_dir:
with tarfile.open('resources/rnode_data/bootstrap') as tar:
tar.extractall(os.path.join(temp_dir, 'bootstrap'))
with tarfile.open('resources/rnode_data/validatorA') as tar:
tar.extractall(os.path.join(temp_dir, 'validatorA'))
with tarfile.open('resources/rnode_data/validatorB') as tar:
tar.extractall(os.path.join(temp_dir, 'validatorB'))
from docker.client import DockerClient
from rchain.crypto import PrivateKey
from rchain.pb.DeployServiceCommon_pb2 import BlockInfo
from . import conftest
from .common import (CommandLineOptions, NotAnActiveValidatorError)
from .rnode import (
bootstrap_connected_peer,
ready_bootstrap_with_network,
)
from .wait import (
wait_for_node_sees_block, )
from .test_wallets import get_vault_balance
BOOTSTRAP_KEY = PrivateKey.from_hex(
"b2527b00340a83e302beae2a8daf6d654e8e57541acfa261cc1b5635eb16aa15")
VALIDATOR_KEY_1 = PrivateKey.from_hex(
"9a801debae8bb97fe54c99389cafa576c60612503348578125b65ab182ff5850")
VALIDATOR_KEY_2 = PrivateKey.from_hex(
"2bdedd2e4dd2e7b5f176b7a5bc155f10fafd3fbd9c03fb7556f2ffd22c786f8b")
VALIDATOR_KEY_3 = PrivateKey.from_hex(
"632a21e0176c4daed1ca78f08f98885f61d2050e0391e31eae59ff1a35ccca7f")
def get_total_cost_from_block(block_info: BlockInfo) -> int:
"""get the total costs in the block"""
total_cost = 0
for deploy in block_info.deploys:
total_cost += deploy.cost
return total_cost
from random import Random
import pytest
from rchain.crypto import PrivateKey
from docker.client import DockerClient
from . import conftest
from .common import (
CommandLineOptions, )
from .rnode import (ready_bootstrap_with_network)
BOOTSTRAP_NODE_KEYS = PrivateKey.from_hex(
"80366db5fbb8dad7946f27037422715e4176dda41d582224db87b6c3b783d709")
BONDED_VALIDATOR_KEY_1 = PrivateKey.from_hex(
"120d42175739387af0264921bb117e4c4c05fbe2ce5410031e8b158c6e414bb5")
def test_deploy_with_not_enough_phlo(command_line_options: CommandLineOptions,
random_generator: Random,
docker_client: DockerClient) -> None:
genesis_vault = {
BOOTSTRAP_NODE_KEYS: 500000000000,
BONDED_VALIDATOR_KEY_1: 500000000000,
}
with conftest.testing_context(command_line_options, random_generator, docker_client,
wallets_dict=genesis_vault) as context, \
ready_bootstrap_with_network(context=context, synchrony_constraint_threshold=0) as bootstrap_node:
contract = "/opt/docker/examples/tut-hello.rho"
# deploy with not enough phlo
bootstrap_node.deploy(contract,
BOOTSTRAP_NODE_KEYS,
from docker.client import DockerClient
from . import conftest
from .common import CommandLineOptions
from .wait import (
wait_for_node_sees_block,
wait_for_peers_count_at_least,
wait_for_block_finalized,
)
from .rnode import (
bootstrap_connected_peer,
ready_bootstrap_with_network,
)
BOOTSTRAP_NODE_KEY = PrivateKey.from_hex("ff2ba092524bafdbc85fa0c7eddb2b41c69bc9bf066a4711a8a16f749199e5be")
BONDED_VALIDATOR_KEY_1 = PrivateKey.from_hex("597623f0b50e82008d52644983699724538b4307efbe3d0b992c651ca7f860c8")
BONDED_VALIDATOR_KEY_2 = PrivateKey.from_hex("9a32ff7b7c6e25527e0b4e5bec70596c6094e6529d56bf61cbd1ca26d3e92b10")
BONDED_VALIDATOR_KEY_3 = PrivateKey.from_hex("af47862137d4e772f540029ae73ee01443c61288f3df9307a13d681de6ad2de4")
BONDED_VALIDATOR_KEY_4 = PrivateKey.from_hex("2a6018851984203e0983f0671e94fcf649ec04b614e5924f435081f7d1e3b44b")
def test_finalizes_block(command_line_options: CommandLineOptions, random_generator: Random, docker_client: DockerClient) -> None:
"""
^
|
| b7=-1.0
| b6=-1.0
| b5=-1.0
| b4=0.2631579
from rchain.crypto import PrivateKey
PREGENERATED_KEYPAIRS = [
PrivateKey.from_hex(
"80366db5fbb8dad7946f27037422715e4176dda41d582224db87b6c3b783d709"),
PrivateKey.from_hex(
"120d42175739387af0264921bb117e4c4c05fbe2ce5410031e8b158c6e414bb5"),
PrivateKey.from_hex(
"1f52d0bce0a92f5c79f2a88aae6d391ddf853e2eb8e688c5aa68002205f92dad"),
PrivateKey.from_hex(
"5322dbb1828bdb44cb3275d35672bb3453347ee249a1f32d3c035e5ec3bfad1a"),
PrivateKey.from_hex(
"632a21e0176c4daed1ca78f08f98885f61d2050e0391e31eae59ff1a35ccca7f"),
PrivateKey.from_hex(
"2bdedd2e4dd2e7b5f176b7a5bc155f10fafd3fbd9c03fb7556f2ffd22c786f8b"),
PrivateKey.from_hex(
"ff2ba092524bafdbc85fa0c7eddb2b41c69bc9bf066a4711a8a16f749199e5be")
]
def test_privatekey_function(key_hex: str, pub_key_hex: str,
rev_address: str) -> None:
key = PrivateKey.from_hex(key_hex)
pub_key = key.get_public_key()
actual_pub_key_hex = pub_key.to_bytes().hex()
assert pub_key_hex == actual_pub_key_hex
from . import conftest
from .common import (
CommandLineOptions,
NonZeroExitCodeError,
)
from .rnode import (
bootstrap_connected_peer,
ready_bootstrap_with_network,
)
from .wait import (wait_for_node_sees_block, wait_for_peers_count_at_least,
wait_for_approved_block_received_handler_state)
from .test_wallets import get_vault_balance
BOOTSTRAP_KEY = PrivateKey.from_hex(
"b2527b00340a83e302beae2a8daf6d654e8e57541acfa261cc1b5635eb16aa15")
BONDED_VALIDATOR_KEY = PrivateKey.from_hex(
"9a801debae8bb97fe54c99389cafa576c60612503348578125b65ab182ff5850")
JOINING_VALIDATOR_KEY = PrivateKey.from_hex(
"567ea426deaeb8233f134c3a266149fb196d6eea7d28b447dfefff92002cb400")
READONLY_PEER_KEY = PrivateKey.from_hex(
"3596e2e5fd14b24a6d84af04b7f0a8f13e3e68ee2ca91dc4b19550f12e61502c")
def test_bonding_validators(command_line_options: CommandLineOptions,
random_generator: Random,
docker_client: DockerClient) -> None:
genesis_vault = {
BOOTSTRAP_KEY: 50000000,
BONDED_VALIDATOR_KEY: 50000000,
JOINING_VALIDATOR_KEY: 50000000,
help="private key of the sender vault")
parser.add_argument("-r",
"--receiver",
action="store",
type=str,
required=True,
dest="receiver",
help="receiver of the transfer")
parser.add_argument("-a",
"--amount",
action="store",
type=int,
required=True,
dest="amount",
help="the amount of the transfer")
args = parser.parse_args()
try:
private_key = PrivateKey.from_hex(args.private_key)
except:
logging.error("The private you provided is not valid")
sys.exit(1)
with grpc.insecure_channel('localhost:40401') as channel:
client = RClient(channel)
vault = VaultAPI(client, private_key)
vault.transfer(from_addr=None, to_addr=args.receiver, amount=args.amount)
logging.info("Succeed transfer {} from {} to {} .".format(
args.amount,
private_key.get_public_key().get_rev_address(), args.receiver))
def test_key_to_hex(key_hex: str, pub_key_hex: str, rev_address: str) -> None:
private_key = PrivateKey.from_hex(key_hex)
assert private_key.to_hex() == key_hex
public_key = PublicKey.from_hex(pub_key_hex)
assert public_key.to_hex() == pub_key_hex