def main(): god_key = PrivateKey.generate() alice_key = PrivateKey.generate() bob_key = PrivateKey.generate() god_addr = god_key.get_public_key().get_rev_address() alice_addr = alice_key.get_public_key().get_rev_address() bob_addr = bob_key.get_public_key().get_rev_address() with grpc.insecure_channel('172.27.0.2:40401') as channel: client = RClient(channel) god_vault_api = VaultAPI(client, god_key) alice_vault_api = VaultAPI(client, alice_key) bob_vault_api = VaultAPI(client, bob_key) # Most methods without deploy_ prefix create block (propose) after # deploy. To deploy a batch and then create block do: # # alice_vault_api.deploy_create_vault() # bob_vault_api.deploy_create_vault() # client.propose() alice_vault_api.create_vault() bob_vault_api.create_vault() assert god_vault_api.get_balance() == 100_000 assert alice_vault_api.get_balance() == 0 assert bob_vault_api.get_balance() == 0 god_vault_api.transfer(None, alice_addr, 1000) # Example way to get balances in one block: god_bal_deploy_id = god_vault_api.deploy_get_balance() alice_bal_deploy_id = alice_vault_api.deploy_get_balance() bob_bal_deploy_id = bob_vault_api.deploy_get_balance() client.propose() god_bal = god_vault_api.get_balance_from_deploy_id(god_bal_deploy_id) alice_bal = alice_vault_api.get_balance_from_deploy_id( alice_bal_deploy_id) bob_bal = bob_vault_api.get_balance_from_deploy_id(bob_bal_deploy_id) assert god_bal == 99_000 assert alice_bal == 1000 assert bob_bal == 0 alice_vault_api.transfer(None, bob_addr, 400) assert god_vault_api.get_balance() == 99_000 assert alice_vault_api.get_balance() == 600 assert bob_vault_api.get_balance() == 400
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 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 deploy(self, term: str, phlo_limit: int, phlo_price: int, valid_after_block_number: int, deployer: PrivateKey) -> str: timestamp = int(time.time() * 1000) deploy_data = { "term": term, "timestamp": timestamp, "phloLimit": phlo_limit, "phloPrice": phlo_price, "validAfterBlockNumber": valid_after_block_number } deploy_proto = DeployDataProto( term=term, timestamp=timestamp, phloLimit=phlo_limit, phloPrice=phlo_price, validAfterBlockNumber=valid_after_block_number) deploy_req = { "data": deploy_data, "deployer": deployer.get_public_key().to_hex(), "signature": sign_deploy_data(deployer, deploy_proto).hex(), "sigAlgorithm": "secp256k1" } deploy_url = self.url + '/deploy' rep = requests.post(deploy_url, json=deploy_req) _check_reponse(rep) return rep.text
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_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 test_slash_justification_not_correct(command_line_options: CommandLineOptions, random_generator: Random, docker_client: DockerClient) -> None: """ Slash a validator which proposed a block with justifications not matching bonded validators of main parent 1. v1 proposes a valid block b1 2. v1 proposes an invalid block b3 which contains justifications not matching bonded validators and send it to v2 3. v2 records the invalid block b3 (InvalidFollows) 4. v2 proposes a new block which slashes v1. """ bonded_validators = { BOOTSTRAP_NODE_KEY: 100, BONDED_VALIDATOR_KEY_1: 100, BONDED_VALIDATOR_KEY_2: 100, BONDED_VALIDATOR_KEY_3: 100, } with three_nodes_network_with_node_client(command_line_options, random_generator, docker_client, validator_bonds_dict=bonded_validators) as (context, _ , validator1, validator2, client): contract = '/opt/docker/examples/tut-hello.rho' validator1.deploy(contract, BONDED_VALIDATOR_KEY_1) blockhash = validator1.propose() wait_for_node_sees_block(context, validator2, blockhash) block_info = validator1.get_block(blockhash) block_msg = client.block_request(block_info.blockInfo.blockHash, validator1) invalid_justifications_block = BlockMessage() invalid_justifications_block.CopyFrom(block_msg) error_justification = Justification(validator=PrivateKey.generate().to_bytes(), latestBlockHash=block_msg.blockHash) invalid_justifications_block.justifications.append(error_justification) # pylint: disable=maybe-no-member # change timestamp to make block hash different invalid_justifications_block.header.timestamp = block_msg.header.timestamp + 1 # pylint: disable=maybe-no-member invalid_block_hash = gen_block_hash_from_block(invalid_justifications_block) invalid_justifications_block.sig = BONDED_VALIDATOR_KEY_1.sign_block_hash(invalid_block_hash) invalid_justifications_block.blockHash = invalid_block_hash client.send_block(invalid_justifications_block, validator2) record_invalid = re.compile("Recording invalid block {}... for InvalidFollows".format(invalid_block_hash.hex()[:10])) wait_for_log_match(context, validator2, record_invalid) validator2.deploy(contract, BONDED_VALIDATOR_KEY_2) slashed_block_hash = validator2.propose() block_info = validator2.get_block(slashed_block_hash) bonds_validators = {b.validator: b.stake for b in block_info.blockInfo.bonds} assert bonds_validators[BONDED_VALIDATOR_KEY_1.get_public_key().to_hex()] == 0.0
def test_sign_deploy(key: PrivateKey, terms: str, phlo_price: int, phlo_limit: int, valid_after_block_no: int, timestamp_millis: int): runner = CliRunner() result = runner.invoke(cli, ['sign-deploy', '--private-key', key.to_hex(), '--term', terms, "--phlo-price", phlo_price, "--phlo-limit", phlo_limit, "--valid-after-block-number", valid_after_block_no, "--timestamp", timestamp_millis, "--sig-algorithm", "secp256k1" ]) assert result.exit_code == 0 sig = result.output.strip() data = DeployDataProto( deployer=key.get_public_key().to_bytes(), term=terms, phloPrice=phlo_price, phloLimit=phlo_limit, validAfterBlockNumber=valid_after_block_no, timestamp=timestamp_millis, sigAlgorithm='secp256k1', ) assert verify_deploy_data(key.get_public_key(), bytes.fromhex(sig), data)
def test_client_deploy(key: PrivateKey, terms: str, phlo_price: int, phlo_limit: int, valid_after_block_no: int, timestamp_millis: int) -> None: class DummyDeploySerivce(DeployServiceServicer): def doDeploy(self, request: DeployDataProto, context: grpc.ServicerContext) -> DeployResponse: return DeployResponse(result=request.sig.hex()) with deploy_service(DummyDeploySerivce()) as (server, port), \ RClient(TEST_HOST, port) as client: ret = client.deploy(key, terms, phlo_price, phlo_limit, valid_after_block_no, timestamp_millis) assert verify_deploy_data( key.get_public_key(), bytes.fromhex(ret), create_deploy_data(key, terms, phlo_price, phlo_limit, valid_after_block_no, timestamp_millis))
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))
def test_submit_deploy(key: PrivateKey, terms: str, phlo_price: int, phlo_limit: int, valid_after_block_no: int, timestamp_millis: int): class DummyDeploySerivce(DeployServiceServicer): def doDeploy(self, request: DeployDataProto, context: grpc.ServicerContext) -> DeployResponse: return DeployResponse(result=request.sig.hex()) with deploy_service(DummyDeploySerivce()) as (server, port): runner = CliRunner() result = runner.invoke(cli, ['submit-deploy', '--deployer', key.get_public_key().to_hex(), '--term', terms, "--phlo-price", phlo_price, "--phlo-limit", phlo_limit, "--valid-after-block-number", valid_after_block_no, "--timestamp", timestamp_millis, "--sig-algorithm", "secp256k1", "--sig", "1111", "--host", 'localhost', "--port", port ]) assert result.exit_code == 0
def test_transfer_to_not_exist_vault(command_line_options: CommandLineOptions, docker_client: DockerClient, random_generator: Random) -> None: genesis_vault = {CHARLIE_KEY: 500000000, ALICE_KEY: 500000000} not_exist_vault = PrivateKey.generate() with testing_context(command_line_options, random_generator, docker_client, wallets_dict=genesis_vault) as context, \ started_bootstrap_with_network(context=context) as bootstrap: transfer_amount = 2000000 wait_for_approved_block_received_handler_state(context, bootstrap) alice_rev_address = ALICE_KEY.get_public_key().get_rev_address() no_exist_address = not_exist_vault.get_public_key().get_rev_address() alice_balance = get_vault_balance(context, bootstrap, alice_rev_address, CHARLIE_KEY, 1000000, 1) assert alice_balance == 500000000 with pytest.raises(WaitTimeoutError): # transfer to a vault which does not exist in the genesis vault # the result can not be got because the vault is not created in the tuplespace log_marker = random_string(context, 10) transfer_funds_result_pattern = re.compile( '"{} (Successfully|Failing) reason: (?P<reason>[a-zA-Z0-9 ]*)"' .format(log_marker)) deploy_transfer(log_marker, bootstrap, alice_rev_address, no_exist_address, transfer_amount, ALICE_KEY, 1000000, 1) wait_transfer_result(context, bootstrap, transfer_funds_result_pattern) # the get_vault_balance contract would call the method `findOrCreate` to generate the not-exist vault # then the transfer above can get the continuation and transfer is done no_vault_balance = get_vault_balance(context, bootstrap, no_exist_address, CHARLIE_KEY, 1000000, 1) wait_transfer_result(context, bootstrap, transfer_funds_result_pattern) assert no_vault_balance == transfer_amount
#!/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 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") ]
import grpc import pytest from click.testing import CliRunner from rchain.__main__ import cli from rchain.crypto import PrivateKey from rchain.pb.CasperMessage_pb2 import DeployDataProto from rchain.pb.DeployServiceV1_pb2 import DeployResponse from rchain.pb.DeployServiceV1_pb2_grpc import DeployServiceServicer from rchain.util import verify_deploy_data from .test_client import deploy_service key = PrivateKey.generate() def test_get_rev_from_private(): runner = CliRunner() result = runner.invoke(cli, ['get-rev-addr', '--input-type', 'private', '--input', "1000000000000000000000000000000000000000000000000000000000000000"]) assert result.exit_code == 0 assert result.output == '1111cnoFDAa7GubxBMHpPLbbediPegnjSdZwNjxg9oqYvSvSmfqQL\n' def test_get_rev_from_pub(): runner = CliRunner() result = runner.invoke(cli, ['get-rev-addr', '--input-type', 'public', '--input', "0408ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945"]) assert result.exit_code == 0 assert result.output == '1111cnoFDAa7GubxBMHpPLbbediPegnjSdZwNjxg9oqYvSvSmfqQL\n'
# 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 .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)
#!/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)
# https://github.com/tgrospic/rnode-client-js/blob/master/src/nodejs/client-insert-signed.js # the logic below mostly copied from the logic of the link above from rchain.crypto import PrivateKey, blake2b_32 from rchain.client import RClient from rchain.pb.RhoTypes_pb2 import Par, Expr, ETuple, Bundle, GPrivate, GUnforgeable host = "localhost" port = 40402 deployKey = PrivateKey.generate() timestamp = 1559156356769 nonce = 9223372036854775807 publicKey = deployKey.get_public_key() with RClient(host, port) as client: ret = client.previewPrivateNames(publicKey, timestamp, 3) unforgeable = ret.payload.ids[0] print(unforgeable) dataToSign = Par(exprs=[ Expr(e_tuple_body=ETuple(ps=[ Par(exprs=[Expr(g_int=nonce)]), Par(bundles=[ Bundle(body=Par(unforgeables=[ GUnforgeable(g_private_body=GPrivate(id=unforgeable)) ]), writeFlag=True, readFlag=False) ]) ]))
from rchain.crypto import PrivateKey MAINNET_SERVER = ['node0.root-shard.mainnet.rchain.coop', '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'] admin_key = PrivateKey.generate() contract = "@1!(2)" exploratory_term = 'new return in{return!("a")}' block_hash = '4d135ce5773a05a782d1c52a7dfb42c4142b1a471bc3c57d77eee4d5affdef9a' find_deploy = '3045022100c4cdd5e8bb05b1627c2302ffd90393cf30ed0ad693ef63d46e5d8b99856a44c40220055b2dff342934b59b3fac5ac1f81c7b7763db9ee945809d86b04dbd48867bd4' # read-only node can not deploy with deploy request with RClient(READONLY_SERVER[0], 40401) as client: # get the latest 10 block in the rnode block_infos = client.show_blocks(depth=10) # get the detailed info in the rnode block = client.show_block(block_hash)
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',
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 make_peer( *, docker_client: DockerClient, network: str, name: str, bonds_file: str, command_timeout: int, bootstrap: Node, private_key: PrivateKey, allowed_peers: Optional[List[str]] = None, mem_limit: Optional[str] = None, wallets_file: Optional[str] = None, cli_flags: Optional[AbstractSet] = None, cli_options: Optional[Dict] = None, extra_volumes: Optional[List[str]] = None, synchrony_constraint_threshold: float = 0.0, max_peer_queue_size: int = 10, give_up_after_skipped: int = 0, drop_peer_after_retries: int = 0, number_of_active_validators: int = 10, epoch_length: int = 10000, quarantine_length: int = 50000 ) -> Node: assert isinstance(name, str) assert '_' not in name, 'Underscore is not allowed in host name' name = make_peer_name(network, name) bootstrap_address = bootstrap.get_rnode_address() container_command_flags = set([ "--prometheus", "--no-upnp", "--allow-private-addresses" ]) if cli_flags is not None: container_command_flags.update(cli_flags) container_command_options = { "--bootstrap": bootstrap_address, "--validator-private-key": private_key.to_hex(), "--validator-public-key": private_key.get_public_key().to_hex(), "--host": name, "--synchrony-constraint-threshold": synchrony_constraint_threshold, "--frrd-max-peer-queue-size": max_peer_queue_size, "--frrd-give-up-after-skipped": give_up_after_skipped, "--frrd-drop-peer-after-retries": drop_peer_after_retries, "--number-of-active-validators": number_of_active_validators, "--epoch-length": epoch_length, "--quarantine-length": quarantine_length } if cli_options is not None: container_command_options.update(cli_options) container = make_node( docker_client=docker_client, name=name, network=network, bonds_file=bonds_file, container_command='run', container_command_flags=container_command_flags, container_command_options=container_command_options, command_timeout=command_timeout, extra_volumes=extra_volumes, allowed_peers=allowed_peers, mem_limit=mem_limit if not None else '4G', wallets_file=wallets_file, ) return container