def sdk_change_bls_key(looper,
txnPoolNodeSet,
node,
sdk_pool_handle,
sdk_wallet_steward,
add_wrong=False,
new_bls=None,
new_key_proof=None):
if add_wrong:
_, new_blspk, key_proof = create_default_bls_crypto_factory(
).generate_bls_keys()
else:
new_blspk, key_proof = init_bls_keys(node.keys_dir, node.name)
key_in_txn = new_bls or new_blspk
bls_key_proof = new_key_proof or key_proof
node_dest = hexToFriendly(node.nodestack.verhex)
sdk_send_update_node(looper,
sdk_wallet_steward,
sdk_pool_handle,
node_dest,
node.name,
None,
None,
None,
None,
bls_key=key_in_txn,
services=None,
key_proof=bls_key_proof)
poolSetExceptOne = list(txnPoolNodeSet)
poolSetExceptOne.remove(node)
waitNodeDataEquality(looper, node, *poolSetExceptOne)
sdk_pool_refresh(looper, sdk_pool_handle)
sdk_ensure_pool_functional(looper, txnPoolNodeSet, sdk_wallet_steward,
sdk_pool_handle)
return new_blspk
def init_bls_keys(baseDir, node_name, seed=None):
# TODO: do we need keys based on transport keys?
bls_factory = create_default_bls_crypto_factory(basedir=baseDir,
node_name=node_name)
stored_pk = bls_factory.generate_and_store_bls_keys(seed)
print("BLS Public key is", stored_pk)
return stored_pk
def __init__(self,
node_count: int = 4,
random: Optional[SimRandom] = None):
self._random = random if random else DefaultSimRandom()
self._timer = MockTimer()
self._network = SimNetwork(self._timer, self._random,
self._serialize_deserialize)
self._nodes = []
validators = genNodeNames(node_count)
# ToDo: maybe it should be a random too?
primary_name = validators[0]
genesis_txns = create_pool_txn_data(
node_names=validators,
crypto_factory=create_default_bls_crypto_factory(),
get_free_port=partial(random.integer, 9000, 9999))['txns']
for name in validators:
# TODO: emulate it the same way as in Replica, that is sender must have 'node_name:inst_id' form
replica_name = generateName(name, 0)
handler = partial(self.network._send_message, replica_name)
write_manager = create_test_write_req_manager(name, genesis_txns)
write_manager.node_reg_handler.node_reg_at_beginning_of_view[
0] = validators
replica = ReplicaService(replica_name,
validators,
primary_name,
self._timer,
InternalBus(),
self.network.create_peer(name, handler),
write_manager=write_manager,
bls_bft_replica=MockBlsBftReplica())
replica.config.NEW_VIEW_TIMEOUT = 30 * 1000
self._nodes.append(replica)
def sdk_change_bls_key(looper, txnPoolNodeSet,
node,
sdk_pool_handle,
sdk_wallet_steward,
add_wrong=False,
new_bls=None,
new_key_proof=None):
if add_wrong:
_, new_blspk, key_proof = create_default_bls_crypto_factory().generate_bls_keys()
else:
new_blspk, key_proof = init_bls_keys(node.keys_dir, node.name)
key_in_txn = new_bls or new_blspk
bls_key_proof = new_key_proof or key_proof
node_dest = hexToFriendly(node.nodestack.verhex)
sdk_send_update_node(looper, sdk_wallet_steward,
sdk_pool_handle,
node_dest, node.name,
None, None,
None, None,
bls_key=key_in_txn,
services=None,
key_proof=bls_key_proof)
poolSetExceptOne = list(txnPoolNodeSet)
poolSetExceptOne.remove(node)
waitNodeDataEquality(looper, node, *poolSetExceptOne)
sdk_pool_refresh(looper, sdk_pool_handle)
sdk_ensure_pool_functional(looper, txnPoolNodeSet, sdk_wallet_steward, sdk_pool_handle)
return new_blspk
def poolTxnData(request):
node_count = getValueFromModule(request, "nodeCount", 4)
nodes_with_bls = getValueFromModule(request, "nodes_wth_bls", node_count)
node_names = genNodeNames(node_count)
return create_pool_txn_data(node_names=node_names,
crypto_factory=create_default_bls_crypto_factory(),
get_free_port=lambda: genHa()[1],
nodes_with_bls=nodes_with_bls)
def init_bls_keys(keys_dir, node_name, seed=None):
# TODO: do we need keys based on transport keys?
bls_keys_dir = os.path.join(keys_dir, node_name)
bls_factory = create_default_bls_crypto_factory(keys_dir=bls_keys_dir)
stored_pk, key_proof = bls_factory.generate_and_store_bls_keys(seed)
print("BLS Public key is", stored_pk)
print("Proof of possession for BLS key is", key_proof)
return stored_pk, key_proof
def init_bls_keys(keys_dir, node_name, seed=None):
# TODO: do we need keys based on transport keys?
bls_keys_dir = os.path.join(keys_dir, node_name)
bls_factory = create_default_bls_crypto_factory(keys_dir=bls_keys_dir)
stored_pk, key_proof = bls_factory.generate_and_store_bls_keys(seed)
print("BLS Public key is", stored_pk)
print("Proof of possession for BLS key is", key_proof)
return stored_pk, key_proof
def poolTxnData(request):
nodeCount = getValueFromModule(request, "nodeCount", 4)
nodes_with_bls = getValueFromModule(request, "nodes_wth_bls", nodeCount)
data = {'txns': [], 'seeds': {}, 'nodesWithBls': {}}
for i, node_name in zip(range(1, nodeCount + 1), genNodeNames(nodeCount)):
data['seeds'][node_name] = node_name + '0' * (32 - len(node_name))
steward_name = 'Steward' + str(i)
data['seeds'][steward_name] = steward_name + \
'0' * (32 - len(steward_name))
n_idr = SimpleSigner(seed=data['seeds'][node_name].encode()).identifier
s_idr = DidSigner(seed=data['seeds'][steward_name].encode())
data['txns'].append({
TXN_TYPE: NYM,
ROLE: STEWARD,
ALIAS: steward_name,
TARGET_NYM: s_idr.identifier,
VERKEY: s_idr.verkey,
})
node_txn = {
TXN_TYPE: NODE,
f.IDENTIFIER.nm: s_idr.identifier,
TARGET_NYM: n_idr,
DATA: {
ALIAS: node_name,
SERVICES: [VALIDATOR],
NODE_IP: '127.0.0.1',
NODE_PORT: genHa()[1],
CLIENT_IP: '127.0.0.1',
CLIENT_PORT: genHa()[1],
}
}
if i <= nodes_with_bls:
_, bls_key = create_default_bls_crypto_factory().generate_bls_keys(
seed=data['seeds'][node_name])
node_txn[DATA][BLS_KEY] = bls_key
data['nodesWithBls'][node_name] = True
data['txns'].append(node_txn)
more_data_seeds = \
{
"Alice": "99999999999999999999999999999999",
"Jason": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
"John": "dddddddddddddddddddddddddddddddd",
"Les": "ffffffffffffffffffffffffffffffff"
}
more_data_users = []
for more_name, more_seed in more_data_seeds.items():
signer = DidSigner(seed=more_seed.encode())
more_data_users.append({TXN_TYPE: NYM, ALIAS: more_name, TARGET_NYM: signer.identifier, VERKEY: signer.verkey,
f.IDENTIFIER.nm: "5rArie7XKukPCaEwq5XGQJnM9Fc5aZE3M9HAPVfMU2xC"})
data['txns'].extend(more_data_users)
data['seeds'].update(more_data_seeds)
return data
def create_default_bls_bft_factory(node):
'''
Creates a default BLS factory to instantiate BLS BFT classes.
:param node: Node instance
:return: BLS factory instance
'''
bls_keys_dir = os.path.join(node.keys_dir, node.name)
bls_crypto_factory = create_default_bls_crypto_factory(bls_keys_dir)
return BlsFactoryBftPlenum(bls_crypto_factory, node)
def getPoolTxnData(poolId, newPoolTxnNodeNames):
data = {}
data["seeds"] = {}
data["txns"] = []
data['nodesWithBls'] = {}
for index, n in enumerate(newPoolTxnNodeNames, start=1):
newStewardAlias = poolId + "Steward" + str(index)
stewardSeed = (newStewardAlias + "0" *
(32 - len(newStewardAlias))).encode()
data["seeds"][newStewardAlias] = stewardSeed
stewardSigner = SimpleSigner(seed=stewardSeed)
data["txns"].append({
TARGET_NYM:
stewardSigner.verkey,
ROLE:
STEWARD,
TXN_TYPE:
NYM,
ALIAS:
poolId + "Steward" + str(index),
TXN_ID:
sha256("{}".format(stewardSigner.verkey).encode()).hexdigest()
})
newNodeAlias = n
nodeSeed = (newNodeAlias + "0" * (32 - len(newNodeAlias))).encode()
data["seeds"][newNodeAlias] = nodeSeed
nodeSigner = SimpleSigner(seed=nodeSeed)
node_txn = {
TARGET_NYM: nodeSigner.verkey,
TXN_TYPE: NODE,
f.IDENTIFIER.nm: stewardSigner.verkey,
DATA: {
CLIENT_IP: "127.0.0.1",
ALIAS: newNodeAlias,
NODE_IP: "127.0.0.1",
NODE_PORT: genHa()[1],
CLIENT_PORT: genHa()[1],
SERVICES: [VALIDATOR],
},
TXN_ID:
sha256("{}".format(nodeSigner.verkey).encode()).hexdigest()
}
_, bls_key = create_default_bls_crypto_factory().generate_bls_keys(
seed=data['seeds'][n])
node_txn[DATA][BLS_KEY] = bls_key
data['nodesWithBls'][n] = True
data["txns"].append(node_txn)
return data
def replica_service(validators, primary, timer, internal_bus, external_bus):
genesis_txns = create_pool_txn_data(
node_names=validators,
crypto_factory=create_default_bls_crypto_factory(),
get_free_port=lambda: 8090)['txns']
return ReplicaService("Alpha:0",
validators,
primary,
timer,
internal_bus,
external_bus,
write_manager=create_test_write_req_manager(
"Alpha", genesis_txns),
bls_bft_replica=FakeSomething(gc=lambda key: None))
def __init__(self, node_count: int = 4, random: Optional[SimRandom] = None):
self._random = random if random else DefaultSimRandom()
self._timer = MockTimer()
self._network = SimNetwork(self._timer, self._random)
validators = genNodeNames(node_count)
primary_name = validators[0]
genesis_txns = create_pool_txn_data(
node_names=validators,
crypto_factory=create_default_bls_crypto_factory(),
get_free_port=partial(random.integer, 9000, 9999))['txns']
self._nodes = [ReplicaService(name, validators, primary_name,
self._timer, InternalBus(), self.network.create_peer(name),
write_manager=create_test_write_req_manager(name, genesis_txns))
for name in validators]
def getPoolTxnData(poolId, newPoolTxnNodeNames):
data = {}
data["seeds"] = {}
data["txns"] = []
data['nodesWithBls'] = {}
for index, n in enumerate(newPoolTxnNodeNames, start=1):
newStewardAlias = poolId + "Steward" + str(index)
stewardSeed = (newStewardAlias + "0" *
(32 - len(newStewardAlias))).encode()
data["seeds"][newStewardAlias] = stewardSeed
stewardSigner = SimpleSigner(seed=stewardSeed)
data["txns"].append(
Member.nym_txn(nym=stewardSigner.identifier,
verkey=stewardSigner.verkey,
role=STEWARD,
name=poolId + "Steward" + str(index),
seq_no=index,
txn_id=sha256("{}".format(
stewardSigner.verkey).encode()).hexdigest()))
newNodeAlias = n
nodeSeed = (newNodeAlias + "0" * (32 - len(newNodeAlias))).encode()
data["seeds"][newNodeAlias] = nodeSeed
nodeSigner = SimpleSigner(seed=nodeSeed)
_, bls_key, key_proof = create_default_bls_crypto_factory(
).generate_bls_keys(seed=data['seeds'][n])
data['nodesWithBls'][n] = True
node_txn = Steward.node_txn(
steward_nym=stewardSigner.verkey,
node_name=newNodeAlias,
nym=nodeSigner.verkey,
ip="127.0.0.1",
node_port=genHa()[1],
client_port=genHa()[1],
client_ip="127.0.0.1",
blskey=bls_key,
bls_key_proof=key_proof,
services=[VALIDATOR],
txn_id=sha256("{}".format(nodeSigner.verkey).encode()).hexdigest())
data["txns"].append(node_txn)
return data
def getPoolTxnData(poolId, newPoolTxnNodeNames):
data = {}
data["seeds"] = {}
data["txns"] = []
data['nodesWithBls'] = {}
for index, n in enumerate(newPoolTxnNodeNames, start=1):
newStewardAlias = poolId + "Steward" + str(index)
stewardSeed = (newStewardAlias + "0" *
(32 - len(newStewardAlias))).encode()
data["seeds"][newStewardAlias] = stewardSeed
stewardSigner = SimpleSigner(seed=stewardSeed)
data["txns"].append({
TARGET_NYM: stewardSigner.verkey,
ROLE: STEWARD, TXN_TYPE: NYM,
ALIAS: poolId + "Steward" + str(index),
TXN_ID: sha256("{}".format(stewardSigner.verkey).encode()).hexdigest()
})
newNodeAlias = n
nodeSeed = (newNodeAlias + "0" * (32 - len(newNodeAlias))).encode()
data["seeds"][newNodeAlias] = nodeSeed
nodeSigner = SimpleSigner(seed=nodeSeed)
node_txn = {
TARGET_NYM: nodeSigner.verkey,
TXN_TYPE: NODE,
f.IDENTIFIER.nm: stewardSigner.verkey,
DATA: {
CLIENT_IP: "127.0.0.1",
ALIAS: newNodeAlias,
NODE_IP: "127.0.0.1",
NODE_PORT: genHa()[1],
CLIENT_PORT: genHa()[1],
SERVICES: [VALIDATOR],
},
TXN_ID: sha256("{}".format(nodeSigner.verkey).encode()).hexdigest()
}
_, bls_key = create_default_bls_crypto_factory().generate_bls_keys(
seed=data['seeds'][n])
node_txn[DATA][BLS_KEY] = bls_key
data['nodesWithBls'][n] = True
data["txns"].append(node_txn)
return data
def getPoolTxnData(poolId, newPoolTxnNodeNames):
data = {}
data["seeds"] = {}
data["txns"] = []
data['nodesWithBls'] = {}
for index, n in enumerate(newPoolTxnNodeNames, start=1):
newStewardAlias = poolId + "Steward" + str(index)
stewardSeed = (newStewardAlias + "0" *
(32 - len(newStewardAlias))).encode()
data["seeds"][newStewardAlias] = stewardSeed
stewardSigner = SimpleSigner(seed=stewardSeed)
data["txns"].append(
Member.nym_txn(nym=stewardSigner.identifier,
verkey=stewardSigner.verkey,
role=STEWARD,
name=poolId + "Steward" + str(index),
seq_no=index,
txn_id=sha256("{}".format(stewardSigner.verkey).encode()).hexdigest()))
newNodeAlias = n
nodeSeed = (newNodeAlias + "0" * (32 - len(newNodeAlias))).encode()
data["seeds"][newNodeAlias] = nodeSeed
nodeSigner = SimpleSigner(seed=nodeSeed)
_, bls_key = create_default_bls_crypto_factory().generate_bls_keys(
seed=data['seeds'][n])
data['nodesWithBls'][n] = True
node_txn = Steward.node_txn(
steward_nym=stewardSigner.verkey,
node_name=newNodeAlias,
nym=nodeSigner.verkey,
ip="127.0.0.1",
node_port=genHa()[1],
client_port=genHa()[1],
client_ip="127.0.0.1",
blskey=bls_key,
services=[VALIDATOR],
txn_id=sha256("{}".format(nodeSigner.verkey).encode()).hexdigest()
)
data["txns"].append(node_txn)
return data
def __init__(self,
node_count: int = 4,
random: Optional[SimRandom] = None):
self._random = random if random else DefaultSimRandom()
self._timer = MockTimer()
self._network = SimNetwork(self._timer, self._random,
self._serialize_deserialize)
self._nodes = []
validators = genNodeNames(node_count)
# ToDo: maybe it should be a random too?
primary_name = validators[0]
genesis_txns = create_pool_txn_data(
node_names=validators,
crypto_factory=create_default_bls_crypto_factory(),
get_free_port=partial(random.integer, 9000, 9999))['txns']
for name in validators:
# TODO: emulate it the same way as in Replica, that is sender must have 'node_name:inst_id' form
replica_name = generateName(name, 0)
handler = partial(self.network._send_message, replica_name)
write_manager = create_test_write_req_manager(name, genesis_txns)
replica = ReplicaService(replica_name,
validators,
primary_name,
self._timer,
InternalBus(),
self.network.create_peer(name, handler),
write_manager=write_manager,
bls_bft_replica=MockBlsBftReplica())
# ToDo: For now, future_primary_handler is depended from the node.
# And for now we need to patching set_node_state functionality
future_primaries_handler = FuturePrimariesBatchHandler(
write_manager.database_manager,
FakeSomething(nodeReg={}, nodeIds=[]))
future_primaries_handler._get_primaries = lambda *args, **kwargs: replica._data.primaries
write_manager.register_batch_handler(future_primaries_handler)
# ToDo: also, it should be done at the zero-view stage.
write_manager.future_primary_handler.set_node_state()
replica.config.NEW_VIEW_TIMEOUT = 30 * 1000
self._nodes.append(replica)
def replica_service(validators, primary, timer,
internal_bus, external_bus):
genesis_txns = create_pool_txn_data(
node_names=validators,
crypto_factory=create_default_bls_crypto_factory(),
get_free_port=lambda: 8090)['txns']
replica = ReplicaService("Alpha:0",
validators, primary,
timer,
internal_bus,
external_bus,
write_manager=create_test_write_req_manager("Alpha", genesis_txns),
bls_bft_replica=FakeSomething(gc=lambda key: None))
future_primaries_handler = FuturePrimariesBatchHandler(replica._write_manager.database_manager,
FakeSomething(nodeReg={},
nodeIds=[]))
future_primaries_handler._get_primaries = lambda *args, **kwargs: replica._data.primaries
replica._write_manager.register_batch_handler(future_primaries_handler)
return replica
def newNodeVals():
newNodeSeed = randomSeed()
nodeIp, nodePort = genHa()
clientIp, clientPort = genHa()
_, bls_key, key_proof = create_default_bls_crypto_factory(
).generate_bls_keys()
newNodeData = {
NODE_IP: nodeIp,
NODE_PORT: nodePort,
CLIENT_IP: clientIp,
CLIENT_PORT: clientPort,
ALIAS: randomString(6),
SERVICES: [VALIDATOR],
BLS_KEY: bls_key,
BLS_KEY_PROOF: key_proof
}
return {
'newNodeSeed': newNodeSeed.decode(),
'newNodeIdr': SimpleSigner(seed=newNodeSeed).identifier,
'newNodeData': newNodeData
}
def poolTxnData(request):
nodeCount = getValueFromModule(request, "nodeCount", 4)
nodes_with_bls = getValueFromModule(request, "nodes_wth_bls", nodeCount)
data = {'txns': [], 'seeds': {}, 'nodesWithBls': {}}
for i, node_name in zip(range(1, nodeCount + 1), genNodeNames(nodeCount)):
data['seeds'][node_name] = node_name + '0' * (32 - len(node_name))
steward_name = 'Steward' + str(i)
data['seeds'][steward_name] = steward_name + \
'0' * (32 - len(steward_name))
n_idr = SimpleSigner(seed=data['seeds'][node_name].encode()).identifier
s_idr = DidSigner(seed=data['seeds'][steward_name].encode())
data['txns'].append(
Member.nym_txn(nym=s_idr.identifier,
verkey=s_idr.verkey,
role=STEWARD,
name=steward_name,
seq_no=i)
)
node_txn = Steward.node_txn(steward_nym=s_idr.identifier,
node_name=node_name,
nym=n_idr,
ip='127.0.0.1',
node_port=genHa()[1],
client_port=genHa()[1],
client_ip='127.0.0.1',
services=[VALIDATOR],
seq_no=i)
if i <= nodes_with_bls:
_, bls_key, bls_key_proof = create_default_bls_crypto_factory().generate_bls_keys(
seed=data['seeds'][node_name])
get_payload_data(node_txn)[DATA][BLS_KEY] = bls_key
get_payload_data(node_txn)[DATA][BLS_KEY_PROOF] = bls_key_proof
data['nodesWithBls'][node_name] = True
data['txns'].append(node_txn)
# Add 4 Trustees
for i in range(4):
trustee_name = 'Trs' + str(i)
data['seeds'][trustee_name] = trustee_name + '0' * (
32 - len(trustee_name))
t_sgnr = DidSigner(seed=data['seeds'][trustee_name].encode())
data['txns'].append(
Member.nym_txn(nym=t_sgnr.identifier,
verkey=t_sgnr.verkey,
role=TRUSTEE,
name=trustee_name)
)
more_data_seeds = \
{
"Alice": "99999999999999999999999999999999",
"Jason": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
"John": "dddddddddddddddddddddddddddddddd",
"Les": "ffffffffffffffffffffffffffffffff"
}
more_data_users = []
for more_name, more_seed in more_data_seeds.items():
signer = DidSigner(seed=more_seed.encode())
more_data_users.append(
Member.nym_txn(nym=signer.identifier,
verkey=signer.verkey,
name=more_name,
creator="5rArie7XKukPCaEwq5XGQJnM9Fc5aZE3M9HAPVfMU2xC")
)
data['txns'].extend(more_data_users)
data['seeds'].update(more_data_seeds)
return data
def poolTxnData(request):
nodeCount = getValueFromModule(request, "nodeCount", 4)
nodes_with_bls = getValueFromModule(request, "nodes_wth_bls", nodeCount)
data = {'txns': [], 'seeds': {}, 'nodesWithBls': {}}
for i, node_name in zip(range(1, nodeCount + 1), genNodeNames(nodeCount)):
data['seeds'][node_name] = node_name + '0' * (32 - len(node_name))
steward_name = 'Steward' + str(i)
data['seeds'][steward_name] = steward_name + \
'0' * (32 - len(steward_name))
n_idr = SimpleSigner(seed=data['seeds'][node_name].encode()).identifier
s_idr = DidSigner(seed=data['seeds'][steward_name].encode())
data['txns'].append(
Member.nym_txn(nym=s_idr.identifier,
verkey=s_idr.verkey,
role=STEWARD,
name=steward_name,
seq_no=i))
node_txn = Steward.node_txn(steward_nym=s_idr.identifier,
node_name=node_name,
nym=n_idr,
ip='127.0.0.1',
node_port=genHa()[1],
client_port=genHa()[1],
client_ip='127.0.0.1',
services=[VALIDATOR],
seq_no=i)
if i <= nodes_with_bls:
_, bls_key, bls_key_proof = create_default_bls_crypto_factory(
).generate_bls_keys(seed=data['seeds'][node_name])
get_payload_data(node_txn)[DATA][BLS_KEY] = bls_key
get_payload_data(node_txn)[DATA][BLS_KEY_PROOF] = bls_key_proof
data['nodesWithBls'][node_name] = True
data['txns'].append(node_txn)
# Add 4 Trustees
for i in range(4):
trustee_name = 'Trs' + str(i)
data['seeds'][trustee_name] = trustee_name + '0' * (32 -
len(trustee_name))
t_sgnr = DidSigner(seed=data['seeds'][trustee_name].encode())
data['txns'].append(
Member.nym_txn(nym=t_sgnr.identifier,
verkey=t_sgnr.verkey,
role=TRUSTEE,
name=trustee_name))
more_data_seeds = \
{
"Alice": "99999999999999999999999999999999",
"Jason": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
"John": "dddddddddddddddddddddddddddddddd",
"Les": "ffffffffffffffffffffffffffffffff"
}
more_data_users = []
for more_name, more_seed in more_data_seeds.items():
signer = DidSigner(seed=more_seed.encode())
more_data_users.append(
Member.nym_txn(
nym=signer.identifier,
verkey=signer.verkey,
name=more_name,
creator="5rArie7XKukPCaEwq5XGQJnM9Fc5aZE3M9HAPVfMU2xC"))
data['txns'].extend(more_data_users)
data['seeds'].update(more_data_seeds)
return data
def write_req_manager(initial_nodes):
genesis_txns = create_pool_txn_data(
node_names=initial_nodes,
crypto_factory=create_default_bls_crypto_factory(),
get_free_port=lambda: 8090)['txns']
return create_test_write_req_manager(initial_nodes[0], genesis_txns)
def _generate_genensis_txns(self):
self._genesis_txns = create_pool_txn_data(
node_names=self._genesis_validators,
crypto_factory=create_default_bls_crypto_factory(),
get_free_port=self._get_free_port)['txns']
def poolTxnData(request):
nodeCount = getValueFromModule(request, "nodeCount", 4)
nodes_with_bls = getValueFromModule(request, "nodes_wth_bls", nodeCount)
data = {'txns': [], 'seeds': {}, 'nodesWithBls': {}}
for i, node_name in zip(range(1, nodeCount + 1), genNodeNames(nodeCount)):
data['seeds'][node_name] = node_name + '0' * (32 - len(node_name))
steward_name = 'Steward' + str(i)
data['seeds'][steward_name] = steward_name + \
'0' * (32 - len(steward_name))
n_idr = SimpleSigner(seed=data['seeds'][node_name].encode()).identifier
s_idr = SimpleSigner(
seed=data['seeds'][steward_name].encode()).identifier
data['txns'].append({
TXN_TYPE: NYM,
ROLE: STEWARD,
ALIAS: steward_name,
TARGET_NYM: s_idr
})
node_txn = {
TXN_TYPE: NODE,
f.IDENTIFIER.nm: s_idr,
TARGET_NYM: n_idr,
DATA: {
ALIAS: node_name,
SERVICES: [VALIDATOR],
NODE_IP: '127.0.0.1',
NODE_PORT: genHa()[1],
CLIENT_IP: '127.0.0.1',
CLIENT_PORT: genHa()[1],
}
}
if i <= nodes_with_bls:
_, bls_key = create_default_bls_crypto_factory().generate_bls_keys(
seed=data['seeds'][node_name])
node_txn[DATA][BLS_KEY] = bls_key
data['nodesWithBls'][node_name] = True
data['txns'].append(node_txn)
# Below is some static data that is needed for some CLI tests
more_data = {
'txns': [{
"identifier": "5rArie7XKukPCaEwq5XGQJnM9Fc5aZE3M9HAPVfMU2xC",
"dest": "4AdS22kC7xzb4bcqg9JATuCfAMNcQYcZa1u5eWzs6cSJ",
"type": "1",
"alias": "Alice"
}, {
"identifier": "5rArie7XKukPCaEwq5XGQJnM9Fc5aZE3M9HAPVfMU2xC",
"dest": "46Kq4hASUdvUbwR7s7Pie3x8f4HRB3NLay7Z9jh9eZsB",
"type": "1",
"alias": "Jason"
}, {
"identifier": "5rArie7XKukPCaEwq5XGQJnM9Fc5aZE3M9HAPVfMU2xC",
"dest": "3wpYnGqceZ8DzN3guiTd9rrYkWTwTHCChBSuo6cvkXTG",
"type": "1",
"alias": "John"
}, {
"identifier": "5rArie7XKukPCaEwq5XGQJnM9Fc5aZE3M9HAPVfMU2xC",
"dest": "4Yk9HoDSfJv9QcmJbLcXdWVgS7nfvdUqiVcvbSu8VBru",
"type": "1",
"alias": "Les"
}],
'seeds': {
"Alice": "99999999999999999999999999999999",
"Jason": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
"John": "dddddddddddddddddddddddddddddddd",
"Les": "ffffffffffffffffffffffffffffffff"
}
}
data['txns'].extend(more_data['txns'])
data['seeds'].update(more_data['seeds'])
return data
def bls_bft_factory(node, tdir_for_func):
dir = os.path.join(tdir_for_func, 'TestNode')
bls_crypto_factory = create_default_bls_crypto_factory(dir)
return BlsFactoryBftPlenum(bls_crypto_factory, node)
def new_bls_keys():
_, bls_key, key_proof = create_default_bls_crypto_factory(
).generate_bls_keys()
return bls_key, key_proof
def bls_bft_factory(node, tempdir):
bls_crypto_factory = create_default_bls_crypto_factory(tempdir, 'TestNode')
return BlsFactoryBftPlenum(bls_crypto_factory, node)
def bls_bft_factory(node, tdir_for_func):
dir = os.path.join(tdir_for_func, 'TestNode')
bls_crypto_factory = create_default_bls_crypto_factory(dir)
return BlsFactoryBftPlenum(bls_crypto_factory,
node)
def _create_multi_sig_verifier(self) -> BlsCryptoVerifier:
verifier = create_default_bls_crypto_factory() \
.create_bls_crypto_verifier()
return verifier
def _create_multi_sig_verifier() -> BlsCryptoVerifier:
verifier = create_default_bls_crypto_factory() \
.create_bls_crypto_verifier()
return verifier
