async def get_uid_for_pubkey__does_not_exist():
client.connect()
await client.is_connected()
random = Keypair.create_from_mnemonic(Keypair.generate_mnemonic())
uid = await client.get_uid_for_pubkey(random.public_key)
assert uid is None
def new_neuron():
# 1. Init Config item.
config = {
'session': {
'datapath': 'data/',
'learning_rate': 0.01,
'momentum': 0.9,
'batch_size_train': 64,
'batch_size_test': 64,
'log_interval': 10,
'sync_interval': 100,
'priority_interval': 100,
'name': 'mnist',
'trial_id': '1608070667'
},
'synapse': {
'target_dim': 10
},
'dendrite': {
'key_dim': 100,
'topk': 10,
'stale_emit_filter': 10000,
'pass_gradients': True,
'timeout': 0.5,
'do_backoff': True,
'max_backoff': 100
},
'axon': {
'local_port': 8091,
'external_ip': '191.97.53.53',
'max_workers': 5,
'max_gradients': 1000
},
'nucleus': {
'max_workers': 5,
'queue_timeout': 5,
'queue_maxsize': 1000
},
'metagraph': {
'chain_endpoint': '206.189.254.5:12345',
'stale_emit_filter': 10000
},
'meta_logger': {
'log_dir': 'data/'
},
'neuron': {
'keyfile': None,
'keypair': None
}
}
config = Munch.fromDict(config)
logger.info(Config.toString(config))
mnemonic = Keypair.generate_mnemonic()
keypair = Keypair.create_from_mnemonic(mnemonic)
neuron = Neuron(config)
neuron.keypair = keypair
return neuron
def test_sign_and_verify_scale_bytes(self):
mnemonic = Keypair.generate_mnemonic()
keypair = Keypair.create_from_mnemonic(mnemonic)
data = ScaleBytes('0x1234')
signature = keypair.sign(data)
self.assertTrue(keypair.verify(data, signature))
def test_dendrite_backoff():
_config = Munch.fromDict(config.copy())
_config.dendrite.do_backoff = True
_config.dendrite.max_backoff = 1
_mnemonic = Keypair.generate_mnemonic()
_keypair = Keypair.create_from_mnemonic(_mnemonic)
_dendrite = bittensor.dendrite.Dendrite(_config, metagraph)
_neuron_pb2 = bittensor_pb2.Neuron(
version=bittensor.__version__,
public_key=_keypair.public_key,
address='0.0.0.0',
port=12345,
)
# Add a quick sleep here, it appears that this test is intermittent, likely based on the asyncio operations of past tests.
# This forces the test to sleep a little while until the dust settles.
# Bandaid patch, TODO(unconst): fix this.
time.sleep(5)
# Normal call.
x = torch.rand(3, 3, bittensor.__network_dim__)
out, ops = _dendrite.forward_tensor([_neuron_pb2], [x])
assert ops[0].item() == bittensor_pb2.ReturnCode.Unavailable
assert list(out[0].shape) == [3, 3, bittensor.__network_dim__]
# Backoff call.
x = torch.rand(3, 3, bittensor.__network_dim__)
out, ops = _dendrite.forward_tensor([_neuron_pb2], [x])
assert ops[0].item() == bittensor_pb2.ReturnCode.Backoff
assert list(out[0].shape) == [3, 3, bittensor.__network_dim__]
# Normal call.
x = torch.rand(3, 3, bittensor.__network_dim__)
out, ops = _dendrite.forward_tensor([_neuron_pb2], [x])
assert ops[0].item() == bittensor_pb2.ReturnCode.Unavailable
assert list(out[0].shape) == [3, 3, bittensor.__network_dim__]
# Backoff call.
x = torch.rand(3, 3, bittensor.__network_dim__)
out, ops = _dendrite.forward_tensor([_neuron_pb2], [x])
assert ops[0].item() == bittensor_pb2.ReturnCode.Backoff
assert list(out[0].shape) == [3, 3, bittensor.__network_dim__]
def __create_keypair() -> Keypair:
return Keypair.create_from_mnemonic(Keypair.generate_mnemonic())
def gen_new_key(words):
mnemonic = Keypair.generate_mnemonic(words)
keypair = Keypair.create_from_mnemonic(mnemonic)
return keypair
def generate_keypair():
return Keypair.create_from_mnemonic(Keypair.generate_mnemonic())
},
'metagraph': {
'chain_endpoint': '206.189.254.5:12345',
'stale_emit_filter': 10000
},
'meta_logger': {
'log_dir': 'data/'
},
'neuron': {
'keyfile': None,
'keypair': None
}
}
config = Munch.fromDict(config)
mnemonic = Keypair.generate_mnemonic()
keypair = Keypair.create_from_mnemonic(mnemonic)
config.neuron.keypair = keypair
metagraph = Metagraph(config)
def test_convert_weight_order_should_work_last():
MAX_INT_WEIGHT = 4294967295 # Max weight value on chain.
metagraph.state.uids = torch.tensor([1, 2, 3, 4])
metagraph.uid = 4
weights = [0.1, 0.2, 0.3, 0.4]
uids, vals = metagraph.convert_weights_to_emit(weights)
print(uids, vals)
assert uids == [4, 1, 2, 3]
assert sum(vals) == MAX_INT_WEIGHT
def test_sign_and_verify_hex_data(self):
mnemonic = Keypair.generate_mnemonic()
keypair = Keypair.create_from_mnemonic(mnemonic)
signature = keypair.sign("0x1234")
self.assertTrue(keypair.verify("0x1234", signature))
def test_generate_mnemonic(self):
mnemonic = Keypair.generate_mnemonic()
self.assertTrue(bip39_validate(mnemonic))
def test_sign_and_verify_invalid_signature_ed25519(self):
mnemonic = Keypair.generate_mnemonic()
keypair = Keypair.create_from_mnemonic(mnemonic, crypto_type=KeypairType.ED25519)
signature = "0x4c291bfb0bb9c1274e86d4b666d13b2ac99a0bacc04a4846fb8ea50bda114677f83c1f164af58fc184451e5140cc8160c4de626163b11451d3bbb208a1889f8a"
self.assertFalse(keypair.verify("Test123", signature))
def test_sign_and_verify_ed25519(self):
mnemonic = Keypair.generate_mnemonic()
keypair = Keypair.create_from_mnemonic(mnemonic, crypto_type=KeypairType.ED25519)
signature = keypair.sign("Test123")
self.assertTrue(keypair.verify("Test123", signature))
def test_sign_and_verify_invalid_message(self):
mnemonic = Keypair.generate_mnemonic()
keypair = Keypair.create_from_mnemonic(mnemonic)
signature = keypair.sign("Test123")
self.assertFalse(keypair.verify("OtherMessage", signature))
def test_sign_and_verify_invalid_signature(self):
mnemonic = Keypair.generate_mnemonic()
keypair = Keypair.create_from_mnemonic(mnemonic)
signature = "Test"
self.assertRaises(TypeError, keypair.verify, "Test123", signature)
