def test_verify_unsealing_data(self):
signup_info = \
SignupInfo.create_signup_info(
originator_public_key_hash=self._originator_public_key_hash,
most_recent_wait_certificate_id=NullIdentifier)
poet_public_key = \
SignupInfo.unseal_signup_data(signup_info.sealed_signup_data)
self.assertEqual(
signup_info.poet_public_key,
poet_public_key,
msg="PoET public key in signup info and sealed data don't match")
def test_verify_unsealing_data(self):
signup_info = \
SignupInfo.create_signup_info(
validator_address='1660 Pennsylvania Avenue NW',
originator_public_key_hash=self._originator_public_key_hash,
most_recent_wait_certificate_id=NullIdentifier)
poet_public_key = \
SignupInfo.unseal_signup_data(
validator_address='1660 Pennsylvania Avenue NW',
sealed_signup_data=signup_info.sealed_signup_data)
self.assertEqual(
signup_info.poet_public_key,
poet_public_key,
msg="PoET public key in signup info and sealed data don't match")
def _on_journal_initialization_complete(self, journal):
"""
Callback journal makes after the journal has completed initialization
Args:
journal (Journal): The journal object that has completed
initialization.
Returns:
True
"""
# If we have sealed signup data (meaning that we have previously
# created signup info), we can request that the enclave unseal it,
# in the process restoring the enclave to its previous state. If
# we don't have sealed signup data, we need to create and register it.
#
# Note - this MUST be done AFTER the journal has completed
# initialization so that there is at least one peer node to which
# we can send the validator registry transaction to. Otherwise,
# we will never, ever be able to be added to the validator registry
# and, to paraphrase Martha Stewart, that is a bad thing.
sealed_signup_data = journal.local_store.get('sealed_signup_data')
if sealed_signup_data is not None:
self.poet_public_key = \
SignupInfo.unseal_signup_data(
validator_address=journal.local_node.signing_address(),
sealed_signup_data=sealed_signup_data)
LOGGER.info(
'Restore signup info for %s (ID = %s, PoET public key = %s)',
journal.local_node.Name,
journal.local_node.Identifier,
self.poet_public_key)
else:
self.register_signup_information(journal)
return True
def _on_journal_initialization_complete(self, journal):
"""
Callback journal makes after the journal has completed initialization
Args:
journal (Journal): The journal object that has completed
initialization.
Returns:
True
"""
# If we have sealed signup data (meaning that we have previously
# created signup info), we can request that the enclave unseal it,
# in the process restoring the enclave to its previous state. If
# we don't have sealed signup data. If we don't have sealed signup
# data, we need to create and register it.
#
# Note - this MUST be done AFTER the journal has completed
# initialization so that there is at least one peer node to which
# we can send the validator registry transaction to. Otherwise,
# we will never, ever be able to be added to the validator registry
# and, to paraphrase Martha Stewart, that is a bad thing.
sealed_signup_data = journal.local_store.get('sealed_signup_data')
if sealed_signup_data is not None:
self.poet_public_key = \
SignupInfo.unseal_signup_data(
validator_address=journal.local_node.signing_address(),
sealed_signup_data=sealed_signup_data)
LOGGER.info(
'Restore signup info for %s (ID = %s, PoET public key = %s)',
journal.local_node.Name, journal.local_node.Identifier,
self.poet_public_key)
else:
self.register_signup_information(journal)
return True
def initialization_complete(self, journal):
"""Processes all invocations that arrived while the ledger was
being initialized.
"""
# Before we allow the base journal to do anything that might result
# in a wait timer or wait certificate being created, we have to ensure
# the PoET enclave has been initialized. This can be done in one of
# two ways:
# 1. If we have sealed signup data (meaning that we have previously
# created signup info), we can request that the enclave unseal it,
# in the process restoring the enclave to its previous state.
# 2. Create new signup information.
signup_info = None
sealed_signup_data = journal.local_store.get('sealed_signup_data')
if sealed_signup_data is not None:
self.poet_public_key = SignupInfo.unseal_signup_data(
sealed_signup_data=sealed_signup_data)
else:
wait_certificate_id = journal.most_recent_committed_block_id
public_key_hash = \
hashlib.sha256(
pybitcointools.encode_pubkey(
journal.local_node.public_key(),
'hex')).hexdigest()
signup_info = \
SignupInfo.create_signup_info(
originator_public_key_hash=public_key_hash,
most_recent_wait_certificate_id=wait_certificate_id)
# Save off the sealed signup data
journal.local_store.set('sealed_signup_data',
signup_info.sealed_signup_data)
journal.local_store.sync()
self.poet_public_key = signup_info.poet_public_key
# propagate the maximum blocks to keep
journal.maximum_blocks_to_keep = max(
journal.maximum_blocks_to_keep,
WaitTimer.certificate_sample_length)
# initialize stats specifically for the block chain journal
journal.JournalStats.add_metric(stats.Value('LocalMeanTime', 0))
journal.JournalStats.add_metric(stats.Value('AggregateLocalMean', 0))
journal.JournalStats.add_metric(stats.Value('PopulationEstimate', 0))
journal.JournalStats.add_metric(
stats.Value('ExpectedExpirationTime', 0))
journal.JournalStats.add_metric(stats.Value('Duration', 0))
# initialize the block handlers
poet_transaction_block.register_message_handlers(journal)
# If we created signup information, then advertise self to network
if signup_info is not None:
# Create a validator register transaction and sign it. Wrap
# the transaction in a message. Broadcast it to out.
transaction = \
val_reg.ValidatorRegistryTransaction.register_validator(
journal.local_node.Name,
journal.local_node.Identifier,
signup_info)
transaction.sign_from_node(journal.local_node)
message = \
val_reg.ValidatorRegistryTransactionMessage()
message.Transaction = transaction
LOGGER.info('Advertise PoET 1 validator with name %s',
journal.local_node.Name)
journal.gossip.broadcast_message(message)
def test_create_wait_timer(self):
# Need to create signup information first
signup_info = \
SignupInfo.create_signup_info(
validator_address='1060 W Addison Street',
originator_public_key_hash=self._originator_public_key_hash,
most_recent_wait_certificate_id=NullIdentifier)
stake_in_the_sand = time.time()
# An empty certificate list should result in a local mean that is
# the target wait time
wt = wait_timer.WaitTimer.create_wait_timer(
validator_address='1060 W Addison Street', certificates=[])
self.assertIsNotNone(wt)
self.assertEqual(wt.local_mean, wait_timer.WaitTimer.target_wait_time)
self.assertEqual(wt.previous_certificate_id, NullIdentifier)
self.assertGreaterEqual(wt.request_time, stake_in_the_sand)
self.assertLessEqual(wt.request_time, time.time())
self.assertGreaterEqual(wt.duration,
wait_timer.WaitTimer.minimum_wait_time)
self.assertEqual(wt.validator_address, '1060 W Addison Street')
wt = wait_timer.WaitTimer.create_wait_timer(
validator_address='1060 W Addison Street', certificates=tuple())
self.assertIsNotNone(wt)
self.assertEqual(wt.local_mean, wait_timer.WaitTimer.target_wait_time)
self.assertEqual(wt.previous_certificate_id, NullIdentifier)
self.assertGreaterEqual(wt.request_time, stake_in_the_sand)
self.assertLessEqual(wt.request_time, time.time())
self.assertGreaterEqual(wt.duration,
wait_timer.WaitTimer.minimum_wait_time)
self.assertEqual(wt.validator_address, '1060 W Addison Street')
# Ensure that the enclave is set back to initial state
SignupInfo.poet_enclave = reload(poet_enclave)
wait_timer.WaitTimer.poet_enclave = SignupInfo.poet_enclave
# Make sure that trying to create a wait timer before signup
# information is provided causes an error
with self.assertRaises(ValueError):
wait_timer.WaitTimer.create_wait_timer(
validator_address='1060 W Addison Street', certificates=[])
with self.assertRaises(ValueError):
wait_timer.WaitTimer.create_wait_timer(
validator_address='1060 W Addison Street',
certificates=tuple())
# Initialize the enclave with sealed signup data
SignupInfo.unseal_signup_data(
validator_address='1660 Pennsylvania Avenue NW',
sealed_signup_data=signup_info.sealed_signup_data)
stake_in_the_sand = time.time()
# An empty certificate list should result in a local mean that is
# the target wait time
wt = wait_timer.WaitTimer.create_wait_timer(
validator_address='1060 W Addison Street', certificates=[])
self.assertIsNotNone(wt)
self.assertEqual(wt.local_mean, wait_timer.WaitTimer.target_wait_time)
self.assertEqual(wt.previous_certificate_id, NullIdentifier)
self.assertGreaterEqual(wt.request_time, stake_in_the_sand)
self.assertLessEqual(wt.request_time, time.time())
self.assertGreaterEqual(wt.duration,
wait_timer.WaitTimer.minimum_wait_time)
self.assertEqual(wt.validator_address, '1060 W Addison Street')
wt = wait_timer.WaitTimer.create_wait_timer(
validator_address='1600 Pennsylvania Avenue NW',
certificates=tuple())
self.assertIsNotNone(wt)
self.assertEqual(wt.local_mean, wait_timer.WaitTimer.target_wait_time)
self.assertEqual(wt.previous_certificate_id, NullIdentifier)
self.assertGreaterEqual(wt.request_time, stake_in_the_sand)
self.assertLessEqual(wt.request_time, time.time())
self.assertGreaterEqual(wt.duration,
wait_timer.WaitTimer.minimum_wait_time)
self.assertEqual(wt.validator_address, '1600 Pennsylvania Avenue NW')
def test_create_wait_timer(self):
# Need to create signup information first
signup_info = \
SignupInfo.create_signup_info(
validator_address='1060 W Addison Street',
originator_public_key_hash=self._originator_public_key_hash,
most_recent_wait_certificate_id=NullIdentifier)
stake_in_the_sand = time.time()
# An empty certificate list should result in a local mean that is
# the target wait time
wt = wait_timer.WaitTimer.create_wait_timer(
validator_address='1060 W Addison Street',
certificates=[])
self.assertIsNotNone(wt)
self.assertEqual(wt.local_mean, wait_timer.WaitTimer.target_wait_time)
self.assertEqual(wt.previous_certificate_id, NullIdentifier)
self.assertGreaterEqual(wt.request_time, stake_in_the_sand)
self.assertLessEqual(wt.request_time, time.time())
self.assertGreaterEqual(
wt.duration,
wait_timer.WaitTimer.minimum_wait_time)
self.assertEqual(wt.validator_address, '1060 W Addison Street')
wt = wait_timer.WaitTimer.create_wait_timer(
validator_address='1060 W Addison Street',
certificates=tuple())
self.assertIsNotNone(wt)
self.assertEqual(wt.local_mean, wait_timer.WaitTimer.target_wait_time)
self.assertEqual(wt.previous_certificate_id, NullIdentifier)
self.assertGreaterEqual(wt.request_time, stake_in_the_sand)
self.assertLessEqual(wt.request_time, time.time())
self.assertGreaterEqual(
wt.duration,
wait_timer.WaitTimer.minimum_wait_time)
self.assertEqual(wt.validator_address, '1060 W Addison Street')
# Ensure that the enclave is set back to initial state
SignupInfo.poet_enclave = reload(poet_enclave)
wait_timer.WaitTimer.poet_enclave = SignupInfo.poet_enclave
# Make sure that trying to create a wait timer before signup
# information is provided causes an error
with self.assertRaises(ValueError):
wait_timer.WaitTimer.create_wait_timer(
validator_address='1060 W Addison Street',
certificates=[])
with self.assertRaises(ValueError):
wait_timer.WaitTimer.create_wait_timer(
validator_address='1060 W Addison Street',
certificates=tuple())
# Initialize the enclave with sealed signup data
SignupInfo.unseal_signup_data(
validator_address='1660 Pennsylvania Avenue NW',
sealed_signup_data=signup_info.sealed_signup_data)
stake_in_the_sand = time.time()
# An empty certificate list should result in a local mean that is
# the target wait time
wt = wait_timer.WaitTimer.create_wait_timer(
validator_address='1060 W Addison Street',
certificates=[])
self.assertIsNotNone(wt)
self.assertEqual(wt.local_mean, wait_timer.WaitTimer.target_wait_time)
self.assertEqual(wt.previous_certificate_id, NullIdentifier)
self.assertGreaterEqual(wt.request_time, stake_in_the_sand)
self.assertLessEqual(wt.request_time, time.time())
self.assertGreaterEqual(
wt.duration,
wait_timer.WaitTimer.minimum_wait_time)
self.assertEqual(wt.validator_address, '1060 W Addison Street')
wt = wait_timer.WaitTimer.create_wait_timer(
validator_address='1600 Pennsylvania Avenue NW',
certificates=tuple())
self.assertIsNotNone(wt)
self.assertEqual(wt.local_mean, wait_timer.WaitTimer.target_wait_time)
self.assertEqual(wt.previous_certificate_id, NullIdentifier)
self.assertGreaterEqual(wt.request_time, stake_in_the_sand)
self.assertLessEqual(wt.request_time, time.time())
self.assertGreaterEqual(
wt.duration,
wait_timer.WaitTimer.minimum_wait_time)
self.assertEqual(wt.validator_address, '1600 Pennsylvania Avenue NW')
