def nymsAddedInQuickSuccession(genned, addedSponsor, looper, sponsor,
sponsorWallet):
usigner = SimpleSigner()
nym = usigner.verstr
idy = Identity(identifier=nym)
sponsorWallet.addSponsoredIdentity(idy)
# Creating a NYM request with same nym again
req = idy.ledgerRequest()
sponsorWallet._pending.appendleft((req, idy.identifier))
reqs = sponsorWallet.preparePending()
sponsor.submitReqs(*reqs)
def check():
assert sponsorWallet._sponsored[nym].seqNo
looper.run(eventually(check, timeout=2))
looper.run(
eventually(checkNacks,
sponsor,
req.reqId,
"is already added",
retryWait=1,
timeout=15))
count = 0
for name, node in genned.nodes.items():
txns = node.domainLedger.getAllTxn()
for seq, txn in txns.items():
if txn[TXN_TYPE] == NYM and txn[TARGET_NYM] == usigner.verstr:
count += 1
assert (count == len(genned.nodes))
def genTestClient(nodes: TestNodeSet = None,
nodeReg=None,
tmpdir=None,
signer=None,
testClientClass=TestClient,
bootstrapKeys=True) -> TestClient:
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)
ha = genHa()
identifier = "testClient{}".format(ha.port)
signer = signer if signer else SimpleSigner(identifier)
tc = testClientClass(identifier,
nodeReg=nReg,
ha=ha,
basedirpath=tmpdir,
signer=signer)
if bootstrapKeys and nodes:
bootstrapClientKeys(tc, nodes)
return tc
def setupDefaultSigner(self):
"""
Create one SimpleSigner and add it to signers
against the client's name.
"""
self.signers = {self.name: SimpleSigner(self.name)}
self.defaultIdentifier = self.name
def aliceIsRunning(emptyLooper, tdirWithPoolTxns, aliceWallet):
aliceWallet.addSigner(signer=SimpleSigner())
alice = runAlice(aliceWallet.name,
aliceWallet,
basedirpath=tdirWithPoolTxns,
startRunning=False)
emptyLooper.add(alice)
return alice, aliceWallet
def nonSponsor(looper, nodeSet, tdir):
sseed = b'this is a secret sponsor seed...'
signer = SimpleSigner(seed=sseed)
c, _ = genTestClient(nodeSet, tmpdir=tdir)
w = Wallet(c.name)
w.addSigner(signer=signer)
c.registerObserver(w.handleIncomingReply)
looper.add(c)
looper.run(c.ensureConnectedToNodes())
return c, w
def anotherSponsor(genned, steward, stewardWallet, tdir, looper):
sseed = b'this is 1 secret sponsor seed...'
signer = SimpleSigner(seed=sseed)
c, _ = genTestClient(genned, tmpdir=tdir)
w = Wallet(c.name)
w.addSigner(signer=signer)
c.registerObserver(w.handleIncomingReply)
looper.add(c)
looper.run(c.ensureConnectedToNodes())
createNym(looper, signer.verstr, steward, stewardWallet, SPONSOR)
return c, w
def testNonSponsoredNymCanDoGetNym(genned, addedSponsor, sponsorWallet, tdir,
looper):
signer = SimpleSigner()
someClient, _ = genTestClient(genned, tmpdir=tdir)
wallet = Wallet(someClient.name)
wallet.addSigner(signer=signer)
someClient.registerObserver(wallet.handleIncomingReply)
looper.add(someClient)
looper.run(someClient.ensureConnectedToNodes())
needle = sponsorWallet.defaultId
makeGetNymRequest(someClient, wallet, needle)
looper.run(eventually(someClient.hasNym, needle, retryWait=1, timeout=5))
def run_node():
ip = '52.37.111.254'
cliNodeReg = OrderedDict([
# ('AlphaC', ('127.0.0.1', 8002)),
('AlphaC', (ip, 4002)),
('BetaC', (ip, 4004)),
('GammaC', (ip, 4006)),
('DeltaC', (ip, 4008))
])
with Looper(debug=False) as looper:
# Nodes persist keys when bootstrapping to other nodes and reconnecting
# using an ephemeral temporary directory when proving a concept is a
# nice way to keep things clean.
clientName = 'Joem'
# this seed is used by the signer to deterministically generate
# a signature verification key that is shared out of band with the
# consensus pool
seed = b'g034OTmx7qBRtywvCbKhjfALHnsdcJpl'
assert len(seed) == 32
signer = SimpleSigner(seed=seed)
assert signer.verstr == 'o7z4QmFkNB+mVkFI2BwX0H' \
'dm1BGhnz8psWnKYIXWTaQ='
client_address = ('0.0.0.0', 8000)
tmpdir = os.path.join(tempfile.gettempdir(), "sovrin_clients",
clientName)
client = Client(clientName,
cliNodeReg,
ha=client_address,
signer=signer,
basedirpath=tmpdir)
looper.add(client)
# give the client time to connect
looper.runFor(3)
# a simple message
msg = {TXN_TYPE: NYM}
# submit the request to the pool
request, = client.submit(msg)
# allow time for the request to be executed
looper.runFor(3)
reply, status = client.getReply(request.reqId)
print('')
print('Reply: {}\n'.format(reply))
print('Status: {}\n'.format(status))
def testAddNewClient(txnPoolNodeSet, tdirWithPoolTxns, poolTxnStewardData,
txnPoolCliNodeReg):
with Looper(debug=True) as looper:
name, pkseed, sigseed = poolTxnStewardData
stewardSigner = SimpleSigner(seed=sigseed)
client = TestClient(name=name,
nodeReg=txnPoolCliNodeReg,
ha=genHa(),
signer=stewardSigner,
basedirpath=tdirWithPoolTxns)
looper.add(client)
looper.run(client.ensureConnectedToNodes())
sigseed = b'55555555555555555555555555555555'
pkseed = b'66666666666666666666666666666666'
newSigner = SimpleSigner(sigseed)
priver = Privateer(pkseed)
req, = client.submit({
TXN_TYPE: NEW_CLIENT,
ORIGIN: client.defaultIdentifier,
TARGET_NYM: newSigner.verstr,
DATA: {
"pubkey": priver.pubhex.decode(),
"alias": "Robert"
}
})
looper.run(
eventually(checkSufficientRepliesRecvd,
client.inBox,
req.reqId,
1,
retryWait=1,
timeout=5))
def chk():
for node in txnPoolNodeSet:
assert newSigner.verstr in node.clientAuthNr.clients
looper.run(eventually(chk, retryWait=1, timeout=5))
def acmeIsRunning(emptyLooper, tdirWithPoolTxns, acmeAgentPort, acmeWallet):
acmeWallet.addSigner(signer=SimpleSigner(
seed=b'Acme0000000000000000000000000000'))
acme = runAcme(acmeWallet.name,
acmeWallet,
basedirpath=tdirWithPoolTxns,
port=acmeAgentPort,
startRunning=False)
acmeWallet.pendSyncRequests()
prepared = acmeWallet.preparePending()
acme.client.submitReqs(*prepared)
emptyLooper.add(acme)
return acme, acmeWallet
def testNodesReceiveClientMsgs(txnPoolNodeSet, tdirWithPoolTxns,
poolTxnClientData, txnPoolCliNodeReg):
with Looper(debug=True) as looper:
name, pkseed, sigseed = poolTxnClientData
signer = SimpleSigner(seed=sigseed)
client = TestClient(name=name,
nodeReg=txnPoolCliNodeReg,
ha=genHa(),
signer=signer,
basedirpath=tdirWithPoolTxns)
looper.add(client)
looper.run(client.ensureConnectedToNodes())
sendReqsToNodesAndVerifySuffReplies(looper, client, 1)
def testNonStewardCannotCreateASponsor(genned, client1, wallet1, looper):
seed = b'this is a secret sponsor seed...'
sponsorSigner = SimpleSigner(seed)
sponsorNym = sponsorSigner.verstr
op = {TARGET_NYM: sponsorNym, TXN_TYPE: NYM, ROLE: SPONSOR}
submitAndCheckNacks(looper=looper,
client=client1,
wallet=wallet1,
op=op,
identifier=wallet1.defaultId,
contains="InvalidIdentifier")
def testNonSponsorCannotCreateAUser(genned, looper, nonSponsor):
client, wallet = nonSponsor
useed = b'this is a secret apricot seed...'
userSigner = SimpleSigner(seed=useed)
userNym = userSigner.verstr
op = {TARGET_NYM: userNym, TXN_TYPE: NYM}
submitAndCheckNacks(looper,
client,
wallet,
op,
identifier=wallet.defaultId,
contains="InvalidIdentifier")
def run_node():
cliNodeReg = OrderedDict([('AlphaC', ('127.0.0.1', 8002)),
('BetaC', ('127.0.0.1', 8004)),
('GammaC', ('127.0.0.1', 8006)),
('DeltaC', ('127.0.0.1', 8008))])
with Looper(debug=False) as looper:
# Nodes persist keys when bootstrapping to other nodes and reconnecting
# using an ephemeral temporary directory when proving a concept is a
# nice way to keep things clean.
with TemporaryDirectory() as tmpdir:
clientName = 'Joe'
# this seed is used by the signer to deterministically generate
# a signature verification key that is shared out of band with the
# consensus pool
seed = b'a 32 byte super secret seed.....'
assert len(seed) == 32
signer = SimpleSigner(clientName, seed)
assert signer.verkey == b'cffbb88a142be2f62d1b408818e21a2f' \
b'887c4442ae035a260d4cc2ec28ae24d6'
client_address = ('127.0.0.1', 8000)
client = Client(clientName,
cliNodeReg,
ha=client_address,
signer=signer,
basedirpath=tmpdir)
looper.add(client)
# give the client time to connect
looper.runFor(3)
# a simple message
msg = {'life_answer': 42}
# submit the request to the pool
request, = client.submit(msg)
# allow time for the request to be executed
looper.runFor(3)
reply, status = client.getReply(request.reqId)
print('')
print('Reply: {}\n'.format(reply))
print('Status: {}\n'.format(status))
def faberIsRunning(emptyLooper, tdirWithPoolTxns, faberAgentPort, faberWallet):
faberWallet.addSigner(signer=SimpleSigner(
seed=b'Faber000000000000000000000000000'))
faber = runFaber(faberWallet.name,
faberWallet,
basedirpath=tdirWithPoolTxns,
port=faberAgentPort,
startRunning=False,
bootstrap=False)
faber.addKeyIfNotAdded()
faberWallet.pendSyncRequests()
prepared = faberWallet.preparePending()
faber.client.submitReqs(*prepared)
# faber.bootstrap()
emptyLooper.add(faber)
return faber, faberWallet
def run_node():
with Looper(debug=False) as looper:
# Nodes persist keys when bootstrapping to other nodes and reconnecting
# using an ephemeral temporary directory when proving a concept is a
# nice way to keep things clean.
config = getConfig()
basedirpath = os.path.expanduser(config.baseDir)
cliNodeReg = {k: v[0] for k, v in config.cliNodeReg.items()}
clientName = 'Alice'
# this seed is used by the signer to deterministically generate
# a signature verification key that is shared out of band with the
# consensus pool
seed = b'22222222222222222222222222222222'
assert len(seed) == 32
signer = SimpleSigner(clientName, seed)
client_address = ('0.0.0.0', 9700)
client = Client(clientName,
cliNodeReg,
ha=client_address,
signer=signer,
basedirpath=basedirpath)
looper.add(client)
# give the client time to connect
looper.runFor(3)
# a simple message
msg = {'life_answer': 42}
# submit the request to the pool
request, = client.submit(msg)
# allow time for the request to be executed
looper.runFor(3)
reply, status = client.getReply(request.reqId)
print('')
print('Reply: {}\n'.format(reply))
print('Status: {}\n'.format(status))
def newClient(self, clientName, seed=None, identifier=None, signer=None):
try:
self.ensureValidClientId(clientName)
client_addr = self.nextAvailableClientAddr()
if not signer:
seed = seed.encode("utf-8") if seed else None
signer = SimpleSigner(identifier=identifier, seed=seed) \
if (seed or identifier) else None
client = self.ClientClass(clientName,
ha=client_addr,
nodeReg=self.cliNodeReg,
signer=signer,
basedirpath=self.basedirpath)
self.looper.add(client)
for node in self.nodes.values():
self.bootstrapClientKey(client, node)
self.clients[clientName] = client
self.clientWC.words = list(self.clients.keys())
return client
except ValueError as ve:
self.print(ve.args[0], Token.Error)
def sponsorSigner():
return SimpleSigner()
looper = Looper(debug=True)
config = getConfig()
basedirpath = config.baseDir
# Steward that will be used to create a new steward by submitting a
# NYM transaction
# TODO: Make this name configurable
clientName = 'Steward1'
# This is because i know the seed.
# TODO: Make this configurable, maybe read the private key/seed from
# command line
seed = ('0' * (32 - len(clientName)) + clientName).encode()
signer = SimpleSigner(seed=seed)
client_address = ('0.0.0.0', 9760)
client = Client(clientName,
nodeReg=None,
ha=client_address,
signer=signer,
basedirpath=basedirpath)
looper.add(client)
# give the client time to connect
# TODO: Use looper and `eventually` to check whether request succeeded
looper.runFor(3)
# Steward that will be used to create a new node by submitting a
def client1Signer():
seed = b'client1Signer secret key........'
signer = SimpleSigner(seed=seed)
assert signer.verstr == 'TuIpuBcx6P4S0Ez5LUr3HVpWERVHK56XONixonwcAf4='
return signer
def testReconstitutedClientCreatesTheSameSig(cli, sig, msg):
cli2 = SimpleSigner(424242, seed=cli.seed)
sig2 = cli2.sign(msg)
assert sig == sig2
def cli():
return SimpleSigner(424242)
def testReconstitutedClientCreatesTheSameSig(cli, sig, msg):
cli2 = SimpleSigner(424242, seed=cli.seed)
sig2 = cli2.sign(msg)
assert sig == sig2
def _newWallet(name=None):
signer = SimpleSigner()
w = Wallet(name or signer.identifier)
w.addSigner(signer=signer)
return w
