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