def test_generate_block():
signing_key, account_number = create_account()
encoded_account_number = encode_verify_key(verify_key=account_number)
transactions = [{
'amount': 1,
'fee': BANK,
'recipient': random_encoded_account_number(),
}, {
'amount': 1,
'fee': PRIMARY_VALIDATOR,
'recipient': random_encoded_account_number(),
}, {
'amount': 5,
'memo': 'Hello there I am 123 years old',
'recipient': random_encoded_account_number(),
}]
block = generate_block(account_number=account_number,
balance_lock=encoded_account_number,
signing_key=signing_key,
transactions=transactions)
assert block['account_number'] == encoded_account_number
assert block['message']['balance_key'] == encoded_account_number
assert len(block['message']['txs']) == 3
assert len(block['signature']) == SIGNATURE_LENGTH
def test_generate_block():
signing_key, account_number = create_account()
encoded_account_number = encode_verify_key(verify_key=account_number)
transactions = [{
'amount': 1,
'recipient': random_encoded_account_number(),
}, {
'amount': 1,
'recipient': random_encoded_account_number(),
}, {
'amount': 5,
'recipient': random_encoded_account_number(),
}]
block = generate_block(account_number=account_number,
balance_lock=encoded_account_number,
signing_key=signing_key,
transactions=transactions)
assert block['account_number'] == encoded_account_number
assert block['message']['balance_key'] == encoded_account_number
assert len(block['message']['txs']) == 3
assert len(block['signature']) == SIGNATURE_LENGTH
# Verify that signature is valid and the message has not been modified
verify_signature(message=sort_and_encode(block['message']),
signature=block['signature'],
verify_key=block['account_number'])
def test_generate_block():
signing_key, account_number = create_account()
encoded_account_number = encode_verify_key(verify_key=account_number)
transactions = [
{
'amount': 1,
'recipient': random_encoded_account_number(),
},
{
'amount': 1,
'recipient': random_encoded_account_number(),
},
{
'amount': 5,
'recipient': random_encoded_account_number(),
}
]
block = generate_block(
account_number=account_number,
balance_lock=encoded_account_number,
signing_key=signing_key,
transactions=transactions
)
assert block['account_number'] == encoded_account_number
assert block['message']['balance_key'] == encoded_account_number
assert len(block['message']['txs']) == 3
assert len(block['signature']) == SIGNATURE_LENGTH
def test_network_block_serializer():
signing_key, account_number = create_account()
encoded_account_number = encode_verify_key(verify_key=account_number)
transactions = [{
'amount': 1,
'fee': BANK,
'recipient': random_encoded_account_number(),
}, {
'amount': 1,
'fee': PRIMARY_VALIDATOR,
'recipient': random_encoded_account_number(),
}, {
'amount': 5,
'memo': 'Hello there I am 123 years old',
'recipient': random_encoded_account_number(),
}]
block = generate_block(account_number=account_number,
balance_lock=encoded_account_number,
signing_key=signing_key,
transactions=transactions)
serializer = NetworkBlockSerializer(data=block)
assert serializer.is_valid()
def bank_connection_requests_signed_request_new_node_identifier(bank):
signing_key, _ = create_account()
yield generate_signed_request(data={
'ip_address': bank.ip_address,
'port': bank.port,
'protocol': bank.protocol,
},
nid_signing_key=signing_key)
def create_account_and_save_signing_key_file(file):
"""
Create a new account and save signing key to file
Return signing_key, account_number
"""
signing_key, account_number = create_account()
write_signing_key_file(signing_key, file)
return signing_key, account_number
def validator_connection_requests_signed_request_connect_to_itself(
primary_validator_configuration):
signing_key, _ = create_account()
yield generate_signed_request(data={
'ip_address':
primary_validator_configuration.ip_address,
'port':
primary_validator_configuration.port,
'protocol':
primary_validator_configuration.protocol,
},
nid_signing_key=signing_key)
def block_data(account_data, encoded_account_number,
random_encoded_account_number):
signing_key, account_number = create_account()
yield generate_block(account_number=account_number,
balance_lock=encode_verify_key(
verify_key=account_number, ),
signing_key=signing_key,
transactions=[{
'amount':
1,
'recipient':
random_encoded_account_number
}])
def block_data(account_data, encoded_account_number, random_encoded_account_number):
signing_key, account_number = create_account()
yield generate_block(
account_number=account_number,
balance_lock=encode_verify_key(
verify_key=account_number,
),
signing_key=signing_key,
transactions=[
{
'amount': 4,
'fee': PRIMARY_VALIDATOR,
'recipient': 'ad1f8845c6a1abb6011a2a434a079a087c460657aad54329a84b406dce8bf314'
},
{
'amount': 1,
'recipient': random_encoded_account_number
}
]
)
def test_post(self):
"""
Create block
"""
signing_key, account_number = create_account()
encoded_account_number = encode_verify_key(verify_key=account_number)
Account.objects.create(account_number=encoded_account_number, trust=50)
self_configuration = get_self_configuration(
exception_class=RuntimeError)
primary_validator = self_configuration.primary_validator
block = generate_block(
account_number=account_number,
balance_lock=encoded_account_number,
signing_key=signing_key,
transactions=[{
'amount':
float(self_configuration.default_transaction_fee),
'recipient':
self_configuration.account_number
}, {
'amount':
float(primary_validator.default_transaction_fee),
'recipient':
primary_validator.account_number
}, {
'amount':
self.fake.pyfloat(min_value=1,
max_value=100,
positive=True,
right_digits=4),
'recipient':
random_account_number()
}])
self.validate_post('/blocks', block, status.HTTP_201_CREATED)
def account_data():
yield create_account()
def test_create_account():
signing_key, account_number = create_account()
assert isinstance(signing_key, SigningKey)
assert isinstance(account_number, VerifyKey)
def random_encoded_account_number():
_, account_number = create_account()
yield encode_verify_key(verify_key=account_number)
def test_write_signing_key_file(tmpdir):
file_path = tmpdir.join('signing_key_file')
signing_key, account_number = create_account()
write_signing_key_file(signing_key, file_path)
assert signing_key == read_signing_key_file(file_path)
def main():
ssm_client: SSMClient = boto3.client('ssm')
p = argparse.ArgumentParser(description='AWS provision and deploy.')
p.add_argument('--env',
default='prod',
type=str,
help='Environment to run, default is prod.')
p.add_argument(
'--s3-bucket',
required=True,
type=str,
help=
'* The name of the S3 bucket where this command uploads the artifacts that are referenced in '
'the template.')
p.add_argument('--db-pass',
type=str_length_validator(min_len=8),
help='Database password to set.')
p.add_argument('--sentry-dsn',
type=url_validator(),
help='DSN to set up Sentry tracking')
p.add_argument(
'--node-type',
choices=[CONFIRMATION_VALIDATOR, PRIMARY_VALIDATOR],
default=CONFIRMATION_VALIDATOR,
help=
'Network standardized type of node, default: CONFIRMATION_VALIDATOR.')
p.add_argument('--primary-url',
type=url_validator(),
help='Primary validator URL (ex. http://10.10.10.10).')
p.add_argument('--primary-trust',
type=int_validator(),
help='Trust level for the validator.')
p.add_argument('--sign-key',
type=str_length_validator(length=64),
help='Network sign key.')
p.add_argument('--node-identifier',
type=str_length_validator(length=VERIFY_KEY_LENGTH),
help='Public key used to sign requests to other nodes.')
p.add_argument('--account-number',
required=True,
type=str_length_validator(length=VERIFY_KEY_LENGTH),
help='* The account number where Tx fees will be sent.')
p.add_argument('--default-transaction-fee',
required=True,
type=int,
help='* Tx fee cost.')
p.add_argument(
'--seed-block-identifier',
type=str_length_validator(length=BLOCK_IDENTIFIER_LENGTH),
help=
'Identifier of the last block that was used when the root account file was generated.'
)
p.add_argument(
'--root-account-file',
required=True,
type=url_validator(suffix='.json'),
help=
'* Record of all account balances at the moment in time that the validator was first set to '
'"primary".')
p.add_argument('--version-number',
required=True,
type=str_length_validator(max_len=32),
help='* API version.')
args = p.parse_args()
if args.node_type == CONFIRMATION_VALIDATOR and not args.primary_url:
p.error(
'--primary-url is required when --node-type is CONFIRMATION_VALIDATOR.'
)
if args.node_type == CONFIRMATION_VALIDATOR and not args.primary_trust:
p.error(
'--primary-trust is required when --node-type is CONFIRMATION_VALIDATOR.'
)
db_pass = args.db_pass
if not db_pass:
db_pass = token_urlsafe(32)
private_key, public_key = create_account()
private_key = private_key.encode(encoder=HexEncoder).decode('utf-8')
public_key = public_key.encode(encoder=HexEncoder).decode('utf-8')
deploy_args = [
f'ParameterKey=EnvironmentName,ParameterValue={args.env.capitalize()}',
f'ParameterKey=MasterUserPassword,ParameterValue={db_pass}',
f'ParameterKey=NetworkSigningKey,ParameterValue={args.sign_key or private_key}',
f'ParameterKey=NodeType,ParameterValue={args.node_type}',
f'ParameterKey=NodeIdentifier,ParameterValue={args.node_identifier or public_key}',
f'ParameterKey=AccountNumber,ParameterValue={args.account_number}',
f'ParameterKey=DefaultTransactionFee,ParameterValue={args.default_transaction_fee}',
f'ParameterKey=RootAccountFile,ParameterValue={args.root_account_file}',
f'ParameterKey=VersionNumber,ParameterValue={args.version_number}',
]
if args.seed_block_identifier:
deploy_args.append(
f'ParameterKey=SeedBlockIdentifier,ParameterValue={args.seed_block_identifier}'
)
if args.node_type == CONFIRMATION_VALIDATOR:
primary = urlparse(args.primary_url)
deploy_args.extend([
f'ParameterKey=PrimaryIp,ParameterValue={primary.hostname}',
f'ParameterKey=PrimaryProto,ParameterValue={primary.scheme}',
f'ParameterKey=PrimaryPort,ParameterValue={primary.port or 80}',
f'ParameterKey=PrimaryTrust,ParameterValue={args.primary_trust}'
])
if args.sentry_dsn:
deploy_args.append(
f'ParameterKey=DjangoSentryDSN,ParameterValue={args.sentry_dsn}')
try:
secret_key = ssm_client.get_parameter(
Name=
f'{args.env.capitalize()}ValidatorDjangoSecretKey{args.node_type}'
)['Parameter']['Value']
print(secret_key)
except (ssm_client.exceptions.ParameterNotFound,
ssm_client.exceptions.InvalidKeyId):
secret_key = get_random_secret_key()
deploy_args.append(
f'ParameterKey=DjangoSecretKey,ParameterValue={secret_key}')
subprocess.call([
'sam', 'package', '--template-file', 'stack/env.cfn.yaml',
'--s3-bucket', args.s3_bucket, '--output-template-file',
'outputtemplate.yaml'
])
subprocess.call([
'sam', 'deploy', '--stack-name',
f'{args.env.capitalize()}Validator{args.node_type}'.replace('_', '-'),
'--template-file', 'outputtemplate.yaml', '--parameter-overrides',
' '.join(deploy_args), '--capabilities', 'CAPABILITY_AUTO_EXPAND',
'CAPABILITY_NAMED_IAM'
])
#!/usr/bin/env python
"""Generate account keys"""
from nacl.encoding import HexEncoder
from thenewboston.accounts.manage import create_account
private_key, public_key = create_account()
private_key = private_key.encode(encoder=HexEncoder).decode('utf-8')
public_key = public_key.encode(encoder=HexEncoder).decode('utf-8')
def random_encoded_account_number():
signing_key, account_number = create_account()
return encode_verify_key(verify_key=account_number)
