def test_create(self):
addr = random_name(34)
signup_info = poet.create_signup_info(
originator_public_key_hash=self._originator_public_key_hash,
nonce=poet.NULL_IDENTIFIER)
sealed_data = signup_info.sealed_signup_data
previous_cert_id = poet.NULL_IDENTIFIER
wait_timer = poet.create_wait_timer(sealed_data, addr,
previous_cert_id, 100)
self.assertEqual(wait_timer.previous_certificate_id, previous_cert_id)
self.assertEqual(wait_timer.local_mean, 100)
# Random previous cert id
previous_cert_id = random_name(poet.IDENTIFIER_LENGTH)
# Invalid types for validator address
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, [], previous_cert_id, 100)
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, {}, previous_cert_id, 100)
with self.assertRaises(ValueError):
poet.create_wait_timer(sealed_data, None, previous_cert_id, 100)
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, 8888, previous_cert_id, 100)
# Bad local means
with self.assertRaises(ValueError):
poet.create_wait_timer(sealed_data, addr, previous_cert_id, -1)
with self.assertRaises(ValueError):
poet.create_wait_timer(sealed_data, addr, previous_cert_id, 0)
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, addr, previous_cert_id, [])
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, addr, previous_cert_id, None)
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, addr, previous_cert_id, "3")
# Invalid types for previous certificate
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, addr, [], 0)
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, addr, {}, 0)
with self.assertRaises(ValueError):
poet.create_wait_timer(sealed_data, addr, None, 0)
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, addr, 8888, 0)
previous_cert_id = "" # to short
with self.assertRaises(ValueError):
poet.create_wait_timer(sealed_data, addr, previous_cert_id, 100)
previous_cert_id = random_name(8) # to short
with self.assertRaises(ValueError):
poet.create_wait_timer(sealed_data, addr, previous_cert_id, 100)
previous_cert_id = random_name(17) # to long
with self.assertRaises(ValueError):
poet.create_wait_timer(sealed_data, addr, previous_cert_id, 100)
def test_create(self):
addr = random_name(34)
_ = \
poet.create_signup_info(
originator_public_key_hash=self._originator_public_key_hash,
nonce=poet.NULL_IDENTIFIER)
block_hash = random_name(32)
# with expired timer -- positive case
wait_timer = self.get_wait_timer(addr=addr)
wait_cert = \
poet.create_wait_certificate(
wait_timer,
block_hash)
self.assertEqual(wait_timer.duration, wait_cert.duration)
self.assertEqual(wait_timer.local_mean, wait_cert.local_mean)
self.assertEqual(wait_timer.previous_certificate_id,
wait_cert.previous_certificate_id)
self.assertEqual(len(wait_cert.identifier()),
poet.IDENTIFIER_LENGTH)
# the initial block does not need to wait, to accelerate
# validator launch
wait_timer = poet.create_wait_timer(addr, poet.NULL_IDENTIFIER, 1)
wait_cert = \
poet.create_wait_certificate(
wait_timer,
block_hash)
self.assertEqual(wait_timer.duration, wait_cert.duration)
self.assertEqual(wait_timer.local_mean, wait_cert.local_mean)
self.assertEqual(wait_timer.previous_certificate_id,
wait_cert.previous_certificate_id)
def test_create(self):
addr = random_name(34)
signup_info = poet.create_signup_info(
originator_public_key_hash=self._originator_public_key_hash,
nonce=poet.NULL_IDENTIFIER)
sealed_data = signup_info.sealed_signup_data
previous_cert_id = poet.NULL_IDENTIFIER
wait_timer = poet.create_wait_timer(
sealed_data, addr, previous_cert_id, 100)
self.assertEqual(wait_timer.previous_certificate_id, previous_cert_id)
self.assertEqual(wait_timer.local_mean, 100)
# Random previous cert id
previous_cert_id = random_name(poet.IDENTIFIER_LENGTH)
# Invalid types for validator address
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, [], previous_cert_id, 100)
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, {}, previous_cert_id, 100)
with self.assertRaises(ValueError):
poet.create_wait_timer(sealed_data, None, previous_cert_id, 100)
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, 8888, previous_cert_id, 100)
# Bad local means
with self.assertRaises(ValueError):
poet.create_wait_timer(sealed_data, addr, previous_cert_id, -1)
with self.assertRaises(ValueError):
poet.create_wait_timer(sealed_data, addr, previous_cert_id, 0)
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, addr, previous_cert_id, [])
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, addr, previous_cert_id, None)
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, addr, previous_cert_id, "3")
# Invalid types for previous certificate
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, addr, [], 0)
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, addr, {}, 0)
with self.assertRaises(ValueError):
poet.create_wait_timer(sealed_data, addr, None, 0)
with self.assertRaises(TypeError):
poet.create_wait_timer(sealed_data, addr, 8888, 0)
previous_cert_id = "" # to short
with self.assertRaises(ValueError):
poet.create_wait_timer(sealed_data, addr, previous_cert_id, 100)
previous_cert_id = random_name(8) # to short
with self.assertRaises(ValueError):
poet.create_wait_timer(sealed_data, addr, previous_cert_id, 100)
previous_cert_id = random_name(17) # to long
with self.assertRaises(ValueError):
poet.create_wait_timer(sealed_data, addr, previous_cert_id, 100)
def test_create(self):
addr = random_name(34)
_ = \
poet.create_signup_info(
originator_public_key_hash=self._originator_public_key_hash,
nonce=poet.NULL_IDENTIFIER)
block_hash = random_name(32)
# with expired timer -- positive case
wait_timer = self.get_wait_timer(addr=addr)
wait_cert = \
poet.create_wait_certificate(
wait_timer,
block_hash)
self.assertEqual(wait_timer.duration, wait_cert.duration)
self.assertEqual(wait_timer.local_mean, wait_cert.local_mean)
self.assertEqual(wait_timer.previous_certificate_id,
wait_cert.previous_certificate_id)
self.assertEqual(len(wait_cert.identifier()), poet.IDENTIFIER_LENGTH)
# the initial block does not need to wait, to accelerate
# validator launch
wait_timer = poet.create_wait_timer(addr, poet.NULL_IDENTIFIER, 1)
wait_cert = \
poet.create_wait_certificate(
wait_timer,
block_hash)
self.assertEqual(wait_timer.duration, wait_cert.duration)
self.assertEqual(wait_timer.local_mean, wait_cert.local_mean)
self.assertEqual(wait_timer.previous_certificate_id,
wait_cert.previous_certificate_id)
def get_wait_timer(self, sealed_data, addr=None):
pid = random_name(poet.IDENTIFIER_LENGTH)
if addr is None:
addr = random_name(34)
# super short local mean to get small duration..
wait_timer = poet.create_wait_timer(sealed_data, addr, pid, 1)
while not wait_timer.has_expired():
time.sleep(1)
return wait_timer
def test_create_out_of_seq(self):
addr = random_name(34)
poet.create_signup_info(
originator_public_key_hash=self._originator_public_key_hash,
nonce=poet.NULL_IDENTIFIER)
block_hash = random_name(32)
# use expired wait timers out of order
wait_timer = self.get_wait_timer(addr)
_ = self.get_wait_timer(addr)
with self.assertRaises(ValueError):
_ = poet.create_wait_certificate(wait_timer, block_hash)
def test_create_out_of_seq(self):
addr = random_name(34)
poet.create_signup_info(
originator_public_key_hash=self._originator_public_key_hash,
nonce=poet.NULL_IDENTIFIER)
block_hash = random_name(32)
# use expired wait timers out of order
wait_timer = self.get_wait_timer(addr)
_ = self.get_wait_timer(addr)
with self.assertRaises(ValueError):
_ = poet.create_wait_certificate(wait_timer, block_hash)
def test_serialize(self):
addr = random_name(34)
signup_info = poet.create_signup_info(
originator_public_key_hash=self._originator_public_key_hash,
nonce=poet.NULL_IDENTIFIER)
sealed_data = signup_info.sealed_signup_data
wait_cert = self.get_wait_cert(sealed_data, addr=addr)
serialized_wait_cert = wait_cert.serialize()
wait_cert2 = poet.deserialize_wait_certificate(
serialized_wait_cert,
wait_cert.signature)
self.assertAlmostEqual(wait_cert.duration, wait_cert2.duration)
self.assertEqual(wait_cert.local_mean, wait_cert2.local_mean)
self.assertEqual(wait_cert.request_time, wait_cert2.request_time)
self.assertEqual(wait_cert.nonce, wait_cert2.nonce)
self.assertEqual(wait_cert.previous_certificate_id,
wait_cert2.previous_certificate_id)
self.assertEqual(wait_cert.signature, wait_cert2.signature)
self.assertEqual(wait_cert.identifier(), wait_cert2.identifier())
# Bad Serial strings
with self.assertRaises(ValueError):
poet.deserialize_wait_certificate(None, wait_cert.signature)
with self.assertRaises(TypeError):
poet.deserialize_wait_certificate([], wait_cert.signature)
with self.assertRaises(TypeError):
poet.deserialize_wait_certificate(8, wait_cert.signature)
with self.assertRaises(ValueError):
poet.deserialize_wait_certificate(
random_name(len(serialized_wait_cert)),
wait_cert.signature)
with self.assertRaises(ValueError):
poet.deserialize_wait_certificate("{}", wait_cert.signature)
with self.assertRaises(ValueError):
poet.deserialize_wait_certificate(
serialized_wait_cert[:int(len(serialized_wait_cert) / 2)],
wait_cert.signature)
# Bad signature strings
with self.assertRaises(ValueError):
poet.deserialize_wait_certificate(serialized_wait_cert, None)
with self.assertRaises(TypeError):
poet.deserialize_wait_certificate(serialized_wait_cert, [])
with self.assertRaises(TypeError):
poet.deserialize_wait_certificate(serialized_wait_cert, 7)
with self.assertRaises(TypeError):
poet.deserialize_wait_certificate(8, wait_cert.signature)
def test_serialize(self):
addr = random_name(34)
signup_info = poet.create_signup_info(
originator_public_key_hash=self._originator_public_key_hash,
nonce=poet.NULL_IDENTIFIER)
sealed_data = signup_info.sealed_signup_data
previous_cert_id = poet.NULL_IDENTIFIER
wait_timer = poet.create_wait_timer(
sealed_data, addr, previous_cert_id, 5)
serialized_wait_timer = wait_timer.serialize()
wait_timer2 = poet.deserialize_wait_timer(
serialized_wait_timer,
wait_timer.signature)
self.assertAlmostEqual(wait_timer.duration, wait_timer2.duration)
self.assertEqual(wait_timer.request_time, wait_timer2.request_time)
self.assertEqual(wait_timer.previous_certificate_id,
wait_timer2.previous_certificate_id)
self.assertEqual(wait_timer.signature, wait_timer2.signature)
# Bad serialized strings
with self.assertRaises(TypeError):
poet.deserialize_wait_timer([], wait_timer.signature)
with self.assertRaises(TypeError):
poet.deserialize_wait_timer({}, wait_timer.signature)
with self.assertRaises(ValueError):
poet.deserialize_wait_timer(None, wait_timer.signature)
with self.assertRaises(TypeError):
poet.deserialize_wait_timer(8, wait_timer.signature)
with self.assertRaises(ValueError):
poet.deserialize_wait_timer(
random_name(len(serialized_wait_timer)),
wait_timer.signature)
with self.assertRaises(ValueError):
poet.deserialize_wait_timer(
serialized_wait_timer[:int(len(serialized_wait_timer) / 2)],
wait_timer.signature)
# Bad signatures
with self.assertRaises(TypeError):
poet.deserialize_wait_timer(serialized_wait_timer, [])
with self.assertRaises(TypeError):
poet.deserialize_wait_timer(serialized_wait_timer, {})
with self.assertRaises(ValueError):
poet.deserialize_wait_timer(serialized_wait_timer, None)
with self.assertRaises(TypeError):
poet.deserialize_wait_timer(serialized_wait_timer, 7)
def test_serialize(self):
addr = random_name(34)
signup_info = poet.create_signup_info(
originator_public_key_hash=self._originator_public_key_hash,
nonce=poet.NULL_IDENTIFIER)
sealed_data = signup_info.sealed_signup_data
previous_cert_id = poet.NULL_IDENTIFIER
wait_timer = poet.create_wait_timer(
sealed_data, addr, previous_cert_id, 5)
serialized_wait_timer = wait_timer.serialize()
wait_timer2 = poet.deserialize_wait_timer(
serialized_wait_timer,
wait_timer.signature)
self.assertAlmostEqual(wait_timer.duration, wait_timer2.duration)
self.assertEqual(wait_timer.request_time, wait_timer2.request_time)
self.assertEqual(wait_timer.previous_certificate_id,
wait_timer2.previous_certificate_id)
self.assertEqual(wait_timer.signature, wait_timer2.signature)
# Bad serialized strings
with self.assertRaises(TypeError):
poet.deserialize_wait_timer([], wait_timer.signature)
with self.assertRaises(TypeError):
poet.deserialize_wait_timer({}, wait_timer.signature)
with self.assertRaises(ValueError):
poet.deserialize_wait_timer(None, wait_timer.signature)
with self.assertRaises(TypeError):
poet.deserialize_wait_timer(8, wait_timer.signature)
with self.assertRaises(ValueError):
poet.deserialize_wait_timer(
random_name(len(serialized_wait_timer)),
wait_timer.signature)
with self.assertRaises(ValueError):
poet.deserialize_wait_timer(
serialized_wait_timer[:int(len(serialized_wait_timer) / 2)],
wait_timer.signature)
# Bad signatures
with self.assertRaises(TypeError):
poet.deserialize_wait_timer(serialized_wait_timer, [])
with self.assertRaises(TypeError):
poet.deserialize_wait_timer(serialized_wait_timer, {})
with self.assertRaises(ValueError):
poet.deserialize_wait_timer(serialized_wait_timer, None)
with self.assertRaises(TypeError):
poet.deserialize_wait_timer(serialized_wait_timer, 7)
def test_before_creating_signup_info(self):
# If we have not created signup information, an exception should be
# thrown if we try to create a wait timer.
with self.assertRaises(ValueError):
addr = random_name(34)
previous_cert_id = poet.NULL_IDENTIFIER
poet.create_wait_timer(addr, previous_cert_id, 100)
def test_before_creating_signup_info(self):
# If we have not created signup information, an exception should be
# thrown if we try to create a wait timer.
with self.assertRaises(ValueError):
addr = random_name(34)
previous_cert_id = poet.NULL_IDENTIFIER
poet.create_wait_timer(None, addr, previous_cert_id, 100)
def get_wait_cert(self, addr=None):
block_hash = random_name(32)
wait_timer = self.get_wait_timer(addr=addr)
return \
poet.create_wait_certificate(
wait_timer,
block_hash)
def get_wait_cert(self, addr=None):
block_hash = random_name(32)
wait_timer = self.get_wait_timer(addr=addr)
return \
poet.create_wait_certificate(
wait_timer,
block_hash)
def test_verify(self):
addr = random_name(34)
signup_info = \
poet.create_signup_info(
originator_public_key_hash=self._originator_public_key_hash,
nonce=poet.NULL_IDENTIFIER)
sealed_data = signup_info.sealed_signup_data
wait_cert = self.get_wait_cert(sealed_data, addr=addr)
poet.verify_wait_certificate(
wait_cert,
signup_info.poet_public_key)
# Bad wait certificate types
with self.assertRaises(TypeError):
poet.verify_wait_certificate([], signup_info.poet_public_key)
with self.assertRaises(TypeError):
poet.verify_wait_certificate({}, signup_info.poet_public_key)
with self.assertRaises(ValueError):
poet.verify_wait_certificate(None, signup_info.poet_public_key)
with self.assertRaises(TypeError):
poet.verify_wait_certificate("3", signup_info.poet_public_key)
with self.assertRaises(TypeError):
poet.verify_wait_certificate(3, signup_info.poet_public_key)
# Bad public key types
with self.assertRaises(TypeError):
poet.verify_wait_certificate(wait_cert, [])
with self.assertRaises(TypeError):
poet.verify_wait_certificate(wait_cert, {})
with self.assertRaises(ValueError):
poet.verify_wait_certificate(wait_cert, None)
with self.assertRaises(TypeError):
poet.verify_wait_certificate(wait_cert, 3)
# A different public key
other_signup_info = \
poet.create_signup_info(
originator_public_key_hash=create_random_public_key_hash(),
nonce=poet.NULL_IDENTIFIER)
with self.assertRaises(ValueError):
poet.verify_wait_certificate(
wait_cert,
other_signup_info.poet_public_key)
def test_is_expired(self):
addr = random_name(34)
poet.create_signup_info(
originator_public_key_hash=self._originator_public_key_hash,
nonce=poet.NULL_IDENTIFIER)
previous_cert_id = poet.NULL_IDENTIFIER
start = time.time()
wait_timer = poet.create_wait_timer(addr, previous_cert_id, 5)
while not wait_timer.has_expired():
time.sleep(1)
end = time.time()
self.assertLessEqual(wait_timer.duration, end - start)
def test_is_expired(self):
addr = random_name(34)
poet.create_signup_info(
originator_public_key_hash=self._originator_public_key_hash,
nonce=poet.NULL_IDENTIFIER)
previous_cert_id = poet.NULL_IDENTIFIER
start = time.time()
wait_timer = poet.create_wait_timer(addr, previous_cert_id, 5)
while not wait_timer.has_expired():
time.sleep(1)
end = time.time()
self.assertLessEqual(wait_timer.duration, end - start)
def test_create(self):
addr = random_name(34)
signup_info = poet.create_signup_info(
originator_public_key_hash=self._originator_public_key_hash,
nonce=poet.NULL_IDENTIFIER)
sealed_data = signup_info.sealed_signup_data
block_hash = random_name(32)
# with expired timer -- positive case
wait_timer = self.get_wait_timer(sealed_data, addr=addr)
wait_cert = poet.create_wait_certificate(
sealed_data, wait_timer, block_hash)
self.assertEqual(wait_timer.duration, wait_cert.duration)
self.assertEqual(wait_timer.local_mean, wait_cert.local_mean)
self.assertNotEqual(wait_cert.nonce, '')
self.assertEqual(wait_timer.previous_certificate_id,
wait_cert.previous_certificate_id)
self.assertEqual(len(wait_cert.identifier()),
poet.IDENTIFIER_LENGTH)
# We should not be able to create another wait certificate with the
# same wait timer.
with self.assertRaises(ValueError):
poet.create_wait_certificate(sealed_data, wait_timer, block_hash)
# When we create a new wait timer, it should not be possible to use
# another, otherwise valid, wait timer to create a wait certificate.
wait_timer = self.get_wait_timer(sealed_data, addr=addr)
poet.create_wait_timer(sealed_data, addr, poet.NULL_IDENTIFIER, 1)
with self.assertRaises(ValueError):
poet.create_wait_certificate(sealed_data, wait_timer, block_hash)
# the initial block does not need to wait, to accelerate
# validator launch
wait_timer = poet.create_wait_timer(
sealed_data, addr, poet.NULL_IDENTIFIER, 1)
wait_cert = poet.create_wait_certificate(
sealed_data, wait_timer, block_hash)
self.assertEqual(wait_timer.duration, wait_cert.duration)
self.assertEqual(wait_timer.local_mean, wait_cert.local_mean)
self.assertEqual(wait_timer.previous_certificate_id,
wait_cert.previous_certificate_id)
# with unexpired timer
wait_timer = \
poet.create_wait_timer(
sealed_data, addr, random_name(poet.IDENTIFIER_LENGTH), 10)
with self.assertRaises(ValueError):
poet.create_wait_certificate(sealed_data, wait_timer, block_hash)
# With timed out timer
wait_timer = self.get_wait_timer(sealed_data, addr=addr)
time.sleep(10)
with self.assertRaises(ValueError):
wait_cert = poet.create_wait_certificate(
sealed_data, wait_timer, block_hash)
# verify that new wait certificate gets a different nonce. In reality
# we should test a statistically significant number of wait
# certificates to verify that each gets a unique nonce, but we have to
# wait for wait timers to expire and we want the test to finish
# sometime this century.
wait_timer = self.get_wait_timer(sealed_data, addr=addr)
wait_cert2 = poet.create_wait_certificate(
sealed_data, wait_timer, block_hash)
self.assertNotEqual(wait_cert.nonce, wait_cert2.nonce)
def get_wait_cert(self, sealed_data, addr=None):
block_hash = random_name(32)
wait_timer = self.get_wait_timer(sealed_data, addr)
return poet.create_wait_certificate(
sealed_data, wait_timer, block_hash)
