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 addUser(looper, creatorClient, creatorWallet, name, addVerkey=True):
wallet = Wallet(name)
signer = DidSigner()
idr, _ = wallet.addIdentifier(signer=signer)
verkey = wallet.getVerkey(idr) if addVerkey else None
createNym(looper, idr, creatorClient, creatorWallet, verkey=verkey)
return wallet
def gen_defs(cls, ips, node_count, node_names, node_ports, client_ports):
"""
Generates some default steward and node definitions for tests
:param ips: array of ip addresses
:param node_count: number of stewards/nodes
:return: duple of steward and node definitions
"""
steward_defs = []
node_defs = []
for i in range(1, node_count + 1):
d = adict()
d.name = "Steward" + str(i)
d.sigseed = cls.get_signing_seed()
s_signer = DidSigner(seed=d.sigseed)
d.nym = s_signer.identifier
d.verkey = s_signer.verkey
steward_defs.append(d)
name = node_names[i - 1]
sigseed = cls.get_signing_seed()
node_defs.append(
NodeDef(name=name,
ip=ips[i - 1],
port=node_ports[i - 1],
client_port=client_ports[i - 1],
idx=i,
sigseed=sigseed,
verkey=Signer(sigseed).verhex,
steward_nym=d.nym))
return steward_defs, node_defs
def put_load():
port = genHa()[1]
ha = HA('0.0.0.0', port)
name = "hello"
wallet = Wallet(name)
wallet.addIdentifier(signer=DidSigner(
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,
customTimeoutPerReq=100,
override_timeout_limit=True)
print('>>> Got replies for {} requests << in {}'.format(
numReqs // splits,
perf_counter() - s))
end = perf_counter()
print('>>>Total {} in {}<<<'.format(numReqs, end - start))
exit(0)
def philCli(be, do, philCLI, trusteeCli):
be(philCLI)
do('prompt Phil', expect=prompt_is('Phil'))
do('new keyring Phil',
expect=['New keyring Phil created', 'Active keyring set to "Phil"'])
phil_seed = '11111111111111111111111111111111'
phil_signer = DidSigner(seed=phil_seed.encode())
mapper = {'seed': phil_seed, 'idr': phil_signer.identifier}
do('new key with seed {seed}',
expect=[
'Key created in keyring Phil', 'Identifier for key is {idr}',
'Current identifier set to {idr}'
],
mapper=mapper)
addNym(be,
do,
trusteeCli,
phil_signer.identifier,
verkey=phil_signer.verkey,
role=Roles.TRUSTEE.name)
return philCLI
def newSigner():
while True:
signer = DidSigner()
idr = signer.identifier
if idr not in usedIdentifiers:
usedIdentifiers.add(idr)
return signer
def _add_did(role, did_name, with_verkey=True):
nonlocal data
data['seeds'][did_name] = did_name + '0' * (32 - len(did_name))
t_sgnr = DidSigner(seed=data['seeds'][did_name].encode())
verkey = t_sgnr.full_verkey if with_verkey else None
data['txns'].append(
Member.nym_txn(nym=t_sgnr.identifier,
verkey=verkey,
role=role.value,
name=did_name,
creator=trustee.did)
)
if verkey:
(sdk_did, sdk_verkey) = looper.loop.run_until_complete(
create_and_store_my_did(
trustee.wallet_handle,
json.dumps({'seed': data['seeds'][did_name]}))
)
return DID(
did=t_sgnr.identifier, role=role, verkey=verkey,
creator=trustee, wallet_handle=trustee.wallet_handle
)
def acceptInvitation(self, link: Union[str, Link]):
if isinstance(link, str):
link = self.wallet.getLink(link, required=True)
elif isinstance(link, Link):
pass
else:
raise TypeError("Type of link must be either string or Link but "
"provided {}".format(type(link)))
# TODO should move to wallet in a method like accept(link)
if not link.localIdentifier:
signer = DidSigner()
self.wallet.addIdentifier(signer=signer)
link.localIdentifier = signer.identifier
msg = {
TYPE: ACCEPT_INVITE,
# TODO should not send this... because origin should be the sender
NONCE: link.invitationNonce,
VERKEY: self.wallet.getVerkey(link.localIdentifier)
}
logger.debug("{} accepting invitation from {} with id {}".
format(self.name, link.name, link.localIdentifier))
self.agentLogger.info('Invitation accepted with nonce {} from id {}'
.format(link.invitationNonce,
link.localIdentifier))
self.signAndSend(msg, None, None, link.name)
def philCli(be, do, philCLI, trusteeCli, poolTxnData):
be(philCLI)
do('prompt Phil', expect=prompt_is('Phil'))
do('new wallet Phil',
expect=['New wallet Phil created', 'Active wallet set to "Phil"'])
phil_seed = randomSeed()
phil_signer = DidSigner(seed=phil_seed)
mapper = {'seed': phil_seed.decode(), 'idr': phil_signer.identifier}
do('new key with seed {seed}',
expect=[
'Key created in wallet Phil', 'DID for key is {idr}',
'Current DID set to {idr}'
],
mapper=mapper)
addNym(be,
do,
trusteeCli,
phil_signer.identifier,
verkey=phil_signer.verkey,
role=Roles.TRUSTEE.name)
return philCLI
def createAgent(agentClass,
name,
wallet=None,
basedirpath=None,
port=None,
loop=None,
clientClass=Client):
config = getConfig()
if not wallet:
wallet = Wallet(name)
wallet.addIdentifier(signer=DidSigner(
seed=randomString(32).encode('utf-8')))
if not basedirpath:
basedirpath = config.baseDir
if not port:
_, port = genHa()
client = create_client(base_dir_path=basedirpath, client_class=clientClass)
return agentClass(basedirpath=basedirpath,
client=client,
wallet=wallet,
port=port,
loop=loop)
def test_non_steward_cannot_create_trust_anchor(nodeSet, trustAnchor,
addedTrustAnchor, client1,
looper):
with whitelistextras("UnknownIdentifier"):
non_permission = Wallet()
signer = DidSigner()
non_permission.addIdentifier(signer=signer)
createNym(looper,
non_permission.defaultId,
trustAnchor,
addedTrustAnchor,
role=None,
verkey=non_permission.getVerkey())
op = add_nym_operation(seed=b'a secret trust anchor seed......',
role=TRUST_ANCHOR)
submitAndCheckRejects(looper=looper,
client=client1,
wallet=non_permission,
op=op,
identifier=non_permission.defaultId,
contains="UnauthorizedClientRequest")
def new_identity():
wallet = Wallet(randomString(5))
signer = DidSigner()
new_idr, _ = wallet.addIdentifier(signer=signer)
verkey = wallet.getVerkey(new_idr)
idy = Identity(identifier=new_idr, verkey=verkey, role=None)
return idy, wallet
def nymsAddedInQuickSuccession(looper, nodeSet, sdk_added_raw_attribute,
trustAnchor, trustAnchorWallet):
usigner = DidSigner()
nym = usigner.verkey
idy = Identity(identifier=nym)
trustAnchorWallet.addTrustAnchoredIdentity(idy)
# Creating a NYM request with same nym again
req = idy.ledgerRequest()
trustAnchorWallet._pending.appendleft((req, idy.identifier))
reqs = trustAnchorWallet.preparePending()
trustAnchor.submitReqs(*reqs)
def check():
assert trustAnchorWallet._trustAnchored[nym].seqNo
timeout = waits.expectedTransactionExecutionTime(len(nodeSet))
looper.run(eventually(check, timeout=timeout))
timeout = waits.expectedReqNAckQuorumTime()
looper.run(
eventually(checkNacks,
trustAnchor,
req.reqId,
"is already added",
retryWait=1,
timeout=timeout))
count = 0
for node in nodeSet:
for seq, txn in node.domainLedger.getAllTxn():
if txn[TXN_TYPE] == NYM and txn[TARGET_NYM] == usigner.identifier:
count += 1
assert (count == len(nodeSet))
def test_attr_with_no_dest_added(nodeSet, tdirWithClientPoolTxns, looper,
trustAnchor, addedTrustAnchor, attributeData):
user_wallet = Wallet()
signer = DidSigner()
user_wallet.addIdentifier(signer=signer)
client, _ = genTestClient(nodeSet,
tmpdir=tdirWithClientPoolTxns,
usePoolLedger=True)
client.registerObserver(user_wallet.handleIncomingReply)
looper.add(client)
looper.run(client.ensureConnectedToNodes())
makePendingTxnsRequest(client, user_wallet)
createNym(looper,
user_wallet.defaultId,
trustAnchor,
addedTrustAnchor,
role=None,
verkey=user_wallet.getVerkey())
attr1 = json.dumps({'age': "24"})
attrib = Attribute(name='test4 attribute',
origin=user_wallet.defaultId,
value=attr1,
dest=None,
ledgerStore=LedgerStore.RAW)
addAttributeAndCheck(looper, client, user_wallet, attrib)
def changeHA(looper, config, nodeName, nodeSeed, newNodeHA,
stewardName, stewardsSeed, newClientHA=None, basedir=None):
if not newClientHA:
newClientHA = HA(newNodeHA.host, newNodeHA.port + 1)
assert basedir is not None
# prepare steward wallet
stewardSigner = DidSigner(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, basedirpath=basedir)
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 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 client1Signer():
seed = b'client1Signer secret key........'
signer = DidSigner(seed=seed)
testable_verkey = friendlyToRaw(signer.identifier)
testable_verkey += friendlyToRaw(signer.verkey[1:])
testable_verkey = base58.b58encode(testable_verkey).decode("utf-8")
assert testable_verkey == '6JvpZp2haQgisbXEXE9NE6n3Tuv77MZb5HdF9jS5qY8m'
return signer
def testNewverkeyAddedToCID(be, do, philCli, trustAnchorSigner,
verkeyRemovedFromExistingCID):
newSigner = DidSigner()
addNym(be, do, philCli, trustAnchorSigner.identifier, newSigner.verkey)
getNym(
be, do, philCli, trustAnchorSigner.identifier,
getCurrentVerkeyIsgMsgs(trustAnchorSigner.identifier,
newSigner.verkey))
def req(poolTxnClientData):
_, seed = poolTxnClientData
signer = DidSigner(seed=seed)
request = {
f.IDENTIFIER.nm: signer.identifier,
f.REQ_ID.nm: int(time.time() * 10**6),
OPERATION: {
'amount': 62,
'type': 'buy'
},
f.PROTOCOL_VERSION.nm: CURRENT_PROTOCOL_VERSION
}
request[f.SIG.nm] = signer.sign(request)
return request
def gen_trustee_def(cls, idx):
d = adict()
d.name = 'Trustee' + str(idx)
d.sigseed = cls.getSigningSeed(d.name)
t_signer = DidSigner(seed=d.sigseed)
d.nym = t_signer.identifier
d.verkey = t_signer.verkey
return d
def newStewardVals():
newStewardSeed = randomSeed()
signer = DidSigner(seed=newStewardSeed)
return {
'newStewardSeed': newStewardSeed.decode(),
'newStewardIdr': signer.identifier,
'newStewardVerkey': signer.verkey
}
def gen_client_def(cls, idx):
d = adict()
d.name = "Client" + str(idx)
d.sigseed = cls.getSigningSeed(d.name)
c_signer = DidSigner(seed=d.sigseed)
d.nym = c_signer.identifier
d.verkey = c_signer.verkey
return d
def trustAnchorAdded(be, do, trusteeCli, nymAddedOut):
global vals
v = copy(vals)
v['remote'] = vals['newTrustAnchorIdr'][0]
v['remote_verkey'] = DidSigner(seed=vals['newTrustAnchorIdr'][1]).verkey
be(trusteeCli)
do('send NYM dest={{remote}} role={role} verkey={{remote_verkey}}'.format(
role=Roles.TRUST_ANCHOR.name), within=5, expect=nymAddedOut, mapper=v)
return v
def addRole(looper, creatorClient, creatorWallet, name, useDid=True,
addVerkey=True, role=None):
wallet = Wallet(name)
signer = DidSigner() if useDid else SimpleSigner()
idr, _ = wallet.addIdentifier(signer=signer)
verkey = wallet.getVerkey(idr) if addVerkey else None
createNym(looper, idr, creatorClient, creatorWallet, verkey=verkey,
role=role)
return wallet
def createClientAndWalletWithSeed(name, seed, ha=None):
if isinstance(seed, str):
seed = seed.encode()
if not ha:
port = genHa()[1]
ha = HA('0.0.0.0', port)
wallet = Wallet(name)
wallet.addIdentifier(signer=DidSigner(seed=seed))
client = Client(name, ha=ha)
return client, wallet
def __init__(self, identity_name, vault_path):
self.vault_path = vault_path
self.identity_name = identity_name
self.seed = self.get_signing_seed()
self.did = DidSigner(seed=self.seed).identifier
self.bls_generator = BlsGenerator(self.seed)
self.public_key = None
self.secret_key = None
self.sig_key = None
self.verif_key = None
def nonTrustAnchor(looper, nodeSet, tdir):
sseed = b'a secret trust anchor seed......'
signer = DidSigner(seed=sseed)
c, _ = genTestClient(nodeSet, tmpdir=tdir, usePoolLedger=True)
w = Wallet(c.name)
w.addIdentifier(signer=signer)
c.registerObserver(w.handleIncomingReply)
looper.add(c)
looper.run(c.ensureConnectedToNodes())
return c, w
def buildPoolClientAndWallet(clientData, tempDir, clientClass=None, walletClass=None):
walletClass = walletClass or Wallet
clientClass = clientClass or TestClient
name, sigseed = clientData
w = walletClass(name)
w.addIdentifier(signer=DidSigner(seed=sigseed))
client, _ = genTestClient(name=name, identifier=w.defaultId,
tmpdir=tempDir, usePoolLedger=True,
testClientClass=clientClass)
return client, w
def spawnClient(clientName, port, signerSeed, host='0.0.0.0'):
clientAddress = HA(host, port)
# from plenum.client.request_id_store import FileRequestIdStore
# walletFilePath = os.path.join(config.baseDir, "wallet")
# print("Storing request ids in {}".format(walletFilePath))
# store = FileRequestIdStore(walletFilePath)
# wallet = Wallet(clientName, store)
wallet = Wallet(clientName)
wallet.addIdentifier(signer=DidSigner(seed=signerSeed))
client = Client(clientName, ha=clientAddress)
return client, wallet
def updatedPoolTxnData(poolTxnData):
data = deepcopy(poolTxnData)
trusteeSeed = 'thisistrusteeseednotsteward12345'
signer = DidSigner(seed=trusteeSeed.encode())
t = Member.nym_txn(nym=signer.identifier,
name="Trustee1",
verkey=signer.verkey,
role=TRUSTEE,
txn_id="6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4a")
data["seeds"]["Trustee1"] = trusteeSeed
data["txns"].insert(0, t)
return data
