def load():
port = genHa()[1]
ha = HA('0.0.0.0', port)
name = "hello"
wallet = Wallet(name)
wallet.addIdentifier(signer=SimpleSigner(
seed=b'000000000000000000000000Steward1'))
client = Client(name, ha=ha)
with Looper(debug=getConfig().LOOPER_DEBUG) as looper:
looper.add(client)
print('Will send {} reqs in all'.format(numReqs))
requests = sendRandomRequests(wallet, client, numReqs)
start = perf_counter()
for i in range(0, numReqs, numReqs // splits):
print('Will wait for {} now'.format(numReqs // splits))
s = perf_counter()
reqs = requests[i:i + numReqs // splits + 1]
waitForSufficientRepliesForRequests(looper,
client,
requests=reqs,
fVal=2,
customTimeoutPerReq=3)
print('>>> Got replies for {} requests << in {}'.format(
numReqs // splits,
perf_counter() - s))
end = perf_counter()
print('>>>{}<<<'.format(end - start))
exit(0)
def __init__(self, name: str):
PWallet.__init__(self, name)
Sponsoring.__init__(self)
self._credMasterSecret = None
self._attributes = {
} # type: Dict[(str, Identifier, Optional[Identifier]), Attribute]
self._credDefs = {} # type: Dict[(str, str, str), CredDef]
self._credDefSks = {} # type: Dict[(str, str, str), CredDefSk]
self._credentials = {} # type: Dict[str, Credential]
self.lastKnownSeqs = {} # type: Dict[str, int]
self._links = {} # type: Dict[str, Link]
self.knownIds = {} # type: Dict[str, Identifier]
self._claimDefs = {} # type: Dict[ClaimDefKey, ClaimDef]
self._issuerSks = {}
self._issuerPks = {}
# transactions not yet submitted
self._pending = deque(
) # type Tuple[Request, Tuple[str, Identifier, Optional[Identifier]]
# pending transactions that have been prepared (probably submitted)
self._prepared = {} # type: Dict[(Identifier, int), Request]
self.replyHandler = {
ATTRIB: self._attribReply,
GET_ATTR: self._getAttrReply,
CRED_DEF: self._credDefReply,
GET_CRED_DEF: self._getCredDefReply,
NYM: self._nymReply,
GET_NYM: self._getNymReply,
GET_TXNS: self._getTxnsReply,
ISSUER_KEY: self._issuerKeyReply,
GET_ISSUER_KEY: self._getIssuerKeyReply,
}
def changeHA(looper, config, nodeName, nodeSeed, newNodeHA,
stewardName, stewardsSeed, newClientHA=None):
if not newClientHA:
newClientHA = HA(newNodeHA.host, newNodeHA.port + 1)
# prepare steward wallet
stewardSigner = SimpleSigner(seed=stewardsSeed)
stewardWallet = Wallet(stewardName)
stewardWallet.addIdentifier(signer=stewardSigner)
# prepare client to submit change ha request
_, randomClientPort = genHa()
client = Client(stewardName,
ha=('0.0.0.0', randomClientPort), config=config)
looper.add(client)
timeout = waits.expectedClientToPoolConnectionTimeout(4)
looper.run(eventually(__checkClientConnected, client,
retryWait=1, timeout=timeout))
nodeVerKey = SimpleSigner(seed=nodeSeed).verkey
# send request
req = submitNodeIpChange(client, stewardWallet, nodeName, nodeVerKey,
newNodeHA, newClientHA)
return client, req
def __init__(self, name: str, supportedDidMethods: DidMethods = None):
PWallet.__init__(self, name, supportedDidMethods or DefaultDidMethods)
Sponsoring.__init__(self)
self._attributes = {} # type: Dict[(str, Identifier,
# Optional[Identifier]), Attribute]
self.env = None # Helps to know associated environment
self._nodes = {}
self._upgrades = {}
self._links = {} # type: Dict[str, Link]
self.knownIds = {} # type: Dict[str, Identifier]
# transactions not yet submitted
self._pending = deque() # type Tuple[Request, Tuple[str, Identifier,
# Optional[Identifier]]
# pending transactions that have been prepared (probably submitted)
self._prepared = {} # type: Dict[(Identifier, int), Request]
self.lastKnownSeqs = {} # type: Dict[str, int]
self.replyHandler = {
ATTRIB: self._attribReply,
GET_ATTR: self._getAttrReply,
NYM: self._nymReply,
GET_NYM: self._getNymReply,
GET_TXNS: self._getTxnsReply,
NODE: self._nodeReply,
POOL_UPGRADE: self._poolUpgradeReply
}
def changeNodeHa(looper, txnPoolNodeSet, tdirWithClientPoolTxns,
poolTxnData, poolTxnStewardNames, tconf, shouldBePrimary, tdir):
# prepare new ha for node and client stack
subjectedNode = None
stewardName = None
stewardsSeed = None
for nodeIndex, n in enumerate(txnPoolNodeSet):
if shouldBePrimary == n.has_master_primary:
subjectedNode = n
stewardName = poolTxnStewardNames[nodeIndex]
stewardsSeed = poolTxnData["seeds"][stewardName].encode()
break
nodeStackNewHA, clientStackNewHA = genHa(2)
logger.debug("change HA for node: {} to {}".format(
subjectedNode.name, (nodeStackNewHA, clientStackNewHA)))
nodeSeed = poolTxnData["seeds"][subjectedNode.name].encode()
# change HA
stewardClient, req = changeHA(looper, tconf, subjectedNode.name, nodeSeed,
nodeStackNewHA, stewardName, stewardsSeed,
basedir=tdirWithClientPoolTxns)
waitForSufficientRepliesForRequests(looper, stewardClient,
requests=[req])
# stop node for which HA will be changed
subjectedNode.stop()
looper.removeProdable(subjectedNode)
# start node with new HA
config_helper = PNodeConfigHelper(subjectedNode.name, tconf, chroot=tdir)
restartedNode = TestNode(subjectedNode.name,
config_helper=config_helper,
config=tconf, ha=nodeStackNewHA,
cliha=clientStackNewHA)
looper.add(restartedNode)
txnPoolNodeSet[nodeIndex] = restartedNode
looper.run(checkNodesConnected(txnPoolNodeSet, customTimeout=70))
electionTimeout = waits.expectedPoolElectionTimeout(
nodeCount=len(txnPoolNodeSet),
numOfReelections=3)
ensureElectionsDone(looper,
txnPoolNodeSet,
retryWait=1,
customTimeout=electionTimeout)
# start client and check the node HA
anotherClient, _ = genTestClient(tmpdir=tdirWithClientPoolTxns,
usePoolLedger=True)
looper.add(anotherClient)
looper.run(eventually(anotherClient.ensureConnectedToNodes))
stewardWallet = Wallet(stewardName)
stewardWallet.addIdentifier(signer=DidSigner(seed=stewardsSeed))
sendReqsToNodesAndVerifySuffReplies(
looper, stewardWallet, stewardClient, 8)
def create_client_wallet(self, seed=None):
""" Create a plenum client wallet with an identifier. """
if seed:
seed = seed.encode()
wallet = Wallet()
wallet.addIdentifier(seed=seed)
return wallet
def genTestClient(nodes=None,
nodeReg=None,
tmpdir=None,
testClientClass=TestClient,
identifier: Identifier = None,
verkey: str = None,
bootstrapKeys=True,
ha=None,
usePoolLedger=False,
name=None,
sighex=None) -> (TestClient, Wallet):
if not usePoolLedger:
nReg = nodeReg
if nodeReg:
assert isinstance(nodeReg, dict)
elif hasattr(nodes, "nodeReg"):
nReg = nodes.nodeReg.extractCliNodeReg()
else:
error("need access to nodeReg")
for k, v in nReg.items():
assert type(k) == str
assert (type(v) == HA or type(v[0]) == HA)
else:
logger.debug("TestClient using pool ledger")
nReg = None
ha = genHa() if not ha else ha
name = name or "testClient{}".format(ha.port)
tc = testClientClass(name,
nodeReg=nReg,
ha=ha,
basedirpath=tmpdir,
sighex=sighex)
if not usePoolLedger and nodes:
for node in nodes:
stack = node.clientstack
# TODO: Remove this if condition once raet is removed
if isinstance(stack, ZStack):
initRemoteKeys(tc.name,
stack.name,
tmpdir,
stack.verhex,
override=True)
w = None # type: Wallet
if bootstrapKeys and nodes:
if not identifier or not verkey:
# no identifier or verkey were provided, so creating a wallet
w = Wallet("test")
w.addIdentifier()
identifier = w.defaultId
verkey = w.getVerkey()
bootstrapClientKeys(identifier, verkey, nodes)
return tc, w
def changeNodeHa(looper, txnPoolNodeSet, tdirWithPoolTxns,
poolTxnData, poolTxnStewardNames, tconf, shouldBePrimary):
# prepare new ha for node and client stack
subjectedNode = None
stewardName = None
stewardsSeed = None
for nodeIndex, n in enumerate(txnPoolNodeSet):
if (shouldBePrimary and n.primaryReplicaNo == 0) or \
(not shouldBePrimary and n.primaryReplicaNo != 0):
subjectedNode = n
stewardName = poolTxnStewardNames[nodeIndex]
stewardsSeed = poolTxnData["seeds"][stewardName].encode()
break
nodeStackNewHA, clientStackNewHA = genHa(2)
logger.debug("change HA for node: {} to {}".
format(subjectedNode.name, (nodeStackNewHA, clientStackNewHA)))
nodeSeed = poolTxnData["seeds"][subjectedNode.name].encode()
# change HA
stewardClient, req = changeHA(looper, tconf, subjectedNode.name, nodeSeed,
nodeStackNewHA, stewardName, stewardsSeed)
f = getMaxFailures(len(stewardClient.nodeReg))
looper.run(eventually(checkSufficientRepliesRecvd, stewardClient.inBox,
req.reqId, f, retryWait=1, timeout=20))
# stop node for which HA will be changed
subjectedNode.stop()
looper.removeProdable(subjectedNode)
# start node with new HA
restartedNode = TestNode(subjectedNode.name, basedirpath=tdirWithPoolTxns,
config=tconf, ha=nodeStackNewHA,
cliha=clientStackNewHA)
looper.add(restartedNode)
txnPoolNodeSet[nodeIndex] = restartedNode
looper.run(checkNodesConnected(txnPoolNodeSet, overrideTimeout=70))
ensureElectionsDone(looper, txnPoolNodeSet, retryWait=1, timeout=10)
# start client and check the node HA
anotherClient, _ = genTestClient(tmpdir=tdirWithPoolTxns,
usePoolLedger=True)
looper.add(anotherClient)
looper.run(eventually(anotherClient.ensureConnectedToNodes))
stewardWallet = Wallet(stewardName)
stewardWallet.addIdentifier(signer=SimpleSigner(seed=stewardsSeed))
sendReqsToNodesAndVerifySuffReplies(looper, stewardWallet, stewardClient, 8)
looper.run(eventually(checkIfGenesisPoolTxnFileUpdated, *txnPoolNodeSet,
stewardClient, anotherClient, retryWait=1,
timeout=10))
looper.removeProdable(stewardClient)
def changeNodeHa(looper, txnPoolNodeSet, tdirWithPoolTxns,
poolTxnData, poolTxnStewardNames, tconf, shouldBePrimary):
# prepare new ha for node and client stack
subjectedNode = None
stewardName = None
stewardsSeed = None
for nodeIndex, n in enumerate(txnPoolNodeSet):
if (shouldBePrimary and n.primaryReplicaNo == 0) or \
(not shouldBePrimary and n.primaryReplicaNo != 0):
subjectedNode = n
stewardName = poolTxnStewardNames[nodeIndex]
stewardsSeed = poolTxnData["seeds"][stewardName].encode()
break
nodeStackNewHA, clientStackNewHA = genHa(2)
logger.debug("change HA for node: {} to {}".
format(subjectedNode.name, (nodeStackNewHA, clientStackNewHA)))
nodeSeed = poolTxnData["seeds"][subjectedNode.name].encode()
# change HA
stewardClient, req = changeHA(looper, tconf, subjectedNode.name, nodeSeed,
nodeStackNewHA, stewardName, stewardsSeed)
f = getMaxFailures(len(stewardClient.nodeReg))
looper.run(eventually(checkSufficientRepliesRecvd, stewardClient.inBox,
req.reqId, f, retryWait=1, timeout=20))
# stop node for which HA will be changed
subjectedNode.stop()
looper.removeProdable(subjectedNode)
# start node with new HA
restartedNode = TestNode(subjectedNode.name, basedirpath=tdirWithPoolTxns,
config=tconf, ha=nodeStackNewHA,
cliha=clientStackNewHA)
looper.add(restartedNode)
txnPoolNodeSet[nodeIndex] = restartedNode
looper.run(checkNodesConnected(txnPoolNodeSet, overrideTimeout=70))
ensureElectionsDone(looper, txnPoolNodeSet, retryWait=1, timeout=10)
# start client and check the node HA
anotherClient, _ = genTestClient(tmpdir=tdirWithPoolTxns,
usePoolLedger=True)
looper.add(anotherClient)
looper.run(eventually(anotherClient.ensureConnectedToNodes))
stewardWallet = Wallet(stewardName)
stewardWallet.addIdentifier(signer=SimpleSigner(seed=stewardsSeed))
sendReqsToNodesAndVerifySuffReplies(looper, stewardWallet, stewardClient, 8)
looper.run(eventually(checkIfGenesisPoolTxnFileUpdated, *txnPoolNodeSet,
stewardClient, anotherClient, retryWait=1,
timeout=10))
def add_and_sign(signersNum=10):
beforeSignTimeBasedId = getTimeBasedId()
wallet = Wallet("shared wallet")
idrs = []
for i in range(signersNum):
identifier = "signer_{}".format(i)
idrs.append(identifier)
wallet.addIdentifier(identifier)
for idr in idrs:
signed = wallet.signOp(op={}, identifier=idr)
afterSignTimeBasedId = getTimeBasedId()
assert beforeSignTimeBasedId < signed.reqId < afterSignTimeBasedId
def add_and_sign(signersNum = 10):
beforeSignTimeBasedId = getTimeBasedId()
wallet = Wallet("shared wallet")
idrs = []
for i in range(signersNum):
identifier = "signer_{}".format(i)
idrs.append(identifier)
wallet.addIdentifier(identifier)
for idr in idrs:
signed = wallet.signOp(op={}, identifier=idr)
afterSignTimeBasedId = getTimeBasedId()
assert beforeSignTimeBasedId < signed.reqId < afterSignTimeBasedId
def build_wallets_from_data(name_seeds):
wallets = []
for name, seed in name_seeds:
# wallet_handle = looper.loop.run_until_complete(
# _gen_wallet_handler(pool_name, name))
# looper.loop.run_until_complete(
# create_and_store_my_did(wallet_handle,
# json.dumps({'seed': seed})))
# wallets.append(wallet_handle)
w = Wallet(name)
w.addIdentifier(seed=seed.encode())
wallets.append(w)
return wallets
def new_client_request(role, name, creatorWallet):
wallet = Wallet(name)
wallet.addIdentifier()
idr = wallet.defaultId
op = {
TXN_TYPE: NYM,
TARGET_NYM: idr,
ALIAS: name,
VERKEY: wallet.getVerkey(idr)
}
if role:
op[ROLE] = role
return creatorWallet.signOp(op), wallet
def test_wallet_multisig():
wallet = Wallet()
idr1, signer1 = wallet.addIdentifier()
idr2, signer2 = wallet.addIdentifier()
idr3, signer3 = wallet.addIdentifier()
authnr = CoreAuthNr()
for idr, signer in [(idr1, signer1), (idr2, signer2), (idr3, signer3)]:
authnr.addIdr(idr, signer.verkey)
def serz(req):
return {k: v for k, v in req.as_dict.items()
if k not in authnr.excluded_from_signing}
op = randomOperation()
req = wallet.sign_using_multi_sig(op=op, identifier=idr1)
assert len(req.signatures) == 1
req_data = serz(req)
assert set(authnr.authenticate_multi(req_data, req.signatures, 1)) == {idr1, }
with pytest.raises(InsufficientSignatures):
authnr.authenticate_multi(req_data, req.signatures, 2)
req = wallet.sign_using_multi_sig(request=req, identifier=idr2)
assert len(req.signatures) == 2
req_data = serz(req)
assert set(authnr.authenticate_multi(req_data, req.signatures, 2)) == {idr1,
idr2}
with pytest.raises(InsufficientSignatures):
authnr.authenticate_multi(req_data, req.signatures, 3)
wallet.do_multi_sig_on_req(req, identifier=idr3)
assert len(req.signatures) == 3
req_data = serz(req)
assert set(authnr.authenticate_multi(req_data, req.signatures, 3)) == {idr1,
idr2,
idr3}
def sendAddNewClient(role, name, creatorClient, creatorWallet):
wallet = Wallet(name)
wallet.addIdentifier()
idr = wallet.defaultId
op = {
TXN_TYPE: NYM,
TARGET_NYM: idr,
ALIAS: name,
VERKEY: wallet.getVerkey(idr)
}
if role:
op[ROLE] = role
req = creatorWallet.signOp(op)
creatorClient.submitReqs(req)
return req, wallet
def __init__(self,
name: str = None,
supportedDidMethods: DidMethods = None):
PWallet.__init__(self, name, supportedDidMethods or DefaultDidMethods)
TrustAnchoring.__init__(self)
# Copy the class version to the instance for the version
# to be serialized when the wallet is persisted
setattr(self, getClassVersionKey(Wallet), Wallet.CLASS_VERSION)
self._attributes = {} # type: Dict[(str, Identifier,
# Optional[Identifier]), Attribute]
self.env = None # Helps to know associated environment
self._nodes = {}
self._upgrades = {}
self._pconfigs = {}
self._connections = OrderedDict() # type: Dict[str, Connection]
# Note, ordered dict to make iteration deterministic
self.knownIds = {} # type: Dict[str, Identifier]
# transactions not yet submitted
self._pending = deque() # type Tuple[Request, Tuple[str, Identifier,
# Optional[Identifier]]
# pending transactions that have been prepared (probably submitted)
self._prepared = {} # type: Dict[(Identifier, int), Request]
self.lastKnownSeqs = {} # type: Dict[str, int]
self.replyHandler = {
ATTRIB: self._attribReply,
GET_ATTR: self._getAttrReply,
NYM: self._nymReply,
GET_NYM: self._getNymReply,
GET_TXNS: self._getTxnsReply,
NODE: self._nodeReply,
POOL_UPGRADE: self._poolUpgradeReply,
POOL_CONFIG: self._poolConfigReply
}
def setupClients(count: int,
looper: Looper,
nodes: Sequence[TestNode] = None,
nodeReg=None,
tmpdir=None):
wallets = {}
clients = {}
for i in range(count):
name = "test-wallet-{}".format(i)
wallet = Wallet(name)
idr, _ = wallet.addIdentifier()
verkey = wallet.getVerkey(idr)
client, _ = setupClient(looper,
nodes,
nodeReg,
tmpdir,
identifier=idr,
verkey=verkey)
clients[client.name] = client
wallets[client.name] = wallet
return clients, wallets
def addNewClient(role, looper, creatorClient: Client, creatorWallet: Wallet,
name: str):
wallet = Wallet(name)
wallet.addIdentifier()
idr = wallet.defaultId
op = {
TXN_TYPE: NYM,
ROLE: role,
TARGET_NYM: idr,
ALIAS: name,
VERKEY: wallet.getVerkey(idr)
}
req = creatorWallet.signOp(op)
creatorClient.submitReqs(req)
nodeCount = len(creatorClient.nodeReg)
looper.run(
eventually(checkSufficientRepliesRecvd,
creatorClient.inBox,
req.reqId,
1,
retryWait=1,
timeout=3 * nodeCount))
return wallet
def addNewClient(role, looper, creatorClient: Client, creatorWallet: Wallet,
name: str):
wallet = Wallet(name)
wallet.addIdentifier()
idr = wallet.defaultId
op = {
TXN_TYPE: NYM,
ROLE: role,
TARGET_NYM: idr,
ALIAS: name,
VERKEY: wallet.getVerkey(idr)
}
req = creatorWallet.signOp(op)
creatorClient.submitReqs(req)
nodeCount = len(creatorClient.nodeReg)
looper.run(eventually(checkSufficientRepliesRecvd, creatorClient.inBox,
req.reqId, 1,
retryWait=1, timeout=3 * nodeCount))
return wallet
def __init__(self,
name: str=None,
supportedDidMethods: DidMethods=None):
PWallet.__init__(self,
name,
supportedDidMethods or DefaultDidMethods)
TrustAnchoring.__init__(self)
self._attributes = {} # type: Dict[(str, Identifier,
# Optional[Identifier]), Attribute]
self.env = None # Helps to know associated environment
self._nodes = {}
self._upgrades = {}
self._pconfigs = {}
self._connections = OrderedDict() # type: Dict[str, Connection]
# Note, ordered dict to make iteration deterministic
self.knownIds = {} # type: Dict[str, Identifier]
# transactions not yet submitted
self._pending = deque() # type Tuple[Request, Tuple[str, Identifier,
# Optional[Identifier]]
# pending transactions that have been prepared (probably submitted)
self._prepared = {} # type: Dict[(Identifier, int), Request]
self.lastKnownSeqs = {} # type: Dict[str, int]
self.replyHandler = {
ATTRIB: self._attribReply,
GET_ATTR: self._getAttrReply,
NYM: self._nymReply,
GET_NYM: self._getNymReply,
GET_TXNS: self._getTxnsReply,
NODE: self._nodeReply,
POOL_UPGRADE: self._poolUpgradeReply,
POOL_CONFIG: self._poolConfigReply
}
def test_wallet_multisig():
wallet = Wallet()
idr1, signer1 = wallet.addIdentifier()
idr2, signer2 = wallet.addIdentifier()
idr3, signer3 = wallet.addIdentifier()
authnr = CoreAuthNr()
for idr, signer in [(idr1, signer1), (idr2, signer2), (idr3, signer3)]:
authnr.addIdr(idr, signer.verkey)
def serz(req):
return {
k: v
for k, v in req.as_dict.items()
if k not in authnr.excluded_from_signing
}
op = randomOperation()
request = Request(reqId=Request.gen_req_id(),
operation=op,
protocolVersion=CURRENT_PROTOCOL_VERSION,
identifier=idr1)
req = wallet.sign_using_multi_sig(request=request, identifier=idr1)
assert len(req.signatures) == 1
req_data = serz(req)
assert set(authnr.authenticate_multi(req_data, req.signatures, 1)) == {
idr1,
}
with pytest.raises(InsufficientSignatures):
authnr.authenticate_multi(req_data, req.signatures, 2)
req = wallet.sign_using_multi_sig(request=req, identifier=idr2)
assert len(req.signatures) == 2
req_data = serz(req)
assert set(authnr.authenticate_multi(req_data, req.signatures,
2)) == {idr1, idr2}
with pytest.raises(InsufficientSignatures):
authnr.authenticate_multi(req_data, req.signatures, 3)
wallet.do_multi_sig_on_req(req, identifier=idr3)
assert len(req.signatures) == 3
req_data = serz(req)
assert set(authnr.authenticate_multi(req_data, req.signatures,
3)) == {idr1, idr2, idr3}
def test_wallet():
return Wallet("TestWallet")
"""
The client has a slightly different node registry than the nodes. The
Nodes have two network interfaces, one for other nodes, and one for
client. This registry points to the nodes' client-facing interfaces.
"""
cliNodeReg = {
'AlphaC': ('127.0.0.1', 7561),
'BetaC': ('127.0.0.1', 7563),
'GammaC': ('127.0.0.1', 7565),
'DeltaC': ('127.0.0.1', 7567)
}
"""
Create a wallet to the keys that the client will use to have a
secure communication with the nodes.
"""
wallet = Wallet("my_wallet")
"""
Now the wallet needs to have one keypair, so lets add it.
"""
wallet.addIdentifier()
"""
A bi-directional connection is made from the client. This is the ip
address and port for the client's interfact to the nodes.
"""
client_addr = ("127.0.0.1", 8000)
"""
Create a client.
"""
clientName = "my_client_id"
client = Client(name=clientName,
ha=client_addr,
def sendRandomRequests(wallet: Wallet, client: Client, count: int):
logger.debug('{} random requests will be sent'.format(count))
reqs = [wallet.signOp(randomOperation()) for _ in range(count)]
return client.submitReqs(*reqs)
def sendRandomRequests(wallet: Wallet, client: Client, count: int):
reqs = [wallet.signOp(randomOperation()) for _ in range(count)]
return client.submitReqs(*reqs)
"""
The client has a slightly different node registry than the nodes. The
Nodes have two network interfaces, one for other nodes, and one for
client. This registry points to the nodes' client-facing interfaces.
"""
cliNodeReg = {
'AlphaC': ('127.0.0.1', 7561),
'BetaC': ('127.0.0.1', 7563),
'GammaC': ('127.0.0.1', 7565),
'DeltaC': ('127.0.0.1', 7567)}
"""
Create a wallet to the keys that the client will use to have a
secure communication with the nodes.
"""
wallet = Wallet("my_wallet")
"""
Now the wallet needs to have one keypair, so lets add it.
"""
wallet.addIdentifier()
"""
A bi-directional connection is made from the client. This is the ip
address and port for the client's interfact to the nodes.
"""
client_addr = ("127.0.0.1", 8000)
"""
Create a client.
"""
def create_client_wallet(self, seed):
""" Create a plenum client wallet from a seed. """
wallet = Wallet()
wallet.addIdentifier(seed=seed.encode())
return wallet