def test_habitat_reinitialization():
"""
Test Reinitializing Habitat class
"""
if os.path.exists('/usr/local/var/keri/db/bob-test'):
shutil.rmtree('/usr/local/var/keri/db/bob-test')
if os.path.exists('/usr/local/var/keri/keep/bob-test'):
shutil.rmtree('/usr/local/var/keri/keep/bob-test')
name = "bob-test"
with basing.openDB(name=name, clear=True, temp=False) as db, \
keeping.openKS(name=name, clear=True, temp=False) as ks:
hab = habbing.Habitat(name=name, ks=ks, db=db, icount=1, temp=False)
oidig = hab.iserder.dig
opre = hab.pre
opub = hab.kever.verfers[0].qb64
odig = hab.kever.serder.dig
assert hab.ridx == 0
with basing.openDB(name=name, temp=False) as db, keeping.openKS(name=name, temp=False) as ks:
hab = habbing.Habitat(name=name, ks=ks, db=db, icount=1, temp=False)
assert hab.pre in hab.prefixes
assert hab.pre in hab.kevers
assert hab.iserder.dig == oidig
hab.rotate()
assert hab.ridx == 1
assert opub != hab.kever.verfers[0].qb64
assert odig != hab.kever.serder.dig
npub = hab.kever.verfers[0].qb64
ndig = hab.kever.serder.dig
assert opre == hab.pre
assert hab.kever.verfers[0].qb64 == npub
assert hab.ridx == 1
assert hab.kever.serder.dig != odig
assert hab.kever.serder.dig == ndig
hab.ks.close(clear=True)
hab.db.close(clear=True)
assert not os.path.exists(hab.ks.path)
assert not os.path.exists(hab.db.path)
"""End Test"""
def __init__(self, name, opts, **kwa):
ks = keeping.Keeper(name=name,
temp=False) # not opened by default, doer opens
self.ksDoer = keeping.KeeperDoer(
keeper=ks) # doer do reopens if not opened and closes
db = basing.Baser(name=name,
temp=False) # not opened by default, doer opens
self.dbDoer = basing.BaserDoer(
baser=db) # doer do reopens if not opened and closes
hab = habbing.Habitat(name=name,
ks=ks,
db=db,
temp=False,
transferable=opts.transferable,
isith=opts.isith,
icount=opts.icount,
nsith=opts.nsith,
ncount=opts.ncount,
wits=opts.witnesses)
self.habDoer = habbing.HabitatDoer(habitat=hab) # setup doer
self.witDoer = agenting.WitnessReceiptor(hab=hab)
doers = [
self.inceptDo, self.ksDoer, self.dbDoer, self.habDoer, self.witDoer
]
self.hab = hab
super(InceptDoer, self).__init__(doers=doers, **kwa)
def test_build_proof():
sidSalt = coring.Salter(raw=b'0123456789abcdef').qb64
with basing.openDB(name="sid") as sigDB, \
keeping.openKS(name="sid") as sigKS:
sigHab = habbing.Habitat(ks=sigKS, db=sigDB, salt=sidSalt, icount=3, ncount=3, temp=True)
sed = dict()
sed["$id"] = ""
sed["$schema"] = "http://json-schema.org/draft-07/schema#"
sed.update(dict(
type="object",
properties=dict(
id=dict(
type="string"
),
lei=dict(
type="string"
)
)
))
schemer = scheming.Schemer(sed=sed, typ=scheming.JSONSchema(), code=coring.MtrDex.Blake3_256)
credSubject = dict(
id="did:keri:Efaavv0oadfghasdfn443fhbyyr4v", # this needs to be generated from a KEL
lei="254900OPPU84GM83MG36",
issuanceDate="2021-06-27T21:26:21.233257+00:00",
)
cache = CacheResolver()
cache.add(schemer.said, schemer.raw)
creder = credential(issuer=sigHab.pre,
schema=schemer.said,
subject=credSubject,
typ=JSONSchema(resolver=cache))
sigHab.rotate()
sigHab.rotate()
sigHab.rotate()
sigHab.rotate()
prefixer = coring.Prefixer(qb64=sigHab.kever.prefixer.qb64)
seqner = coring.Seqner(sn=sigHab.kever.lastEst.s)
diger = coring.Diger(qb64=sigHab.kever.lastEst.d)
sigers = sigHab.mgr.sign(ser=creder.raw, verfers=sigHab.kever.verfers, indexed=True)
proof = buildProof(prefixer, seqner, diger, sigers)
assert proof == (
b'-FABEiRjCnZfca8gUZqecerjGpjkiY8dIkGudP6GfapWi5MU0AAAAAAAAAAAAAAAAAAAAABAECc96yX1sYswnD6LXEcoNuJ0e'
b'hi8gkFMEGedqURhXMBU-AADAAGcSUhma16SY3MiKU7n6mK3JzWS2oAiBRB-jeycIDrQ2Z-36QHrMorzRAO9Iw7FvIKrneaLZP'
b'whz6DFFiXM4oBgAB1g2CudOfOFd9BqesyAIlCDRAkxAQynrED4_ot1MkhKwjmK71XUx1Xer25iWtHMa9sny07AsTO-KE3vu9e'
b'qTPDQAClDQMXWg3I8qeVEjA6JA9xBW2uESMtMzNVQ8lH31UCizqYVjXort--QEJTsfIt_b0Qq1JOCtaj7Y6U-DWHoulBA')
prefixer, seqner, diger, isigers = parseProof(proof)
assert prefixer.qb64 == sigHab.pre
assert diger.qb64 == sigHab.kever.lastEst.d
assert seqner.sn == 4
assert len(isigers) == 3
def runAgent(controller,
name="agent",
httpPort=5620,
tcp=5621,
adminHttpPort=5623,
adminTcpPort=5624,
expire=0.0):
"""
Setup and run one agent
"""
logger = help.ogler.getLogger()
ks = keeping.Keeper(name=name,
temp=False) # not opened by default, doer opens
ksDoer = keeping.KeeperDoer(
keeper=ks) # doer do reopens if not opened and closes
db = basing.Baser(name=name, temp=False,
reload=True) # not opened by default, doer opens
dbDoer = basing.BaserDoer(
baser=db) # doer do reopens if not opened and closes
# setup habitat
hab = habbing.Habitat(name=name, ks=ks, db=db, temp=False, create=False)
habDoer = habbing.HabitatDoer(habitat=hab) # setup doer
# kvy = eventing.Kevery(db=hab.db, local=False)
# setup doers
server = tcpServing.Server(host="", port=tcp)
tcpServerDoer = tcpServing.ServerDoer(server=server)
directant = directing.Directant(hab=hab, server=server)
wallet = walleting.Wallet(hab=hab, name=name)
jsonSchema = scheming.JSONSchema(resolver=scheming.jsonSchemaCache)
issueHandler = handling.IssueHandler(wallet=wallet, typ=jsonSchema)
requestHandler = handling.RequestHandler(wallet=wallet, typ=jsonSchema)
exchanger = exchanging.Exchanger(hab=hab,
handlers=[issueHandler, requestHandler])
app = falcon.App()
exnServer = httping.AgentExnServer(exc=exchanger, app=app)
httpKelServer = httping.AgentKelServer(hab=hab, app=app)
server = http.Server(port=httpPort, app=exnServer.app)
httpServerDoer = http.ServerDoer(server=server)
doers = [
ksDoer, dbDoer, habDoer, exchanger, directant, tcpServerDoer,
exnServer, httpServerDoer, httpKelServer
]
doers.extend(adminInterface(controller, hab, adminHttpPort, adminTcpPort))
try:
tock = 0.03125
doist = doing.Doist(limit=expire, tock=tock, real=True)
doist.do(doers=doers)
except kering.ConfigurationError:
print(f"prefix for {name} does not exist, incept must be run first", )
def setupController(secrets, did, lei, witnessPort=5621, peerPort=5629, indirect=False):
"""
Setup and return doers list to run controller
"""
name = "ian"
secrecies = []
for secret in secrets: # convert secrets to secrecies
secrecies.append([secret])
# setup databases for dependency injection
ks = keeping.Keeper(name=name, temp=True) # not opened by default, doer opens
ksDoer = keeping.KeeperDoer(keeper=ks) # doer do reopens if not opened and closes
db = basing.Baser(name=name, temp=True) # not opened by default, doer opens
dbDoer = basing.BaserDoer(baser=db) # doer do reopens if not opened and closes
# setup habitat
hab = habbing.Habitat(name=name, ks=ks, db=db, temp=True, secrecies=secrecies)
habDoer = habbing.HabitatDoer(habitat=hab) # setup doer
iss = issuing.Issuer(hab=hab, name=name, noBackers=True)
issDoer = issuing.IssuerDoer(issuer=iss)
# setup doers
regDoer = basing.BaserDoer(baser=iss.reger)
path = os.path.dirname(__file__)
path = os.path.join(path, 'logs')
wl = wiring.WireLog(samed=True, filed=True, name=name, prefix='demo', reopen=True,
headDirPath=path)
wireDoer = wiring.WireLogDoer(wl=wl)
witnessClient = clienting.Client(host='127.0.0.1', port=witnessPort, wl=wl)
witnessClientDoer = clienting.ClientDoer(client=witnessClient)
peerClient = clienting.Client(host='127.0.0.1', port=peerPort, wl=wl)
peerClientDoer = clienting.ClientDoer(client=peerClient)
director = IanDirector(hab=hab,
issuer=iss,
witnessClient=witnessClient,
peerClient=peerClient,
tock=0.125,
recipientIdentifier=did,
lei=lei)
reactor = directing.Reactor(hab=hab, client=witnessClient, indirect=indirect)
peerReactor = directing.Reactor(hab=hab, client=peerClient, indirect=indirect)
logger.info("\nDirect Mode demo of %s:\nNamed %s to TCP port %s.\n\n",
hab.pre, hab.name, witnessPort)
return [ksDoer, dbDoer, habDoer, issDoer, regDoer, wireDoer, witnessClientDoer, director,
reactor, peerClientDoer, peerReactor]
def test_habitat():
"""
Test Habitat class
"""
hab = habbing.Habitat(temp=True)
assert hab.name == "test"
hab.db.close(clear=True)
hab.ks.close(clear=True)
"""End Test"""
def __init__(self, real=False, limit=None, doers=None, **kwa):
self.hab = habbing.Habitat(name='kli', temp=False)
kli = koming.Komer(db=self.hab.db, schema=KLIRecord,
subkey='kli.').get((self.hab.pre, ))
super().__init__(real, limit, doers, **kwa)
self.client = clienting.Client(tymth=self.tymen(),
host='127.0.0.1',
port=5678)
clientDoer = clienting.ClientDoer(client=self.client)
self.extend([clientDoer, self.infoDoer])
def setupController(secrets,
vcfile,
did,
lei,
remotePort=5621,
indirect=False):
"""
Setup and return doers list to run controller
"""
secrecies = []
for secret in secrets: # convert secrets to secrecies
secrecies.append([secret])
# setup habitat
hab = habbing.Habitat(name="ian", secrecies=secrecies, temp=True)
logger.info("\nDirect Mode demo of %s:\nNamed %s to TCP port %s.\n\n",
hab.pre, hab.name, remotePort)
iss = issuing.Issuer(hab=hab, name="ian", noBackers=True)
# setup doers
ksDoer = keeping.KeeperDoer(
keeper=hab.ks) # doer do reopens if not opened and closes
dbDoer = basing.BaserDoer(
baser=hab.db) # doer do reopens if not opened and closes
regDoer = basing.BaserDoer(baser=iss.reger)
path = os.path.dirname(__file__)
path = os.path.join(path, 'logs')
wl = wiring.WireLog(samed=True,
filed=True,
name="ian",
prefix='demo',
reopen=True,
headDirPath=path)
wireDoer = wiring.WireLogDoer(wl=wl)
client = clienting.Client(host='127.0.0.1', port=remotePort, wl=wl)
clientDoer = doing.ClientDoer(client=client)
director = IanDirector(hab=hab,
issuer=iss,
client=client,
tock=0.125,
vcfile=vcfile,
recipientIdentifier=did,
lei=lei)
reactor = directing.Reactor(hab=hab, client=client, indirect=indirect)
return [ksDoer, dbDoer, regDoer, wireDoer, clientDoer, director, reactor]
def __init__(self, name, target: int, **kwa):
ks = keeping.Keeper(name=name, temp=False) # not opened by default, doer opens
self.ksDoer = keeping.KeeperDoer(keeper=ks) # doer do reopens if not opened and closes
db = basing.Baser(name=name, temp=False, reload=True) # not opened by default, doer opens
self.dbDoer = basing.BaserDoer(baser=db) # doer do reopens if not opened and closes
self.hab = habbing.Habitat(name=name, ks=ks, db=db, temp=False, create=False)
self.habDoer = habbing.HabitatDoer(habitat=self.hab) # setup doer
self.target = target
self.client = clienting.Client(host="", port=self.target)
self.clientDoer = clienting.ClientDoer(client=self.client)
doers = [self.ksDoer, self.dbDoer, self.habDoer, self.sendDo, self.clientDoer]
super(SenderDoer, self).__init__(doers=doers, **kwa)
def buildHab(db, kpr):
secrets = [
'A1-QxDkso9-MR1A8rZz_Naw6fgaAtayda8hrbkRVVu1E',
'Alntkt3u6dDgiQxTATr01dy8M72uuaZEf9eTdM-70Gk8',
'ArwXoACJgOleVZ2PY7kXn7rA0II0mHYDhc6WrBH8fDAc',
'A6zz7M08-HQSFq92sJ8KJOT2cZ47x7pXFQLPB0pckB3Q',
'AcwFTk-wgk3ZT2buPRIbK-zxgPx-TKbaegQvPEivN90Y',
'AKuYMe09COczwf2nIoD5AE119n7GLFOVFlNLxZcKuswc',
'AxFfJTcSuEE11FINfXMqWttkZGnUZ8KaREhrnyAXTsjw',
'ALq-w1UKkdrppwZzGTtz4PWYEeWm0-sDHzOv5sq96xJY'
]
secrecies = []
for secret in secrets: # convert secrets to secrecies
secrecies.append([secret])
# setup hab
hab = habbing.Habitat(ks=kpr, db=db, secrecies=secrecies, temp=True)
return hab
def handler(args):
name = args.name
with basing.openDB(name=name, temp=False, reload=True) as db, \
keeping.openKS(name=name, temp=False) as ks:
try:
hab = habbing.Habitat(name=name,
ks=ks,
db=db,
temp=False,
create=False)
print(f'Prefix\t\t{hab.pre}')
for idx, verfer in enumerate(hab.kever.verfers):
print(f'Public key {idx+1}:\t{verfer.qb64}')
print()
except ConfigurationError:
print(
f"prefix for {name} does not exist, incept must be run first",
)
def __init__(self, server, doers=None, always=False, **kwa):
self.server = server
self.cants = dict()
self.hab = habbing.Habitat(name='klid', temp=False)
klid = koming.Komer(db=self.hab.db, schema=KLIDRecord, subkey='klid.')
klid.put(
(self.hab.pre, ),
KLIDRecord(started=datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
doers = doers if doers is not None else []
# self.excDoDoer = exchanging.Exchanger(hab=self.hab)
doers.extend([self.serviceDo])
logging.info('super')
super(Serving, self).__init__(doers=doers, **kwa)
def handle(args):
print(args)
hab = habbing.Habitat(name='kli', temp=False)
tock = 0.03125
host = '127.0.0.1'
port = args.port
klis = koming.Komer(db=hab.db, schema=KLIRecord, subkey='kli.')
klis.put((hab.pre, ), KLIRecord(
host=host,
port=port,
))
# doist = doing.Doist(tock=tock, real=True)
# print("client", host, port)
# client = clienting.Client(host=host, port=port, tymth=doist.tymen())
# clientDoer = clienting.ClientDoer(client=client)
# initDoer = InitDoer(client=client, tymth=doist.tymen())
#
# doist.doers = [clientDoer, initDoer]
# doist.do()
doist = doing.Doist(tock=tock, real=True)
server = serving.Server(host='127.0.0.1', port=5678)
serverDoer = serving.ServerDoer(server=server)
servingDoDoer = Serving(server=server, doers=doist.doers)
doist.extend([serverDoer, servingDoDoer])
daemon = daemonocle.Daemon(
worker=doist.do,
# update to use pidPath serving.getPIDPath()
pid_file='/tmp/klid.pid',
# detach=detach,
)
daemon.do_action('start')
def test_indirect_mode_sam_cam_wit_demo():
""" Test indirect mode, bob and eve with witness """
help.ogler.resetLevel(level=logging.DEBUG)
# set of secrets (seeds for private keys)
camSecrets = [
'AgjD4nRlycmM5cPcAkfOATAp8wVldRsnc9f1tiwctXlw',
'AKUotEE0eAheKdDJh9QvNmSEmO_bjIav8V_GmctGpuCQ',
'AK-nVhMMJciMPvmF5VZE_9H-nhrgng9aJWf7_UHPtRNM',
'AT2cx-P5YUjIw_SLCHQ0pqoBWGk9s4N1brD-4pD_ANbs',
'Ap5waegfnuP6ezC18w7jQiPyQwYYsp9Yv9rYMlKAYL8k',
'Aqlc_FWWrxpxCo7R12uIz_Y2pHUH2prHx1kjghPa8jT8',
'AagumsL8FeGES7tYcnr_5oN6qcwJzZfLKxoniKUpG4qc',
'ADW3o9m3udwEf0aoOdZLLJdf1aylokP0lwwI_M2J9h0s'
]
camSecrecies = []
for secret in camSecrets: # convert secrets to secrecies
camSecrecies.append([secret])
# create cam signers
camSigners = [coring.Signer(qb64=secret) for secret in camSecrets]
assert [signer.qb64 for signer in camSigners] == camSecrets
# set of secrets (seeds for private keys)
samSecrets = [
'ArwXoACJgOleVZ2PY7kXn7rA0II0mHYDhc6WrBH8fDAc',
'A6zz7M08-HQSFq92sJ8KJOT2cZ47x7pXFQLPB0pckB3Q',
'AcwFTk-wgk3ZT2buPRIbK-zxgPx-TKbaegQvPEivN90Y',
'Alntkt3u6dDgiQxTATr01dy8M72uuaZEf9eTdM-70Gk8',
'A1-QxDkso9-MR1A8rZz_Naw6fgaAtayda8hrbkRVVu1E',
'AKuYMe09COczwf2nIoD5AE119n7GLFOVFlNLxZcKuswc',
'AxFfJTcSuEE11FINfXMqWttkZGnUZ8KaREhrnyAXTsjw',
'ALq-w1UKkdrppwZzGTtz4PWYEeWm0-sDHzOv5sq96xJY'
]
samSecrecies = []
for secret in samSecrets: # convert secrets to secrecies
samSecrecies.append([secret])
# create sam signers
samSigners = [coring.Signer(qb64=secret) for secret in samSecrets]
assert [signer.qb64 for signer in samSigners] == samSecrets
with basing.openDB(name="cam") as camDB, keeping.openKS(name="cam") as camKS, \
basing.openDB(name="sam") as samDB, keeping.openKS(name="sam") as samKS, \
basing.openDB(name="wit") as witDB, keeping.openKS(name="wit") as witKS:
samPort = 5620 # sam's TCP listening port for server
witPort = 5621 # wit' TCP listneing port for server
# setup the witness
witHab = habbing.Habitat(name='Wit',
ks=witKS,
db=witDB,
isith=1,
icount=1,
temp=True,
transferable=False)
wit = witHab.pre
assert witHab.ks == witKS
assert witHab.db == witDB
witServer = serving.Server(host="", port=witPort)
witServerDoer = serving.ServerDoer(server=witServer)
witDirectant = directing.Directant(hab=witHab, server=witServer)
witDoers = [witServerDoer, witDirectant]
# setup cam
# cam inception transferable (nxt digest not empty)
camSerder = eventing.incept(
keys=[camSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[camSigners[1].verfer.qb64]).qb64,
code=coring.MtrDex.Blake3_256)
cam = camSerder.ked["i"]
assert cam == 'ED9EB3sA5u2vCPOEmX3d7bEyHiSh7Xi8fjew2KMl3FQM'
# sam inception transferable (nxt digest not empty)
samSerder = eventing.incept(
keys=[samSigners[0].verfer.qb64],
wits=[wit],
nxt=coring.Nexter(keys=[samSigners[1].verfer.qb64]).qb64,
code=coring.MtrDex.Blake3_256)
sam = samSerder.ked["i"]
assert sam == 'EhnaYUqhHoo8kZaXJuTDCZ-h5ZDx3st4NemgqSITWp48'
samHab = habbing.Habitat(name='Sam',
ks=samKS,
db=samDB,
wits=[wit],
secrecies=samSecrecies,
temp=True)
assert samHab.ks == samKS
assert samHab.db == samDB
assert samHab.iserder.dig == samSerder.dig
assert samHab.pre == sam
samClient = clienting.Client(host='127.0.0.1', port=witPort)
samClientDoer = clienting.ClientDoer(client=samClient)
samDirector = demoing.SamDirector(hab=samHab,
client=samClient,
tock=0.125)
assert samDirector.hab == samHab
assert samDirector.client == samClient
assert id(samDirector.hab.kvy.kevers) == id(samHab.kevers)
assert samDirector.hab.kvy.db == samDB
assert samDirector.tock == 0.125
samReactor = directing.Reactor(hab=samHab, client=samClient)
assert samReactor.hab == samHab
assert samReactor.client == samClient
assert id(samReactor.hab.kvy.kevers) == id(samHab.kevers)
assert samReactor.hab.kvy.db == samDB
assert samReactor.hab.psr.ims == samReactor.client.rxbs
samServer = serving.Server(host="", port=samPort)
samServerDoer = serving.ServerDoer(server=samServer)
samDirectant = directing.Directant(hab=samHab, server=samServer)
assert samDirectant.hab == samHab
assert samDirectant.server == samServer
# Sam's Reactants created on demand
samDoers = [
samClientDoer, samDirector, samReactor, samServerDoer, samDirectant
]
# setup cam
camHab = habbing.Habitat(name='Cam',
ks=camKS,
db=camDB,
secrecies=camSecrecies,
temp=True)
assert camHab.ks == camKS
assert camHab.db == camDB
assert camHab.iserder.dig == camSerder.dig
assert camHab.pre == cam
camClient = clienting.Client(host='127.0.0.1', port=witPort)
camClientDoer = clienting.ClientDoer(client=camClient)
camDirector = demoing.CamDirector(hab=camHab,
remotePre=sam,
client=camClient,
tock=0.125)
assert camDirector.hab == camHab
assert camDirector.client == camClient
assert id(camDirector.hab.kvy.kevers) == id(camHab.kevers)
assert camDirector.hab.kvy.db == camDB
assert camDirector.tock == 0.125
camReactor = directing.Reactor(hab=camHab,
client=camClient,
indirect=True)
assert camReactor.hab == camHab
assert camReactor.client == camClient
assert id(camReactor.hab.kvy.kevers) == id(camHab.kevers)
assert camReactor.hab.kvy.db == camDB
assert camReactor.hab.psr.ims == camReactor.client.rxbs
camDoers = [camClientDoer, camDirector, camReactor]
# Manually stage SamDoers and wit doers and then camDoers
tock = 0.03125
doist = doing.Doist(doers=samDoers + witDoers, tock=tock)
# manually prep doers
doist.done = False
doist.enter() # injects doist.tymth() dependency to all doers
assert len(doist.deeds) == len(samDoers + witDoers)
while doist.tyme < doist.tock * 16:
doist.recur() # iterate 16 times
time.sleep(doist.tock)
assert len(doist.deeds) == len(samDoers + witDoers)
assert not doist.done
assert samHab.pre in samHab.kevers
# now start up cam doers
doist.extend(camDoers)
assert len(doist.deeds) == len(samDoers + witDoers + camDoers)
while doist.tyme < doist.tock * 32:
doist.recur() # iterate 16 times
time.sleep(doist.tock)
assert len(doist.deeds) == len(samDoers + witDoers + camDoers) - 1
# camDirector completes
assert camDirector.done
assert not doist.done
assert camHab.pre in camHab.kevers
assert samHab.pre in camHab.kevers
# verify final event states
doist.exit()
assert samClient.opened is False
assert samServer.opened is False
assert camClient.opened is False
assert not os.path.exists(camDB.path)
assert not os.path.exists(samDB.path)
help.ogler.resetLevel(level=help.ogler.level)
"""End Test"""
def setupController(secrets, witnessPort=5631, localPort=5629, indirect=False):
"""
Setup and return doers list to run controller
"""
secrecies = []
for secret in secrets: # convert secrets to secrecies
secrecies.append([secret])
# setup habitat
hab = habbing.Habitat(name="han", secrecies=secrecies, temp=True)
logger.info(
"\nDirect Mode demo of %s:\nNamed %s listening on TCP port %s, witness on TCP Port %s.\n\n",
hab.pre, hab.name, localPort, witnessPort)
wallet = walleting.Wallet(hab=hab, name="han")
# setup doers
ksDoer = keeping.KeeperDoer(
keeper=hab.ks) # doer do reopens if not opened and closes
dbDoer = basing.BaserDoer(
baser=hab.db) # doer do reopens if not opened and closes
pdbDoer = basing.BaserDoer(
baser=wallet.db) # doer do reopens if not opened and closes
path = os.path.dirname(__file__)
path = os.path.join(path, 'logs')
wl = wiring.WireLog(samed=True,
filed=True,
name="han",
prefix='demo',
reopen=True,
headDirPath=path)
wireDoer = wiring.WireLogDoer(wl=wl)
jsonSchema = scheming.JSONSchema(resolver=scheming.jsonSchemaCache)
issueHandler = handling.IssueHandler(wallet=wallet, typ=jsonSchema)
requestHandler = handling.RequestHandler(wallet=wallet, typ=jsonSchema)
witnessClient = clienting.Client(host='127.0.0.1', port=witnessPort, wl=wl)
witnessClientDoer = clienting.ClientDoer(client=witnessClient)
excDoer = exchanging.Exchanger(hab=hab,
handlers=[issueHandler, requestHandler])
director = HanDirector(hab=hab,
client=witnessClient,
exchanger=excDoer,
tock=0.125,
wallet=wallet)
reactor = directing.Reactor(hab=hab,
client=witnessClient,
indirect=indirect)
server = serving.Server(host="", port=localPort)
serverDoer = serving.ServerDoer(server=server)
directant = directing.Directant(hab=hab, server=server, exchanger=excDoer)
return [
ksDoer, dbDoer, pdbDoer, excDoer, wireDoer, witnessClientDoer,
director, reactor, serverDoer, directant
]
def test_witness():
"""
Test event validation logic with witnesses
cam is controller
van is validator
wes is a witness
wok is a witness
wam is a witness
"""
salt = coring.Salter(raw=b'abcdef0123456789').qb64
with basing.openDB(name="cam") as camDB, keeping.openKS(name="cam") as camKS, \
basing.openDB(name="van") as vanDB, keeping.openKS(name="van") as vanKS, \
basing.openDB(name="wes") as wesDB, keeping.openKS(name="wes") as wesKS, \
basing.openDB(name="wok") as wokDB, keeping.openKS(name="wok") as wokKS, \
basing.openDB(name="wam") as wamDB, keeping.openKS(name="wam") as wamKS, \
basing.openDB(name="wil") as wilDB, keeping.openKS(name="wil") as wilKS:
# witnesses first so can setup inception event for cam
wsith = 1
# setup Wes's habitat nontrans
# Wes's receipts will be rcts with a receipt couple attached
wesHab = habbing.Habitat(name='wes',
ks=wesKS,
db=wesDB,
isith=wsith,
icount=1,
salt=salt,
transferable=False,
temp=True) # stem is .name
assert wesHab.ks == wesKS
assert wesHab.db == wesDB
assert not wesHab.kever.prefixer.transferable
# create non-local kevery for Wes to process nonlocal msgs
wesKvy = eventing.Kevery(db=wesHab.db, lax=False, local=False)
# setup Wok's habitat nontrans
# Wok's receipts will be rcts with a receipt couple attached
wokHab = habbing.Habitat(name='wok',
ks=wokKS,
db=wokDB,
isith=wsith,
icount=1,
salt=salt,
transferable=False,
temp=True) # stem is .name
assert wokHab.ks == wokKS
assert wokHab.db == wokDB
assert not wokHab.kever.prefixer.transferable
# create non-local kevery for Wok to process nonlocal msgs
wokKvy = eventing.Kevery(db=wokHab.db, lax=False, local=False)
# setup Wam's habitat nontrans
# Wams's receipts will be rcts with a receipt couple attached
wamHab = habbing.Habitat(name='wam',
ks=wamKS,
db=wamDB,
isith=wsith,
icount=1,
salt=salt,
transferable=False,
temp=True) # stem is .name
assert wamHab.ks == wamKS
assert wamHab.db == wamDB
assert not wamHab.kever.prefixer.transferable
# create non-local kevery for Wam to process nonlocal msgs
wamKvy = eventing.Kevery(db=wamHab.db, lax=False, local=False)
# setup Wil's habitat nontrans
# Wil's receipts will be rcts with a receipt couple attached
wilHab = habbing.Habitat(name='wil',
ks=wilKS,
db=wilDB,
isith=wsith,
icount=1,
salt=salt,
transferable=False,
temp=True) # stem is .name
assert wilHab.ks == wilKS
assert wilHab.db == wilDB
assert not wilHab.kever.prefixer.transferable
# create non-local kevery for Wam to process nonlocal msgs
wilKvy = eventing.Kevery(db=wilHab.db, lax=False, local=False)
# setup Cam's habitat trans multisig
wits = [wesHab.pre, wokHab.pre, wamHab.pre]
csith = 2 # hex str of threshold int
camHab = habbing.Habitat(name='cam',
ks=camKS,
db=camDB,
isith=csith,
icount=3,
toad=2,
wits=wits,
salt=salt,
temp=True) # stem is .name
assert camHab.ks == camKS
assert camHab.db == camDB
assert camHab.kever.prefixer.transferable
for werfer in camHab.iserder.werfers:
assert werfer.qb64 in wits
assert camHab.kever.wits == wits
assert camHab.kever.toad == 2
assert camHab.kever.sn == 0
# create non-local kevery for Cam to process onlocal msgs
camKvy = eventing.Kevery(db=camHab.db, lax=False, local=False)
# setup Van's habitat trans multisig
vsith = 2 # two of three signing threshold
vanHab = habbing.Habitat(name='van',
ks=vanKS,
db=vanDB,
isith=vsith,
icount=3,
salt=salt,
temp=True) # stem is .name
assert vanHab.ks == vanKS
assert vanHab.db == vanDB
assert vanHab.kever.prefixer.transferable
# create non-local kevery for Van to process nonlocal msgs
vanKvy = eventing.Kevery(db=vanHab.db, lax=False, local=False)
# make list so easier to batch
camWitKvys = [wesKvy, wokKvy, wamKvy]
camWitHabs = [wesHab, wokHab, wamHab]
# Create Cam inception and send to each of Cam's witnesses
camIcpMsg = camHab.makeOwnInception()
rctMsgs = [] # list of receipts from each witness
for i in range(len(camWitKvys)):
kvy = camWitKvys[i]
parsing.Parser().parse(ims=bytearray(camIcpMsg), kvy=kvy)
# kvy.process(ims=bytearray(camIcpMsg)) # send copy of cam icp msg to witness
assert kvy.kevers[camHab.pre].sn == 0 # accepted event
assert len(kvy.cues) == 1 # queued receipt cue
hab = camWitHabs[i]
rctMsg = hab.processCues(kvy.cues) # process cue returns rct msg
assert len(rctMsg) == 566
rctMsgs.append(rctMsg)
for msg in rctMsgs: # process rct msgs from all witnesses
parsing.Parser().parse(ims=bytearray(msg), kvy=camKvy)
# camKvy.process(ims=bytearray(msg)) # make copy
for hab in camWitHabs:
assert hab.pre in camKvy.kevers
# get from Cam database copies of witness receipts received by Cam
# and send to witnesses so all witnesses have full set of receipts
# from all other witnesses
# reply one event or receipt one event with all witness attachments
dgkey = dbing.dgKey(pre=camHab.pre, dig=camHab.kever.serder.dig)
wigs = camHab.db.getWigs(dgkey)
assert len(wigs) == 3
wigers = [coring.Siger(qb64b=bytes(wig)) for wig in wigs]
rserder = eventing.receipt(pre=camHab.pre,
sn=camHab.kever.sn,
dig=camHab.kever.serder.dig)
camIcpWitRctMsg = eventing.messagize(serder=rserder, wigers=wigers)
assert len(camIcpWitRctMsg) == 413
for i in range(len(camWitKvys)):
kvy = camWitKvys[i]
parsing.Parser().parse(ims=bytearray(camIcpWitRctMsg), kvy=kvy)
# kvy.process(ims=bytearray(camIcpWitRctMsg)) # send copy of witness rcts
assert len(kvy.db.getWigs(dgkey)) == 3 # fully witnessed
assert len(kvy.cues) == 0 # no cues
# send Cam icp and witness rcts to Van
parsing.Parser().parse(ims=bytearray(camIcpMsg), kvy=vanKvy)
# vanKvy.process(ims=bytearray(camIcpMsg)) # should escrow since not witnesses
assert camHab.pre not in vanKvy.kevers
parsing.Parser().parse(ims=bytearray(camIcpWitRctMsg), kvy=vanKvy)
# vanKvy.process(ims=bytearray(camIcpWitRctMsg))
vanKvy.processEscrows()
assert camHab.pre in vanKvy.kevers
vcKvr = vanKvy.kevers[camHab.pre]
assert vcKvr.sn == 0
assert vcKvr.wits == wits
# Create Cam ixn and send to each of Cam's witnesses
camIxnMsg = camHab.interact()
rctMsgs = [] # list of receipts from each witness
for i in range(len(camWitKvys)):
kvy = camWitKvys[i]
parsing.Parser().parse(ims=bytearray(camIxnMsg), kvy=kvy)
# kvy.process(ims=bytearray(camIxnMsg)) # send copy of cam icp msg to witness
assert kvy.kevers[camHab.pre].sn == 1 # accepted event
assert len(kvy.cues) == 1 # queued receipt cue
hab = camWitHabs[i]
rctMsg = hab.processCues(kvy.cues) # process cue returns rct msg
assert len(rctMsg) == 281
rctMsgs.append(rctMsg)
for msg in rctMsgs: # process rct msgs from all witnesses
parsing.Parser().parse(ims=bytearray(msg), kvy=camKvy)
# camKvy.process(ims=bytearray(msg)) # make copy
for hab in camWitHabs:
assert hab.pre in camKvy.kevers
# get from Cam database copies of witness receipts received by Cam
# and send to witnesses so all witnesses have full set of receipts
# from all other witnesses
# reply one event or receipt one event with all witness attachments
dgkey = dbing.dgKey(pre=camHab.pre, dig=camHab.kever.serder.dig)
wigs = camHab.db.getWigs(dgkey)
assert len(wigs) == 3
wigers = [coring.Siger(qb64b=bytes(wig)) for wig in wigs]
rserder = eventing.receipt(pre=camHab.pre,
sn=camHab.kever.sn,
dig=camHab.kever.serder.dig)
camIxnWitRctMsg = eventing.messagize(serder=rserder, wigers=wigers)
assert len(camIxnWitRctMsg) == 413
for i in range(len(camWitKvys)):
kvy = camWitKvys[i]
parsing.Parser().parse(ims=bytearray(camIxnWitRctMsg), kvy=kvy)
# kvy.process(ims=bytearray(camIxnWitRctMsg)) # send copy of witness rcts
assert len(kvy.db.getWigs(dgkey)) == 3 # fully witnessed
assert len(kvy.cues) == 0 # no cues
# send Cam ixn's witness rcts to Van first then send Cam ixn
parsing.Parser().parse(ims=bytearray(camIxnWitRctMsg), kvy=vanKvy)
# vanKvy.process(ims=bytearray(camIxnWitRctMsg))
vanKvy.processEscrows()
assert vcKvr.sn == 0
parsing.Parser().parse(ims=bytearray(camIxnMsg), kvy=vanKvy)
# vanKvy.process(ims=bytearray(camIxnMsg)) # should escrow since not witnesses
assert vcKvr.sn == 0
vanKvy.processEscrows()
assert vcKvr.sn == 1
# Cam replace Wok with Wil as a witness.
# Cam update Wil all event witnessed events for Cam by replay
# Cam update itself with Wil receipts including Wils inception
camReplayMsg = camHab.replay()
assert len(camReplayMsg) == 1831
parsing.Parser().parse(ims=bytearray(camReplayMsg), kvy=wilKvy)
# wilKvy.process(ims=bytearray(camReplayMsg))
assert camHab.pre in wilKvy.kevers
assert wilKvy.kevers[camHab.pre].sn == 1 # asscepted both events
assert len(wilKvy.cues) == 2
wilRctMsg = wilHab.processCues(
wilKvy.cues) # process cue returns rct msg
assert len(wilKvy.cues) == 0
parsing.Parser().parse(ims=bytearray(wilRctMsg), kvy=camKvy)
# camKvy.process(ims=bytearray(wilRctMsg)) # make copy
assert wilHab.pre in camKvy.kevers
# Cam rotation with witness rotation
camRotMsg = camHab.rotate(toad=2, cuts=[wokHab.pre], adds=[wilHab.pre])
assert camHab.kever.wits == [wesHab.pre, wamHab.pre, wilHab.pre]
assert camHab.kever.toad == 2
assert camHab.kever.sn == 2
# update lists of witness kvys and habs
camWitKvys = [wesKvy, wamKvy, wilKvy]
camWitHabs = [wesHab, wamHab, wilHab]
rctMsgs = [] # list of receipt msgs from each witness
for i in range(len(camWitKvys)):
kvy = camWitKvys[i]
parsing.Parser().parse(ims=bytearray(camRotMsg), kvy=kvy)
# kvy.process(ims=bytearray(camRotMsg)) # send copy of cam msg to witness
assert kvy.kevers[camHab.pre].sn == 2 # accepted event
assert len(kvy.cues) == 1 # queued receipt cue
hab = camWitHabs[i]
rctMsg = hab.processCues(kvy.cues) # process cue returns rct msg
assert len(rctMsg) == 281
rctMsgs.append(rctMsg)
for msg in rctMsgs: # process rct msgs from all witnesses
parsing.Parser().parse(ims=bytearray(msg), kvy=camKvy)
# camKvy.process(ims=bytearray(msg)) # make copy
for hab in camWitHabs:
assert hab.pre in camKvy.kevers
# get from Cam database copies of witness receipts received by Cam
# and send to witnesses so all witnesses have full set of receipts
# from all other witnesses
# reply one event or receipt one event with all witness attachments
dgkey = dbing.dgKey(pre=camHab.pre, dig=camHab.kever.serder.dig)
wigs = camHab.db.getWigs(dgkey)
assert len(wigs) == 3
wigers = [coring.Siger(qb64b=bytes(wig)) for wig in wigs]
rserder = eventing.receipt(pre=camHab.pre,
sn=camHab.kever.sn,
dig=camHab.kever.serder.dig)
camRotWitRctMsg = eventing.messagize(serder=rserder, wigers=wigers)
assert len(camRotWitRctMsg) == 413
for i in range(len(camWitKvys)):
kvy = camWitKvys[i]
parsing.Parser().parse(ims=bytearray(camRotWitRctMsg), kvy=kvy)
# kvy.process(ims=bytearray(camRotWitRctMsg)) # send copy of witness rcts
assert len(kvy.db.getWigs(dgkey)) == 3 # fully witnessed
assert len(kvy.cues) == 0 # no cues
# send Cam's rot and wit receipts to Van
#vanKvy.process(ims=bytearray(camRotMsg)) # should escrow since not witnesses
#vanKvy.process(ims=bytearray(camRotWitRctMsg))
#vanKvy.processEscrows()
#assert vcKvr.sn == 2
#assert vcKvr.wits == camHab.kever.wits
# send Cam rot's witness rcts to Van first then send Cam rot
parsing.Parser().parse(ims=bytearray(camRotWitRctMsg), kvy=vanKvy)
# vanKvy.process(ims=bytearray(camRotWitRctMsg))
vanKvy.processEscrows()
assert vcKvr.sn == 1
parsing.Parser().parse(ims=bytearray(camRotMsg), kvy=vanKvy)
# vanKvy.process(ims=bytearray(camRotMsg)) # should escrow since not witnesses
assert vcKvr.sn == 1
vanKvy.processEscrows()
assert vcKvr.sn == 2
assert vcKvr.wits == camHab.kever.wits
assert not os.path.exists(wokKS.path)
assert not os.path.exists(wokDB.path)
assert not os.path.exists(wesKS.path)
assert not os.path.exists(wesDB.path)
assert not os.path.exists(vanKS.path)
assert not os.path.exists(vanDB.path)
assert not os.path.exists(camKS.path)
assert not os.path.exists(camDB.path)
"""End Test"""
def test_issuing():
sidSalt = coring.Salter(raw=b'0123456789abcdef').qb64
with basing.openDB(name="sid") as sidDB, \
keeping.openKS(name="sid") as sidKS, \
basing.openDB(name="red") as redDB, \
openPocket(name="red") as redPDB:
limit = 1.0
tock = 1.0
doist = doing.Doist(limit=limit, tock=tock)
sidHab = habbing.Habitat(ks=sidKS, db=sidDB, salt=sidSalt, temp=True)
sidPre = sidHab.pre
assert sidPre == "E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E"
sidIcpMsg = sidHab.makeOwnInception()
redKvy = eventing.Kevery(db=redDB)
parsing.Parser().parse(ims=bytearray(sidIcpMsg), kvy=redKvy)
assert redKvy.kevers[sidPre].sn == 0 # accepted event
sed = dict()
sed["$id"] = ""
sed["$schema"] = "http://json-schema.org/draft-07/schema#"
sed.update(
dict(type="object",
properties=dict(id=dict(type="string"),
lei=dict(type="string"))))
schemer = scheming.Schemer(sed=sed, code=coring.MtrDex.Blake3_256)
assert schemer.said == "EeCCZi1R5xHUlhsyQNm_7NrUQTEKZH5P9vBomnc9AihY"
cache = scheming.CacheResolver()
cache.add(schemer.said, schemer.raw)
jsonSchema = JSONSchema(resolver=cache)
# Create Red's wallet and Issue Handler for receiving the credential
redWallet = Wallet(hab=sidHab, db=redPDB)
redIssueHandler = IssueHandler(wallet=redWallet, typ=jsonSchema)
redExc = exchanging.Exchanger(hab=sidHab,
tymth=doist.tymen(),
handlers=[redIssueHandler])
# Build the credential subject and then the Credentialer for the full credential
credSubject = dict(
id=
"did:keri:Efaavv0oadfghasdfn443fhbyyr4v", # this needs to be generated from a KEL
lei="254900OPPU84GM83MG36",
issuanceDate="2021-06-27T21:26:21.233257+00:00",
)
creder = credential(issuer=sidHab.pre,
schema=schemer.said,
subject=credSubject,
typ=jsonSchema)
assert creder.said == "EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM"
msg = sidHab.endorse(serder=creder)
assert msg == (
b'{"v":"KERI10JSON000136_","i":"EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM",'
b'"x":"EeCCZi1R5xHUlhsyQNm_7NrUQTEKZH5P9vBomnc9AihY","ti":"E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E",'
b'"d":{"id":"did:keri:Efaavv0oadfghasdfn443fhbyyr4v","lei":"254900OPPU84GM83MG36",'
b'"issuanceDate":"2021-06-27T21:26:21.233257+00:00"}}-VA0-FABE4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE'
b'-YfcI9E0AAAAAAAAAAAAAAAAAAAAAAAElHzHwX3V6itsD2Ksg_CNBbUNTBYzLYw-AxDNI7_ZmaI'
b'-AABAA0pXbQllgzXr88IczAnsPrdhgFKs9wNQvfSfzyrtcvbTwq-U1DmBluAklntCqH1AbBL6TWLZIDGi83BHLWJ82CA'
)
# Create the issue credential payload
pl = dict(vc=[envelope(msg, typ=jsonSchema)])
# Create the `exn` message for issue credential
sidExcSrdr = exchanging.exchange(route="/credential/issue", payload=pl)
excMsg = sidHab.sanction(sidExcSrdr)
# Parse the exn issue credential message on Red's side
parsing.Parser().parse(ims=bytearray(excMsg), kvy=redKvy, exc=redExc)
doist.do(doers=[redExc])
assert doist.tyme == limit
ser = (
b'{"v":"KERI10JSON000136_","i":"EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM",'
b'"x":"EeCCZi1R5xHUlhsyQNm_7NrUQTEKZH5P9vBomnc9AihY","ti":"E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E",'
b'"d":{"id":"did:keri:Efaavv0oadfghasdfn443fhbyyr4v","lei":"254900OPPU84GM83MG36",'
b'"issuanceDate":"2021-06-27T21:26:21.233257+00:00"}}')
sig0 = (
b'AA0pXbQllgzXr88IczAnsPrdhgFKs9wNQvfSfzyrtcvbTwq-U1DmBluAklntCqH1AbBL6TWLZIDGi83BHLWJ82CA'
)
# verify we can load serialized VC by SAID
key = creder.said.encode("utf-8")
assert redPDB.getSers(key) == ser
# verify the signature
sigs = redPDB.getSigs(key)
assert len(sigs) == 1
assert sigs[0] == sig0
# verify we can look up credential by Schema SAID
schema = redPDB.getSchms(schemer.saider.qb64b)
assert len(schema) == 1
assert schema[0] == key
def setupController(secrets, witnessPort=5621, peerPort=5629, indirect=False):
"""
Setup and return doers list to run controller
"""
name = "vic"
secrecies = []
for secret in secrets: # convert secrets to secrecies
secrecies.append([secret])
# setup databases for dependency injection
ks = keeping.Keeper(name=name,
temp=True) # not opened by default, doer opens
ksDoer = keeping.KeeperDoer(
keeper=ks) # doer do reopens if not opened and closes
db = basing.Baser(name=name,
temp=True) # not opened by default, doer opens
dbDoer = basing.BaserDoer(
baser=db) # doer do reopens if not opened and closes
# setup habitat
hab = habbing.Habitat(name=name,
ks=ks,
db=db,
temp=True,
secrecies=secrecies)
habDoer = habbing.HabitatDoer(habitat=hab) # setup doer
verifier = verifying.Verifier(name=name, hab=hab)
regDoer = basing.BaserDoer(baser=verifier.reger)
# setup wirelog to create test vectors
path = os.path.dirname(__file__)
path = os.path.join(path, 'logs')
wl = wiring.WireLog(samed=True,
filed=True,
name=name,
prefix='demo',
reopen=True,
headDirPath=path)
wireDoer = wiring.WireLogDoer(wl=wl)
witnessClient = clienting.Client(host='127.0.0.1', port=witnessPort, wl=wl)
witnessClientDoer = clienting.ClientDoer(client=witnessClient)
peerClient = clienting.Client(host='127.0.0.1', port=peerPort, wl=wl)
peerClientDoer = clienting.ClientDoer(client=peerClient)
jsonSchema = scheming.JSONSchema(resolver=scheming.jsonSchemaCache)
proofs = decking.Deck()
proofHandler = handling.ProofHandler(typ=jsonSchema, proofs=proofs)
excDoer = exchanging.Exchanger(hab=hab, handlers=[proofHandler])
director = VicDirector(hab=hab,
verifier=verifier,
witnessClient=witnessClient,
peerClient=peerClient,
exchanger=excDoer,
jsonSchema=jsonSchema,
proofs=proofs,
tock=0.125)
witnessReactor = directing.Reactor(hab=hab,
client=witnessClient,
verifier=verifier,
indirect=indirect)
peerReactor = directing.Reactor(hab=hab,
client=peerClient,
verifier=verifier,
indirect=indirect,
exchanger=excDoer)
logger.info("\nDirect Mode demo of %s:\nNamed %s to TCP port %s.\n\n",
hab.pre, hab.name, witnessPort)
return [
ksDoer, dbDoer, habDoer, regDoer, excDoer, wireDoer, witnessClientDoer,
director, witnessReactor, peerClientDoer, peerReactor
]
def test_proving():
sidSalt = coring.Salter(raw=b'0123456789abcdef').qb64
with basing.openDB(name="sid") as sidDB, \
keeping.openKS(name="sid") as sidKS:
sidHab = habbing.Habitat(ks=sidKS, db=sidDB, salt=sidSalt, temp=True)
assert sidHab.pre == "E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E"
sed = dict()
sed["$id"] = ""
sed["$schema"] = "http://json-schema.org/draft-07/schema#"
sed.update(
dict(type="object",
properties=dict(id=dict(type="string"),
lei=dict(type="string"))))
schemer = scheming.Schemer(sed=sed,
typ=scheming.JSONSchema(),
code=coring.MtrDex.Blake3_256)
credSubject = dict(
id=
"did:keri:Efaavv0oadfghasdfn443fhbyyr4v", # this needs to be generated from a KEL
lei="254900OPPU84GM83MG36",
issuanceDate="2021-06-27T21:26:21.233257+00:00",
)
cache = CacheResolver()
cache.add(schemer.said, schemer.raw)
creder = credential(issuer=sidHab.pre,
schema=schemer.said,
subject=credSubject,
typ=JSONSchema(resolver=cache))
msg = sidHab.endorse(serder=creder)
assert msg == (
b'{"v":"KERI10JSON000136_","i":"EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM",'
b'"x":"EeCCZi1R5xHUlhsyQNm_7NrUQTEKZH5P9vBomnc9AihY","ti":"E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E",'
b'"d":{"id":"did:keri:Efaavv0oadfghasdfn443fhbyyr4v","lei":"254900OPPU84GM83MG36",'
b'"issuanceDate":"2021-06-27T21:26:21.233257+00:00"}}-VA0-FABE4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE'
b'-YfcI9E0AAAAAAAAAAAAAAAAAAAAAAAElHzHwX3V6itsD2Ksg_CNBbUNTBYzLYw-AxDNI7_ZmaI'
b'-AABAA0pXbQllgzXr88IczAnsPrdhgFKs9wNQvfSfzyrtcvbTwq-U1DmBluAklntCqH1AbBL6TWLZIDGi83BHLWJ82CA'
)
creder = Credentialer(raw=msg, typ=JSONSchema(resolver=cache))
proof = msg[creder.size:]
ctr = Counter(qb64b=proof, strip=True)
assert ctr.code == CtrDex.AttachedMaterialQuadlets
assert ctr.count == 52
pags = ctr.count * 4
assert len(proof) == pags
ctr = Counter(qb64b=proof, strip=True)
assert ctr.code == CtrDex.TransIndexedSigGroups
assert ctr.count == 1
prefixer = Prefixer(qb64b=proof, strip=True)
assert prefixer.qb64 == sidHab.pre
seqner = Seqner(qb64b=proof, strip=True)
assert seqner.sn == sidHab.kever.sn
diger = Diger(qb64b=proof, strip=True)
assert diger.qb64 == sidHab.kever.serder.dig
ictr = Counter(qb64b=proof, strip=True)
assert ictr.code == CtrDex.ControllerIdxSigs
isigers = []
for i in range(ictr.count):
isiger = Siger(qb64b=proof, strip=True)
isiger.verfer = sidHab.kever.serder.verfers[i]
isigers.append(isiger)
assert len(isigers) == 1
siger = isigers[0]
assert siger.verfer.verify(siger.raw, creder.raw) is True
def test_replay():
"""
Test disjoint and conjoint replay
Deb creates series of events.
Deb replays Deb's events to Cam and collects Cam's receipts
Deb replays Deb's events with Cam's recepts to Bev and collects Bev's receipts
Deb replays Deb's events with both Cam's and Bev's receipts to Cam
Compare replay of Deb's events with receipts by both Deb and Cam to confirm identical
"""
with basing.openDB(name="deb") as debDB, keeping.openKS(name="deb") as debKS, \
basing.openDB(name="cam") as camDB, keeping.openKS(name="cam") as camKS, \
basing.openDB(name="bev") as bevDB, keeping.openKS(name="bev") as bevKS, \
basing.openDB(name="art") as artDB, keeping.openKS(name="art") as artKS:
# setup Deb's habitat using default salt multisig already incepts
sith = ["1/2", "1/2", "1/2"] # weighted signing threshold
debHab = habbing.Habitat(name='deb',
ks=debKS,
db=debDB,
isith=sith,
icount=3,
temp=True)
assert debHab.ks == debKS
assert debHab.db == debDB
assert debHab.kever.prefixer.transferable
# setup Cam's habitat using default salt multisig already incepts
# Cam's receipts will be vrcs with 3 indexed sigantures attached
sith = '2' # hex str of threshold int
camHab = habbing.Habitat(name='cam',
ks=camKS,
db=camDB,
isith=sith,
icount=3,
temp=True)
assert camHab.ks == camKS
assert camHab.db == camDB
assert camHab.kever.prefixer.transferable
# setup Bev's habitat using default salt nonstransferable already incepts
# Bev's receipts will be rcts with a receipt couple attached
sith = '1' # hex str of threshold int
bevHab = habbing.Habitat(name='bev',
ks=bevKS,
db=bevDB,
isith=sith,
icount=1,
transferable=False,
temp=True)
assert bevHab.ks == bevKS
assert bevHab.db == bevDB
assert not bevHab.kever.prefixer.transferable
# setup Art's habitat using custom salt nonstransferable so not match Bev
# already incepts
# Art's receipts will be rcts with a receipt couple attached
salt = coring.Salter(raw=b'abcdef0123456789').qb64
sith = '1' # hex str of threshold int
artHab = habbing.Habitat(name='art',
ks=artKS,
db=artDB,
isith=sith,
icount=1,
salt=salt,
transferable=False,
temp=True)
assert artHab.ks == artKS
assert artHab.db == artDB
assert not artHab.kever.prefixer.transferable
# first setup disjoint replay then conjoint replay
# Create series of event for Deb
debMsgs = bytearray()
debMsgs.extend(debHab.makeOwnInception())
debMsgs.extend(debHab.interact())
debMsgs.extend(debHab.rotate())
debMsgs.extend(debHab.interact())
debMsgs.extend(debHab.interact())
debMsgs.extend(debHab.interact())
debMsgs.extend(debHab.interact())
assert debMsgs == (
b'{"v":"KERI10JSON00015b_","i":"EeTLHxy5Npa4SQlFABzhu66FUuSl_iJAaf'
b'ez-encK314","s":"0","t":"icp","kt":["1/2","1/2","1/2"],"k":["DRx'
b'CLERO9eSvG4fluzOsK52GCWCtKOZClVwA38Oa--MA","DCxzT16ikP6LKVJfr6hv'
b'1jmhynm6I4-KoGYkJtd9uBro","DsDl5xSHnIlcGo13u5jDRr1jJMkQ34nEc5R6N'
b'YsdPS2k"],"n":"Eer5S019j0eEFNFLb0R0UDMoNLavlLiQ73fHGU7MUHXg","bt'
b'":"0","b":[],"c":[],"a":[]}-AADAA4HzkCruAhoxet6Vrk_tBCwbwaT78dRw'
b'w9RQJb0MR_tmSpEYOYDue-pBQCthsgDJzjyElpSmzNedlY-hVd6rbDwABJnfOgI6'
b'teO_3fESnXgiz_9J_F_VfQliLWvLCM8ZnVjrryBuiMYOUmHbfXuNtRC4iZxb-RU0'
b'lC55O0r5c5hyrAgACnZEXW7jYpAdrIfmOmH-OEHmhxcwQNu31k-mmzyNTfFvAxmp'
b'r7-zLdmzlWKfMBlE6eAbDgCdNr_VL2l8xeJExAA{"v":"KERI10JSON000098_",'
b'"i":"EeTLHxy5Npa4SQlFABzhu66FUuSl_iJAafez-encK314","s":"1","t":"'
b'ixn","p":"E4gF0E1fkpEPBjeq1Sm-RK_Rvg56KOmtBHGfNe_tPxWc","a":[]}-'
b'AADAAvo8lxVzu4YS6nG3BXu7PncYdZO57P4gYY-ikaRepVIOeRnZ10iMdJGcyULm'
b'mdXLRaVxtuxI956cJljg3joSMBgABgHtCeHi-UZjnI1IWW9ZF8E7ni6UwerFOvPV'
b'7z3i1pI7D3HJCoSx8XkhdXPGzUtrNuAvxVptsJtF17_-rP50bBwACguCjTA2taPP'
b'EyhVecWjtpoBJCAiYeTdeDv3Hq0pAJXWa7SWjxlDR2-f1TIIXg8PbBD_tgn4Z6zp'
b'LZcPLLHH5Cg{"v":"KERI10JSON000190_","i":"EeTLHxy5Npa4SQlFABzhu66'
b'FUuSl_iJAafez-encK314","s":"2","t":"rot","p":"EYROVd3Ho83kEgBkrN'
b'v6kqTAG4YeCqyPWYBo2jCPteiw","kt":["1/2","1/2","1/2"],"k":["Dj-DU'
b'wfCmOrE3ijqucR0I89_fYTFbyotaqeQyDfupkEU","DL-k_8BanjLYaAdm6WWKIp'
b'HcHwcbF834vnLPgpW1NL8k","DWG2ZFsWYUsbDI1Kmu8JH22iGaVDGvM7pnuT4y2'
b'oR3VI"],"n":"EYd4ha92A2yttnCoLMqFGRzh6nsgduE910LD-scP7C3Q","bt":'
b'"0","br":[],"ba":[],"a":[]}-AADAAspTV94LrwMhYVzZD0xu16aKjf1YQ8nT'
b'Ta08ik1Fah545jAoe6n1xdnKSgL9Alucp4F-Yl69ksAttb4hTlnikDwABKspYVa4'
b'J3r7ox-gDsPbpI5jiFSTcDCjBJGfU6hWhMXx7zpgG1jt4cTeW83oaILMbW85i_U7'
b'RT3x6Sm2z5ytCCQACf157-iV13AXKaIddVaXexNx5K9INhJ44tfpb3OBjuPk5JMj'
b'VGIU0iz5LkQlc_rV9D79E1pC5Z--YGplzQMv0Ag{"v":"KERI10JSON000098_",'
b'"i":"EeTLHxy5Npa4SQlFABzhu66FUuSl_iJAafez-encK314","s":"3","t":"'
b'ixn","p":"EA4mqdTa4RPrUJ3B_lmEPSxQK50tDkxRRVwVlLzcAdb0","a":[]}-'
b'AADAAte_OEI-pzZulc4454QS391RR5bPndHIoLG_vLsC4Qmedqz7o04zuisW-7mr'
b'TcfU6ZWs7rlMdSHTBZFErsY-FDQABiHkOIixpSaHGZ80--2JzhmR0TCla09WiEJH'
b'5gTd9XXmxDfzDVON9FgDqLKf_Tf1nmgRh_eQFXu42jfvQG4Q1AAACp478kKPjbh1'
b'pCxlmqa65PplcTa9zG4zsdYz2raYOiregvotKK30LNXm58886gSuSnEWifJvb-zY'
b'wvdK8GsgqBg{"v":"KERI10JSON000098_","i":"EeTLHxy5Npa4SQlFABzhu66'
b'FUuSl_iJAafez-encK314","s":"4","t":"ixn","p":"Ecw6XFmjIeMiYp1MTG'
b'e4KRk9HnygNpnORox6AaCfC44Y","a":[]}-AADAANlbayWV5QQdCTqmh9dSEb13'
b'stiK3srIyL9z4FWMZr_nwejoqK9j9Ic6wBQiUVksayOmGVtknUWrDNOY-PzzgBQA'
b'B2FONMatheF144ziEB7uJpGZa3vugxedmLFfOD5CcoX7z6eX6ZZ_fIVkOHRVOxmv'
b'nfYyVF7uC8G40PeGgkh5eCAACSwyvmjZcik1VBQCCfh5Mq2SQLUvVfFg9plIanMR'
b'Trp7bG_OXE5SSqou6VFNon3Ub8IlBA90-dR7DRRDNPQ5UBw{"v":"KERI10JSON0'
b'00098_","i":"EeTLHxy5Npa4SQlFABzhu66FUuSl_iJAafez-encK314","s":"'
b'5","t":"ixn","p":"EQW9ROsIuNEdKu_ZIm9zDPKIVallegMHz2PVygiZgttc",'
b'"a":[]}-AADAAtjUR1rNouk9T92o22qUbNvptIEjrnqKU3eJTiwdDGoWIwhTLY1T'
b'UunYYpqtbk55oaCyc_MXkP-6l57YDiOAsCwAB5Fl7CZj1P1-NsYgrf2caXvWTfkg'
b'u15C61JRuRpDnjTtevCjxspLQw6hxeJ6-2mTZHqIHC3hzW01Ed2mFOC_eDAACV87'
b'jI4scXXRlNfqXmRrsivc0p3vBIO1OLNC6fex-bFbwV6U8zd_pjWTDZLwCnDm3KJq'
b'labzAfGxX32trskGpCQ{"v":"KERI10JSON000098_","i":"EeTLHxy5Npa4SQl'
b'FABzhu66FUuSl_iJAafez-encK314","s":"6","t":"ixn","p":"E52dhrHeFM'
b'AYWsROU3fPEmD8pCsO_Q2MfvLuZufX43o0","a":[]}-AADAAVe6bfQeaR2X8UIB'
b'OS1HMVLWho7FETQ17FQly0USMiSVDIWh8KTEeW-ndMDUlDBBeNEf3UiwDIRE62-k'
b'ICoofAwABk4ndaxtTYTLmlxWM2Qb38RYtwSRzr7KRRbhLmL_zLXa7KnoAkmCa9LL'
b'ZT5o_6rNjuFruYo7eSL4JfFhCEEn_CwACdPvsbvEV30PaDhbDmdVqI9fzGOSp34e'
b'oTChNPt_UGq3uvCAAlwJa66g4WndLiTkN_BmKZP8YCgn40mUj5TFnAQ')
# Play debMsgs to Cam
# create non-local kevery for Cam to process msgs from Deb
camKevery = eventing.Kevery(db=camHab.db, lax=False, local=False)
parsing.Parser().parse(ims=bytearray(debMsgs), kvy=camKevery)
# camKevery.process(ims=bytearray(debMsgs)) # give copy to process
assert debHab.pre in camKevery.kevers
assert camKevery.kevers[debHab.pre].sn == debHab.kever.sn == 6
assert len(camKevery.cues) == 7
# get disjoints receipts (vrcs) from Cam of Deb's events by processing Cam's cues
camMsgs = camHab.processCues(camKevery.cues)
assert camMsgs == (
b'{"v":"KERI10JSON00014b_","i":"EnjQHu6cA7Mk4gdlnSbhaKtjOh23I2_1ZZ'
b'9KYr-ZdNMg","s":"0","t":"icp","kt":"2","k":["DJBtEHHnzNtE-zxH1xe'
b'X4wxs9rEfUQ8d1ancgJJ1BLKk","DMu6yPITjrOBoTPfsY-r1Rc0ead8GKmoCxA_'
b'BugKehgY","DfhpvbNyYu1fxTBTXy8eCgghMcOYnxkgoGPBr0ZBZPQA"],"n":"E'
b'J85AI0se7UiFBFL1Vl80PnmQ-0dU6q_NXCh6BlSJcKg","bt":"0","b":[],"c"'
b':[],"a":[]}-AADAAya98TxjoKqXBaXKBKmu0_98hrOSjoq8YeT5HlKBZsBvGPGU'
b'NE3Ex9lkhLTl-U_Gx_1JLqEYJJaVrGLaArb5pDAABiYDraSegcRyxe8Syrd3uYqN'
b'HTcalW-_hgVqsUDEZcqdsbje2fBxHO4blsODaSDMm2Crvdj5uvaLch-svOBdEDgA'
b'CVGMTILr9hF9NHVscjqi5yCvtkwMhtZHEqh_6v7N_flmXKCkN2AXAi9OEmf-pdXj'
b'0UlLdab6MkOfbxSRsmrjTDQ{"v":"KERI10JSON000091_","i":"EeTLHxy5Npa'
b'4SQlFABzhu66FUuSl_iJAafez-encK314","s":"0","t":"rct","d":"E4gF0E'
b'1fkpEPBjeq1Sm-RK_Rvg56KOmtBHGfNe_tPxWc"}-FABEnjQHu6cA7Mk4gdlnSbh'
b'aKtjOh23I2_1ZZ9KYr-ZdNMg0AAAAAAAAAAAAAAAAAAAAAAAEZdlVoasgQzvn7mj'
b'ai5hTX7JgLyHrRkeo8Mf5SXL10ro-AADAAY7ru97WNltKYXVBeiqSQ2JhCU6W6Uv'
b'wSmYQRNAQ7Vk3_VslqnAkQDApZwVY-I5nonPybqxS4riBoN8O2MvH3BwABNvm83-'
b'pYo3WR7BAtg13vvHsaX2PfSZn7ajBCRzUXaQ0ZLNr0wJddMywcVtOrgY0myRmiNq'
b'YvetEkb0PJwQG4AwACjit5HUQSAeEMyfC5GeAsPHsGqLwbYMJdqxuZrnzfE2xtXe'
b'3dEz9iSKEFUbykO0f1ThpMLpjat3SsNtZUtn07CQ{"v":"KERI10JSON000091_"'
b',"i":"EeTLHxy5Npa4SQlFABzhu66FUuSl_iJAafez-encK314","s":"1","t":'
b'"rct","d":"EYROVd3Ho83kEgBkrNv6kqTAG4YeCqyPWYBo2jCPteiw"}-FABEnj'
b'QHu6cA7Mk4gdlnSbhaKtjOh23I2_1ZZ9KYr-ZdNMg0AAAAAAAAAAAAAAAAAAAAAA'
b'AEZdlVoasgQzvn7mjai5hTX7JgLyHrRkeo8Mf5SXL10ro-AADAAx2QNu8staqEHq'
b'lv3z__tb9wPPuwTqF3uicXv5BAr3npLW541r9RKcDUQ1yMk1TWcs1vO2a_L2rwtC'
b'h_pP8kzAgABk1B6jf72NOLhSIbAXTbM5JhxiFatklzqYCkiQw12jGxNOHxmEuKNF'
b'0IatvNc3m96hcOb7dc2ZOIQGxX9Ud9nCwAC9LGHfopCtAgtC7OK-aOfYQXN36_Ll'
b'RHZu3eeT9E_pFG9I0LYfoRNf0hGVcyPRBpqrIVOTkH1NBWRbVyOMSYhDA{"v":"K'
b'ERI10JSON000091_","i":"EeTLHxy5Npa4SQlFABzhu66FUuSl_iJAafez-encK'
b'314","s":"2","t":"rct","d":"EA4mqdTa4RPrUJ3B_lmEPSxQK50tDkxRRVwV'
b'lLzcAdb0"}-FABEnjQHu6cA7Mk4gdlnSbhaKtjOh23I2_1ZZ9KYr-ZdNMg0AAAAA'
b'AAAAAAAAAAAAAAAAAAEZdlVoasgQzvn7mjai5hTX7JgLyHrRkeo8Mf5SXL10ro-A'
b'ADAAmMLDAvNgoQ_hnYEfx6uzg0LzRuODZmgwhou-EZv83BNJ9JwNabG9oSuLL15Z'
b'Zc0blUm8GJ0BJuBcE4rjNW3-CAABlkXt_qnbOaBjqlfNXbLxZ_Rx2SCy8pVSYSz7'
b'-UbB2lHpIfGMApVcTamn4pYhyOnaEVVO47tWZ3vDmXkf3WrKBQAC4MZmfqt3B9SY'
b'DROZk8shO6vWxzHfZVBzLtNZAJrJLq8FoZ66q3bG4Pgn1pc0ID0fjkpXSiR5aOF2'
b'2QhT06erDA{"v":"KERI10JSON000091_","i":"EeTLHxy5Npa4SQlFABzhu66F'
b'UuSl_iJAafez-encK314","s":"3","t":"rct","d":"Ecw6XFmjIeMiYp1MTGe'
b'4KRk9HnygNpnORox6AaCfC44Y"}-FABEnjQHu6cA7Mk4gdlnSbhaKtjOh23I2_1Z'
b'Z9KYr-ZdNMg0AAAAAAAAAAAAAAAAAAAAAAAEZdlVoasgQzvn7mjai5hTX7JgLyHr'
b'Rkeo8Mf5SXL10ro-AADAASQpD32fjD-IJuz9w1CFLXYtHE-9rtVRqSvQPqT8yjHO'
b'lKMNG2apDa___svlQSw_OmgsCB-LzQn7dyyv73w3KCQABcbrlJRw3GaM5l5NCq_7'
b'czfZBAyXPwvpfjwM3BAMnt-tDmTEoJku4MpruiwpgSWcPw_Xp3SE3nmxPIK6-Q08'
b'aCAAC58Bw2io7IEt3ZvfEdaHns97Y4QGCnFovmz9VFfp3c2Mjioa1sDgOf9uybHV'
b'MKBhpsUy2_BfpgkVOhmcY6GtzCw{"v":"KERI10JSON000091_","i":"EeTLHxy'
b'5Npa4SQlFABzhu66FUuSl_iJAafez-encK314","s":"4","t":"rct","d":"EQ'
b'W9ROsIuNEdKu_ZIm9zDPKIVallegMHz2PVygiZgttc"}-FABEnjQHu6cA7Mk4gdl'
b'nSbhaKtjOh23I2_1ZZ9KYr-ZdNMg0AAAAAAAAAAAAAAAAAAAAAAAEZdlVoasgQzv'
b'n7mjai5hTX7JgLyHrRkeo8Mf5SXL10ro-AADAAsW_khBjW_8JTAMqSmfO719vBlr'
b'NVpJu-8bpboWZm8hhYfKEEfUWC40GWoYwSN_Xk-2v6oPVp4_oHVVB4hMavAAABuR'
b'VEC014QaDOacru4RchNJBZCa5jKhfK10vt-Mb88mQY-HF-kVywqvGnkFyCZowKPz'
b'sLEJbTAa8py3hCKJ-5AQACo4tT9i1sv7JM6zhprqwklVnYKsG6Y1DCfGj6c6vIWz'
b'StZeO_ICz9iOZkB8IuwJp8r5AYgqJlNl8cl93sgknZDw{"v":"KERI10JSON0000'
b'91_","i":"EeTLHxy5Npa4SQlFABzhu66FUuSl_iJAafez-encK314","s":"5",'
b'"t":"rct","d":"E52dhrHeFMAYWsROU3fPEmD8pCsO_Q2MfvLuZufX43o0"}-FA'
b'BEnjQHu6cA7Mk4gdlnSbhaKtjOh23I2_1ZZ9KYr-ZdNMg0AAAAAAAAAAAAAAAAAA'
b'AAAAAEZdlVoasgQzvn7mjai5hTX7JgLyHrRkeo8Mf5SXL10ro-AADAA_06qSZGjm'
b'75-wLDLPBK-p32mM1oeDQAQD2wfdQ75jn-JRkYqGztS2tQDBFlxK4uiceok50-ZJ'
b'f64An_oB649AQABZpuMeCzUi0oF98kXROI94G3cWLVrDVdbvxDNe60uE7rQ-qwDq'
b'tErr65hMaCgbTO3zD9aumRQMU5-1uWZrIxWDQACyukFA_3zKJQyctI3JER5XO8r_'
b'iz9Ga5CXxnZFqSuGmQqQEpA9wMDOZ66hRBRNgImMQh-btX4sqbjO_ycaGmjBg{"v'
b'":"KERI10JSON000091_","i":"EeTLHxy5Npa4SQlFABzhu66FUuSl_iJAafez-'
b'encK314","s":"6","t":"rct","d":"ENsvgXw3H4VhL3i-eONdu7tgarzrgm9z'
b'c2Lj3XlwZ2_4"}-FABEnjQHu6cA7Mk4gdlnSbhaKtjOh23I2_1ZZ9KYr-ZdNMg0A'
b'AAAAAAAAAAAAAAAAAAAAAAEZdlVoasgQzvn7mjai5hTX7JgLyHrRkeo8Mf5SXL10'
b'ro-AADAAEjRuwX1j8xEYIXjf1cmhLpmF4IwKBGU2fvL0rbbBMN4bA4VTtnAqo6Nh'
b'GYK4XKKVL_SKLaL9x9PcFc5ykBqsBwABVwlNGkdx_oScxgYzhLMDmAi-Ro5n85ly'
b'LRI6DdtMIRfpgyIa2pPw1BkA2FmmsUkkwdTWxNq77AyfbcQzDKOzDAACSIxniS9R'
b'7dsM11Q8uD5qSAxcGyF-CUNYT7NZmQdL52MnszSYy7Mvpwnq9L842jNgL_G8zqif'
b'0eizybIVsQj7AQ')
# Play camMsgs to Deb
# create non-local kevery for Deb to process msgs from Cam
debKevery = eventing.Kevery(db=debHab.db, lax=False, local=False)
parsing.Parser().parse(ims=bytearray(camMsgs), kvy=debKevery)
# debKevery.process(ims=bytearray(camMsgs)) # give copy to process
assert camHab.pre in debKevery.kevers
assert debKevery.kevers[camHab.pre].sn == camHab.kever.sn == 0
assert len(debKevery.cues) == 1
# get disjoints receipts (vrcs) from Deb of Cam's events by processing Deb's cues
debCamVrcs = debHab.processCues(debKevery.cues)
assert debCamVrcs == (
b'{"v":"KERI10JSON000091_","i":"EnjQHu6cA7Mk4gdlnSbhaKtjOh23I2_1ZZ'
b'9KYr-ZdNMg","s":"0","t":"rct","d":"EZdlVoasgQzvn7mjai5hTX7JgLyHr'
b'Rkeo8Mf5SXL10ro"}-FABEeTLHxy5Npa4SQlFABzhu66FUuSl_iJAafez-encK31'
b'40AAAAAAAAAAAAAAAAAAAAAAgEA4mqdTa4RPrUJ3B_lmEPSxQK50tDkxRRVwVlLz'
b'cAdb0-AADAARwO4P3VantEgLrBs4K7hvStQ_kpN5EiFjklROGNkV19PBtxO0uUU8'
b'0RDbWBjuUgIm59v9oJQKe-hdS8neEI2CgABAptixkGIj7UX1PU9Vlr1kZexUaIie'
b'AugElzH99gCfQG2MMtOb3EO5ybgMHkWKKr7PaTpi4H2XrQ-me-PT_fGAgACSUTaW'
b'0o0XhD0bQn-Qv2TwDj01L8zRyy7dqlGemZSzl2DBnliA_NqGHBQ2QJKIZfuIc6Mc'
b'c3n_HpqI6s7xt-jCQ')
# Play disjoints debCamVrcs to Cam
parsing.Parser().parseOne(ims=bytearray(debCamVrcs), kvy=camKevery)
# camKevery.processOne(ims=bytearray(debCamVrcs)) # give copy to process
# Play debMsgs to Bev
# create non-local kevery for Bev to process msgs from Deb
bevKevery = eventing.Kevery(db=bevHab.db, lax=False, local=False)
parsing.Parser().parse(ims=bytearray(debMsgs), kvy=bevKevery)
# bevKevery.process(ims=bytearray(debMsgs)) # give copy to process
assert debHab.pre in bevKevery.kevers
assert bevKevery.kevers[debHab.pre].sn == debHab.kever.sn == 6
assert len(bevKevery.cues) == 7
# get disjoints receipts (rcts) from Bev of Deb's events by processing Bevs's cues
bevMsgs = bevHab.processCues(bevKevery.cues)
assert bevMsgs == (
b'{"v":"KERI10JSON0000c1_","i":"BCqmHiYBZx_uaQiCTVeum-vt1ZPti8chqb'
b'-GpQBPaurA","s":"0","t":"icp","kt":"1","k":["BCqmHiYBZx_uaQiCTVe'
b'um-vt1ZPti8chqb-GpQBPaurA"],"n":"","bt":"0","b":[],"c":[],"a":[]'
b'}-AABAAgO3RAPPeeFcl5ZvoIR55jsqjQsfKQNenz9EUITRBtu9Q5Js-Umzd_mvSq'
b'ZymNJnwLL656s7P-hTZRtG-8-rhBg{"v":"KERI10JSON000091_","i":"EeTLH'
b'xy5Npa4SQlFABzhu66FUuSl_iJAafez-encK314","s":"0","t":"rct","d":"'
b'E4gF0E1fkpEPBjeq1Sm-RK_Rvg56KOmtBHGfNe_tPxWc"}-CABBCqmHiYBZx_uaQ'
b'iCTVeum-vt1ZPti8chqb-GpQBPaurA0B0VYuHkBtlKSqsXj_0-2mSNzQ9UOiO-iX'
b'jG4V74ivokdt9GUYh5OnZ-lW-SfyzGhQv6QlPRcy7nWTyi_mMzOCAg{"v":"KERI'
b'10JSON000091_","i":"EeTLHxy5Npa4SQlFABzhu66FUuSl_iJAafez-encK314'
b'","s":"1","t":"rct","d":"EYROVd3Ho83kEgBkrNv6kqTAG4YeCqyPWYBo2jC'
b'Pteiw"}-CABBCqmHiYBZx_uaQiCTVeum-vt1ZPti8chqb-GpQBPaurA0B_gS89Rl'
b'Y4y-YTTgBpjdBiA6l8PbGZkd4ODmA3RQyDGVapnpMB_SLvolQuz7WxyE0NsnpJ-D'
b'nVFTt-Dv-dKGADA{"v":"KERI10JSON000091_","i":"EeTLHxy5Npa4SQlFABz'
b'hu66FUuSl_iJAafez-encK314","s":"2","t":"rct","d":"EA4mqdTa4RPrUJ'
b'3B_lmEPSxQK50tDkxRRVwVlLzcAdb0"}-CABBCqmHiYBZx_uaQiCTVeum-vt1ZPt'
b'i8chqb-GpQBPaurA0BcbCV4kKek9oab8MDhzvzf0ucYnTIzNiWHLNh65mpxUa2XL'
b'jrEfbWlrjpiDXTyYShlLNt8fZxnnwoAW4aelTyBA{"v":"KERI10JSON000091_"'
b',"i":"EeTLHxy5Npa4SQlFABzhu66FUuSl_iJAafez-encK314","s":"3","t":'
b'"rct","d":"Ecw6XFmjIeMiYp1MTGe4KRk9HnygNpnORox6AaCfC44Y"}-CABBCq'
b'mHiYBZx_uaQiCTVeum-vt1ZPti8chqb-GpQBPaurA0BZSz6DBrS702RsSJ2qhp5V'
b'_4UG3u4v9_PZUxZqkTnBmkxkX-dA9Ml5c_2YaZ0_ETfhrbq30r1elT4gXhKJbRAA'
b'A{"v":"KERI10JSON000091_","i":"EeTLHxy5Npa4SQlFABzhu66FUuSl_iJAa'
b'fez-encK314","s":"4","t":"rct","d":"EQW9ROsIuNEdKu_ZIm9zDPKIVall'
b'egMHz2PVygiZgttc"}-CABBCqmHiYBZx_uaQiCTVeum-vt1ZPti8chqb-GpQBPau'
b'rA0BFvLdsWHk5oGOZQCnDEVww3dMlXZYo9JzNbuJUdK0IqWaJAQBIMEKOqLvZzMx'
b'FIi6xNmJCQYKFu5328ovxtddCg{"v":"KERI10JSON000091_","i":"EeTLHxy5'
b'Npa4SQlFABzhu66FUuSl_iJAafez-encK314","s":"5","t":"rct","d":"E52'
b'dhrHeFMAYWsROU3fPEmD8pCsO_Q2MfvLuZufX43o0"}-CABBCqmHiYBZx_uaQiCT'
b'Veum-vt1ZPti8chqb-GpQBPaurA0BDaF78ajVz3FOsApq_1iBTK2i1PT8F0Fgz4q'
b'r4HuboYf5XMWR8IvrYcYvthaaRP5168Ge-npP6UgRUd7t8vwCDw{"v":"KERI10J'
b'SON000091_","i":"EeTLHxy5Npa4SQlFABzhu66FUuSl_iJAafez-encK314","'
b's":"6","t":"rct","d":"ENsvgXw3H4VhL3i-eONdu7tgarzrgm9zc2Lj3XlwZ2'
b'_4"}-CABBCqmHiYBZx_uaQiCTVeum-vt1ZPti8chqb-GpQBPaurA0B9TkOKxh1bS'
b'1gwzpNCx5R-AW0D_xHbbBNlVSdyPW4VUJm4PvRCK9UFsHHk2LGv0KbqRe7ftiY6o'
b'V7hSkY4rfGAw')
# Play bevMsgs to Deb
parsing.Parser().parse(ims=bytearray(bevMsgs), kvy=debKevery)
# debKevery.process(ims=bytearray(bevMsgs)) # give copy to process
assert bevHab.pre in debKevery.kevers
assert debKevery.kevers[bevHab.pre].sn == bevHab.kever.sn == 0
assert len(debKevery.cues) == 1
# get disjoints receipts (vrcs) from Deb of Bev's events by processing Deb's cues
debBevVrcs = debHab.processCues(debKevery.cues)
assert debBevVrcs == (
b'{"v":"KERI10JSON000091_","i":"BCqmHiYBZx_uaQiCTVeum-vt1ZPti8chqb'
b'-GpQBPaurA","s":"0","t":"rct","d":"ERejsDJsBCs9b2j0Cd3pIDxNoGEw8'
b'zQd94AXMduyyIF8"}-FABEeTLHxy5Npa4SQlFABzhu66FUuSl_iJAafez-encK31'
b'40AAAAAAAAAAAAAAAAAAAAAAgEA4mqdTa4RPrUJ3B_lmEPSxQK50tDkxRRVwVlLz'
b'cAdb0-AADAApoGcQmhmFQ2tQmovG0aZNxBN3QMgynKdfVA3pNyJQ-UMBnliFkeaC'
b'gioFRXuH9SLm3R1XlFjmIJNvZ7hoJ3bBQABLKipRIasV9TRzcoGF7sQs9vfkcneF'
b'7y1YqKMw9oWKEzhJKMuk0QUz6E1fse8mUDazKQsXqY1uKnSFhfjuqAhBQACFrF4i'
b'Nt4Cm0srlq1QsXwJe3duzNKOEdf4z-WxWSw49dDpYyfllWEIs8Eu65IADEycjZR3'
b'q9BTeO9QARuieV_Dw')
# Play disjoints debBevVrcs to Bev
parsing.Parser().parseOne(ims=bytearray(debBevVrcs), kvy=bevKevery)
# bevKevery.processOne(ims=bytearray(debBevVrcs)) # give copy to process
# now setup conjoint replay
# Replay Deb's First Seen Events with receipts (vrcs and rcts) from both Cam and Bev
# datetime is different in each run in the fse attachment in clone replay
# so we either have to force dts in db or we parse in pieces
debFelMsgs = bytearray()
fn = 0
cloner = debHab.db.clonePreIter(pre=debHab.pre,
fn=fn) # create iterator
msg = next(cloner) # get zeroth event with attachments
assert len(msg) == 1423
debFelMsgs.extend(msg)
# parse msg
serder = coring.Serder(raw=msg)
assert serder.raw == debHab.iserder.raw
assert serder.sn == fn # no recovery forks so sn == fn
assert serder.ked["t"] == coring.Ilks.icp
del msg[:len(serder.raw)]
assert len(msg) == 1076
counter = coring.Counter(
qb64b=msg) # attachment length quadlets counter
assert counter.code == coring.CtrDex.AttachedMaterialQuadlets
assert counter.count == (len(msg) - len(counter.qb64b)) // 4 == 268
del msg[:len(counter.qb64b)]
assert len(msg) == 1072 == 268 * 4
counter = coring.Counter(qb64b=msg) # indexed signatures counter
assert counter.code == coring.CtrDex.ControllerIdxSigs
assert counter.count == 3 # multisig deb
del msg[:len(counter.qb64b)]
assert len(msg) == 1068
for i in range(counter.count): # parse signatures
siger = coring.Siger(qb64b=msg)
del msg[:len(siger.qb64b)]
assert len(msg) == 1068 - 3 * len(siger.qb64b) == 804
counter = coring.Counter(qb64b=msg) # trans receipt (vrc) counter
assert counter.code == coring.CtrDex.TransReceiptQuadruples
assert counter.count == 3 # multisig cam
del msg[:len(counter.qb64b)]
assert len(msg) == 800
for i in range(counter.count): # parse receipt quadruples
prefixer, seqner, diger, siger = eventing.deTransReceiptQuadruple(
msg, strip=True)
assert len(msg) == 800 - 3 * (len(prefixer.qb64b) + len(
seqner.qb64b) + len(diger.qb64b) + len(siger.qb64b)) == 200
counter = coring.Counter(qb64b=msg) # nontrans receipt (rct) counter
assert counter.code == coring.CtrDex.NonTransReceiptCouples
assert counter.count == 1 # single sig bev
del msg[:len(counter.qb64b)]
assert len(msg) == 196
for i in range(counter.count): # parse receipt couples
prefixer, cigar = eventing.deReceiptCouple(msg, strip=True)
assert len(
msg) == 196 - 1 * (len(prefixer.qb64b) + len(cigar.qb64b)) == 64
counter = coring.Counter(qb64b=msg) # first seen replay couple counter
assert counter.code == coring.CtrDex.FirstSeenReplayCouples
assert counter.count == 1
del msg[:len(counter.qb64b)]
assert len(msg) == 60
seqner = coring.Seqner(qb64b=msg)
assert seqner.sn == fn == 0
del msg[:len(seqner.qb64b)]
assert len(msg) == 36 # 24 less
dater = coring.Dater(qb64b=msg)
assert (helping.fromIso8601(helping.nowIso8601()) -
helping.fromIso8601(dater.dts)) > datetime.timedelta()
del msg[:len(dater.qb64b)]
assert len(msg) == 0 # 36 less
cloner.close() # must close or get lmdb error upon with exit
"""Exception ignored in: <generator object LMDBer.getAllOrdItemPreIter at 0x106fe1c10>
Traceback (most recent call last):
File "/Users/Load/Data/Code/public/keripy/src/keri/db/dbing.py", line 512, in getAllOrdItemPreIter
yield (cn, bytes(val)) # (on, dig) of event
lmdb.Error: Attempt to operate on closed/deleted/dropped object.
"""
fn += 1
cloner = debHab.db.clonePreIter(pre=debHab.pre,
fn=fn) # create iterator not at 0
msg = next(cloner) # next event with attachments
assert len(msg) == 1228
serder = coring.Serder(raw=msg)
assert serder.sn == fn # no recovery forks so sn == fn
assert serder.ked["t"] == coring.Ilks.ixn
debFelMsgs.extend(msg)
fn += 1
msg = next(cloner) # get zeroth event with attachments
serder = coring.Serder(raw=msg)
assert serder.sn == fn # no recovery forks so sn == fn
assert serder.ked["t"] == coring.Ilks.rot
assert len(msg) == 1476
assert ([verfer.qb64 for verfer in serder.verfers
] == [verfer.qb64 for verfer in debHab.kever.verfers])
debFelMsgs.extend(msg)
fn += 1
while (fn <= 6):
msg = next(cloner) # get zeroth event with attachments
serder = coring.Serder(raw=msg)
assert serder.sn == fn # no recovery forks so sn == fn
assert serder.ked["t"] == coring.Ilks.ixn
assert len(msg) == 1228
debFelMsgs.extend(msg)
fn += 1
assert len(debFelMsgs) == 9039
cloner.close() # must close or get lmdb error upon with exit
msgs = debHab.replay()
assert msgs == debFelMsgs
# Play Cam's messages to Bev
parsing.Parser().parse(ims=bytearray(camMsgs), kvy=bevKevery)
# bevKevery.process(ims=bytearray(camMsgs)) # give copy to process
assert camHab.pre in bevKevery.kevers
assert bevKevery.kevers[camHab.pre].sn == camHab.kever.sn == 0
assert len(bevKevery.cues) == 1
# Play Bev's messages to Cam
parsing.Parser().parse(ims=bytearray(bevMsgs), kvy=camKevery)
# camKevery.process(ims=bytearray(bevMsgs)) # give copy to process
assert bevHab.pre in camKevery.kevers
assert camKevery.kevers[bevHab.pre].sn == bevHab.kever.sn == 0
assert len(camKevery.cues) == 1
camDebFelMsgs = camHab.replay(pre=debHab.pre)
bevDebFelMsgs = bevHab.replay(pre=debHab.pre)
assert len(bevDebFelMsgs) == len(camDebFelMsgs) == len(
debFelMsgs) == 9039
# create non-local kevery for Art to process conjoint replay msgs from Deb
artKevery = eventing.Kevery(db=artHab.db, lax=False, local=False)
# process Cam's inception so Art will proces Cam's vrcs without escrowing
camIcpMsg = camHab.makeOwnInception()
parsing.Parser().parse(ims=bytearray(camIcpMsg), kvy=artKevery)
# artKevery.process(ims=bytearray(camIcpMsg))
assert camHab.pre in artKevery.kevers
assert len(artKevery.cues) == 1
# process in cloned mode
artKevery.cloned = True
parsing.Parser().parse(ims=bytearray(debFelMsgs), kvy=artKevery)
assert debHab.pre in artKevery.kevers
assert artKevery.kevers[debHab.pre].sn == debHab.kever.sn == 6
assert len(artKevery.cues) == 8
artDebFelMsgs = artHab.replay(pre=debHab.pre)
assert len(artDebFelMsgs) == 9039
assert not os.path.exists(artKS.path)
assert not os.path.exists(artDB.path)
assert not os.path.exists(bevKS.path)
assert not os.path.exists(bevDB.path)
assert not os.path.exists(camKS.path)
assert not os.path.exists(camDB.path)
assert not os.path.exists(debKS.path)
assert not os.path.exists(debDB.path)
"""End Test"""
def test_wallet():
sidSalt = coring.Salter(raw=b'0123456789abcdef').qb64
with basing.openDB(name="sid") as sidDB, \
keeping.openKS(name="sid") as sidKS, \
openPocket(name="sid") as sidPDB:
sidHab = habbing.Habitat(ks=sidKS, db=sidDB, salt=sidSalt, temp=True)
assert sidHab.pre == "E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E"
sed = dict()
sed["$id"] = ""
sed["$schema"] = "http://json-schema.org/draft-07/schema#"
sed.update(dict(
type="object",
properties=dict(
id=dict(
type="string"
),
lei=dict(
type="string"
)
)
))
schemer = scheming.Schemer(sed=sed, typ=scheming.JSONSchema(), code=coring.MtrDex.Blake3_256)
credSubject = dict(
id="did:keri:Efaavv0oadfghasdfn443fhbyyr4v", # this needs to be generated from a KEL
lei="254900OPPU84GM83MG36",
issuanceDate="2021-06-27T21:26:21.233257+00:00",
)
cache = CacheResolver()
cache.add(schemer.said, schemer.raw)
creder = credential(issuer=sidHab.pre,
schema=schemer.said,
subject=credSubject,
typ=JSONSchema(resolver=cache))
assert creder.said == "EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM"
msg = sidHab.endorse(serder=creder)
assert msg == (
b'{"v":"KERI10JSON000136_","i":"EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM",'
b'"x":"EeCCZi1R5xHUlhsyQNm_7NrUQTEKZH5P9vBomnc9AihY","ti":"E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E",'
b'"d":{"id":"did:keri:Efaavv0oadfghasdfn443fhbyyr4v","lei":"254900OPPU84GM83MG36",'
b'"issuanceDate":"2021-06-27T21:26:21.233257+00:00"}}-VA0-FABE4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE'
b'-YfcI9E0AAAAAAAAAAAAAAAAAAAAAAAElHzHwX3V6itsD2Ksg_CNBbUNTBYzLYw-AxDNI7_ZmaI'
b'-AABAA0pXbQllgzXr88IczAnsPrdhgFKs9wNQvfSfzyrtcvbTwq-U1DmBluAklntCqH1AbBL6TWLZIDGi83BHLWJ82CA')
ser = (
b'{"v":"KERI10JSON000136_","i":"EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM",'
b'"x":"EeCCZi1R5xHUlhsyQNm_7NrUQTEKZH5P9vBomnc9AihY","ti":"E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E",'
b'"d":{"id":"did:keri:Efaavv0oadfghasdfn443fhbyyr4v","lei":"254900OPPU84GM83MG36",'
b'"issuanceDate":"2021-06-27T21:26:21.233257+00:00"}}')
seal = (
b'E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E0AAAAAAAAAAAAAAAAAAAAAAAElHzHwX3V6itsD2Ksg_CNBbUNTBYzLYw'
b'-AxDNI7_ZmaI')
sig0 = (
b'AA0pXbQllgzXr88IczAnsPrdhgFKs9wNQvfSfzyrtcvbTwq-U1DmBluAklntCqH1AbBL6TWLZIDGi83BHLWJ82CA'
)
sidWallet = Wallet(hab=sidHab, db=sidPDB)
parseCredential(ims=msg, wallet=sidWallet, typ=JSONSchema(resolver=cache))
# verify we can load serialized VC by SAID
key = creder.said.encode("utf-8")
assert sidPDB.getSers(key) == ser
# verify the signature
sigs = sidPDB.getSigs(key)
assert len(sigs) == 1
assert sigs[0] == sig0
# verify the seal
sl = sidPDB.getSeals(key)
assert sl == seal
# verify we can look up credential by Schema SAID
schema = sidPDB.getSchms(schemer.saider.qb64b)
assert len(schema) == 1
assert schema[0] == key
def test_store_exchanger():
with dbing.openLMDB(cls=Mailboxer) as mber, \
basing.openDB(name="test") as db, \
keeping.openKS(name="test") as ks:
salt = coring.Salter(raw=b'0123456789abcdef').qb64
hab = habbing.Habitat(ks=ks, db=db, salt=salt, temp=True)
exchr = exchanging.StoreExchanger(hab=hab, mbx=mber)
source = coring.Prefixer(
qb64="E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E")
siger = coring.Siger(
qb64=
"AAMKEkKlqSYcAbOHfNXQ_D0Rbj9bQD5FqhFqckAlDnOFozRKOIPrCWaszRzSUN20UBj80tO5ozN35KrQp9m7Z1AA"
)
d = dict(a="b", b=123)
exn = exchanging.exchange("/credential/issue",
payload=d,
date="2021-07-15T13:01:37.624492+00:00")
with pytest.raises(MissingSignatureError):
exchr.processEvent(serder=exn, source=source, sigers=[siger])
sigers = hab.mgr.sign(ser=exn.raw, verfers=hab.kever.verfers)
with pytest.raises(MissingDestinationError):
exchr.processEvent(serder=exn, source=source, sigers=sigers)
for idx in range(10):
d = dict(a="b", b=idx)
dest = coring.Prefixer(
qb64="E4D919wF4oiG7ck6mnBWTRD_Z-Io0wZKCxL0zjx5je9I")
source = coring.Prefixer(
qb64="E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E")
exn = exchanging.exchange("/credential/issue",
payload=d,
recipient=dest.qb64,
date="2021-07-15T13:01:37.624492+00:00")
sigers = hab.mgr.sign(ser=exn.raw, verfers=hab.kever.verfers)
exchr.processEvent(serder=exn, source=source, sigers=sigers)
msgs = []
for msg in mber.clonePreIter(pre=dest.qb64b, fn=0):
msgs.append(msg)
assert (len(msgs)) == 10
for idx, msg in enumerate(msgs):
exn = coring.Serder(msg)
d = exn.ked["q"]
assert d["b"] == idx
msgs = []
for msg in mber.clonePreIter(pre=dest.qb64b, fn=10):
msgs.append(msg)
assert (len(msgs)) == 0
msgs = []
for msg in mber.clonePreIter(pre=dest.qb64b, fn=4):
msgs.append(msg)
assert (len(msgs)) == 6
def test_proving():
sidSalt = coring.Salter(raw=b'0123456789abcdef').qb64
hanSalt = coring.Salter(raw=b'abcdef0123456789').qb64
vicSalt = coring.Salter(raw=b'fedcba9876543210').qb64
with basing.openDB(name="sid") as sidDB, \
keeping.openKS(name="sid") as sidKS, \
basing.openDB(name="vic") as vicDB, \
keeping.openKS(name="vic") as vicKS, \
basing.openDB(name="han") as hanDB, \
keeping.openKS(name="han") as hanKS, \
openPocket(name="han") as hanPDB:
limit = 1.0
tock = 1.0
doist = doing.Doist(limit=limit, tock=tock)
sidHab = habbing.Habitat(ks=sidKS, db=sidDB, salt=sidSalt, temp=True)
assert sidHab.pre == "E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E"
sidIcpMsg = sidHab.makeOwnInception()
hanKvy = eventing.Kevery(db=hanDB)
parsing.Parser().parse(ims=bytearray(sidIcpMsg), kvy=hanKvy)
assert hanKvy.kevers[sidHab.pre].sn == 0 # accepted event
hanHab = habbing.Habitat(ks=hanKS, db=hanDB, salt=hanSalt, temp=True)
assert hanHab.pre == "EKDWzykRd45o5UQyprm_9e8UcltXGo1tZCrdfGBTA8tc"
hanIcpMsg = hanHab.makeOwnInception()
vicKvy = eventing.Kevery(db=vicDB)
parsing.Parser().parse(ims=bytearray(hanIcpMsg), kvy=vicKvy)
assert vicKvy.kevers[hanHab.pre].sn == 0 # accepted event
vicHab = habbing.Habitat(ks=vicKS, db=vicDB, salt=vicSalt, temp=True)
assert vicHab.pre == "E8HQASAgOnZnQ4T7rv3dcvj0-UydrTTtyCprhEASk__o"
vicIcpMsg = vicHab.makeOwnInception()
parsing.Parser().parse(ims=bytearray(vicIcpMsg), kvy=hanKvy)
assert hanKvy.kevers[vicHab.pre].sn == 0 # accepted event
sed = dict()
sed["$id"] = ""
sed["$schema"] = "http://json-schema.org/draft-07/schema#"
sed.update(
dict(type="object",
properties=dict(id=dict(type="string"),
lei=dict(type="string"))))
schemer = scheming.Schemer(sed=sed,
typ=scheming.JSONSchema(),
code=coring.MtrDex.Blake3_256)
cache = CacheResolver()
cache.add(schemer.said, schemer.raw)
jsonSchema = JSONSchema(resolver=cache)
credSubject = dict(
id=
"did:keri:Efaavv0oadfghasdfn443fhbyyr4v", # this needs to be generated from a KEL
lei="254900OPPU84GM83MG36",
issuanceDate="2021-06-27T21:26:21.233257+00:00",
)
creder = credential(issuer=sidHab.pre,
schema=schemer.said,
subject=credSubject,
typ=JSONSchema(resolver=cache))
assert creder.said == "EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM"
msg = sidHab.endorse(serder=creder)
hanWallet = Wallet(hab=hanHab, db=hanPDB)
parseCredential(ims=msg,
wallet=hanWallet,
typ=JSONSchema(resolver=cache))
# verify we can load serialized VC by SAID
key = creder.said.encode("utf-8")
assert hanPDB.getSers(key) is not None
# Create Red's wallet and Issue Handler for receiving the credential
hanRequestHandler = RequestHandler(wallet=hanWallet, typ=jsonSchema)
hanExc = exchanging.Exchanger(hab=hanHab,
tymth=doist.tymen(),
handlers=[hanRequestHandler])
# Create the issue credential payload
pl = dict(input_descriptors=[dict(x=schemer.said)])
# Create the `exn` message for presentation request
vicExcSrdr = exchanging.exchange(route="/presentation/request",
payload=pl)
excMsg = vicHab.sanction(vicExcSrdr)
# Parse the exn presentation request message on Han's side
parsing.Parser().parse(ims=bytearray(excMsg), kvy=hanKvy, exc=hanExc)
doist.do(doers=[hanExc])
assert doist.tyme == limit
resp = hanRequestHandler.cues.popleft()
assert resp is not None
respSer = coring.Serder(raw=resp.raw)
assert respSer.ked['t'] == coring.Ilks.exn
assert respSer.ked['r'] == "/presentation/proof"
data = respSer.ked['q']
assert "presentation_submission" in data
pe = data["presentation_submission"]
assert "descriptor_map" in pe
dm = pe["descriptor_map"]
assert len(dm) == 1
assert dm[0]["id"] == schemer.said
assert "verifiableCredential" in data
vcs = data["verifiableCredential"]
assert len(vcs) == 1
proof = (
"-FABE4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E0AAAAAAAAAAAAAAAAAAAAAAAElHzHwX3V6itsD2Ksg_CNBbUNTBYzLYw"
"-AxDNI7_ZmaI-AABAA0pXbQllgzXr88IczAnsPrdhgFKs9wNQvfSfzyrtcvbTwq-U1DmBluAklntCqH1AbBL6TWLZIDGi83BHLWJ82CA"
)
assert vcs[0]["proof"] == proof
def test_directing_basic():
"""
Test directing
"""
help.ogler.resetLevel(level=logging.INFO)
# set of secrets (seeds for private keys)
bobSecrets = [
'ArwXoACJgOleVZ2PY7kXn7rA0II0mHYDhc6WrBH8fDAc',
'A6zz7M08-HQSFq92sJ8KJOT2cZ47x7pXFQLPB0pckB3Q',
'AcwFTk-wgk3ZT2buPRIbK-zxgPx-TKbaegQvPEivN90Y',
'Alntkt3u6dDgiQxTATr01dy8M72uuaZEf9eTdM-70Gk8',
'A1-QxDkso9-MR1A8rZz_Naw6fgaAtayda8hrbkRVVu1E',
'AKuYMe09COczwf2nIoD5AE119n7GLFOVFlNLxZcKuswc',
'AxFfJTcSuEE11FINfXMqWttkZGnUZ8KaREhrnyAXTsjw',
'ALq-w1UKkdrppwZzGTtz4PWYEeWm0-sDHzOv5sq96xJY'
]
bobSecrecies = []
for secret in bobSecrets: # convert secrets to secrecies
bobSecrecies.append([secret])
# create bob signers
bobSigners = [coring.Signer(qb64=secret) for secret in bobSecrets]
assert [signer.qb64 for signer in bobSigners] == bobSecrets
# bob inception transferable (nxt digest not empty)
bobSerder = eventing.incept(keys=[bobSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[bobSigners[1].verfer.qb64]).qb64,
code=coring.MtrDex.Blake3_256)
bob = bobSerder.ked["i"]
assert bob == 'EQf1hzB6s5saaQPdDAsEzSMEFoQx_WLsq93bjPu5wuqA'
# set of secrets (seeds for private keys)
eveSecrets = ['AgjD4nRlycmM5cPcAkfOATAp8wVldRsnc9f1tiwctXlw',
'AKUotEE0eAheKdDJh9QvNmSEmO_bjIav8V_GmctGpuCQ',
'AK-nVhMMJciMPvmF5VZE_9H-nhrgng9aJWf7_UHPtRNM',
'AT2cx-P5YUjIw_SLCHQ0pqoBWGk9s4N1brD-4pD_ANbs',
'Ap5waegfnuP6ezC18w7jQiPyQwYYsp9Yv9rYMlKAYL8k',
'Aqlc_FWWrxpxCo7R12uIz_Y2pHUH2prHx1kjghPa8jT8',
'AagumsL8FeGES7tYcnr_5oN6qcwJzZfLKxoniKUpG4qc',
'ADW3o9m3udwEf0aoOdZLLJdf1aylokP0lwwI_M2J9h0s']
eveSecrecies = []
for secret in eveSecrets: # convert secrets to secrecies
eveSecrecies.append([secret])
# create eve signers
eveSigners = [coring.Signer(qb64=secret) for secret in eveSecrets]
assert [signer.qb64 for signer in eveSigners] == eveSecrets
# eve inception transferable (nxt digest not empty)
eveSerder = eventing.incept(keys=[eveSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[eveSigners[1].verfer.qb64]).qb64,
code=coring.MtrDex.Blake3_256)
eve = eveSerder.ked["i"]
assert eve == 'ED9EB3sA5u2vCPOEmX3d7bEyHiSh7Xi8fjew2KMl3FQM'
with basing.openDB(name="eve") as eveDB, keeping.openKS(name="eve") as eveKS, \
basing.openDB(name="bob") as bobDB, keeping.openKS(name="bob") as bobKS:
limit = 0.125
tock = 0.03125
doist = doing.Doist(limit=limit, tock=tock)
bobPort = 5620 # bob's TCP listening port for server
evePort = 5621 # eve's TCP listneing port for server
eveKevers = dict()
# setup bob
bobHab = habbing.Habitat(ks=bobKS, db=bobDB, secrecies=bobSecrecies,
temp=True)
assert bobHab.ks == bobKS
assert bobHab.db == bobDB
assert bobHab.iserder.dig == bobSerder.dig
assert bobHab.pre == bob
bobClient = clienting.Client(tymth=doist.tymen(), host='127.0.0.1', port=evePort)
bobClientDoer = clienting.ClientDoer(tymth=doist.tymen(), client=bobClient)
bobDirector = directing.Director(hab=bobHab, client=bobClient)
assert bobDirector.hab == bobHab
assert bobDirector.client == bobClient
assert id(bobDirector.hab.kvy.kevers) == id(bobHab.kevers)
assert bobDirector.hab.kvy.db == bobDB
bobReactor = directing.Reactor(hab=bobHab, client=bobClient)
assert bobReactor.hab == bobHab
assert bobReactor.client == bobClient
assert id(bobReactor.hab.kvy.kevers) == id(bobHab.kevers)
assert bobReactor.hab.kvy.db == bobDB
assert id(bobReactor.parser.ims) == id(bobReactor.client.rxbs)
assert id(bobReactor.client.rxbs) == id(bobDirector.client.rxbs)
bobServer = serving.Server(host="", port=bobPort)
bobServerDoer = serving.ServerDoer(server=bobServer)
bobDirectant = directing.Directant(hab=bobHab, server=bobServer)
assert bobDirectant.hab == bobHab
assert bobDirectant.server == bobServer
# Bob's Reactants created on demand
# setup eve
eveHab = habbing.Habitat(ks=eveKS, db=eveDB, secrecies=eveSecrecies,
temp=True)
assert eveHab.ks == eveKS
assert eveHab.db == eveDB
assert eveHab.iserder.dig == eveSerder.dig
assert eveHab.pre == eve
eveClient = clienting.Client(tymth=doist.tymen(), host='127.0.0.1', port=bobPort)
eveClientDoer = clienting.ClientDoer(tymth=doist.tymen(), client=eveClient)
eveDirector = directing.Director(hab=eveHab, client=eveClient)
assert eveDirector.hab == eveHab
assert eveDirector.client == eveClient
assert id(eveDirector.hab.kvy.kevers) == id(eveHab.kevers)
assert eveDirector.hab.kvy.db == eveDB
eveReactor = directing.Reactor(hab=eveHab, client=eveClient)
assert eveReactor.hab == eveHab
assert eveReactor.client == eveClient
assert id(eveReactor.hab.kvy.kevers) == id(eveHab.kevers)
assert eveReactor.hab.kvy.db == eveDB
assert id(eveReactor.parser.ims) == id(eveReactor.client.rxbs)
assert id(eveReactor.client.rxbs) == id(eveDirector.client.rxbs)
eveServer = serving.Server(host="", port=evePort)
eveServerDoer = serving.ServerDoer(server=eveServer)
eveDirectant = directing.Directant(hab=eveHab, server=eveServer)
assert eveDirectant.hab == eveHab
assert eveDirectant.server == eveServer
# Eve's Reactants created on demand
bobMsgTx = b"Hi Eve I am Bob"
bobDirector.client.tx(bobMsgTx)
eveMsgTx = b"Hi Bob its me Eve"
eveDirector.client.tx(eveMsgTx)
doers = [bobClientDoer, bobDirector, bobReactor, bobServerDoer, bobDirectant,
eveClientDoer, eveDirector, eveReactor, eveServerDoer, eveDirectant]
doist.do(doers=doers)
assert doist.tyme == limit
assert bobClient.opened == False
assert bobServer.opened == False
assert eveClient.opened == False
assert eveServer.opened == False
assert not bobClient.txbs
ca, ix = list(eveServer.ixes.items())[0]
eveMsgRx = bytes(ix.rxbs) # ColdStart Error fluhes buffer
assert eveMsgRx == b''
# assert eveMsgRx == bobMsgTx
assert not eveClient.txbs
ca, ix = list(bobServer.ixes.items())[0]
bobMsgRx = bytes(ix.rxbs) # ColdStart Error fluhes buffer
assert bobMsgRx == b''
# assert bobMsgRx == eveMsgTx
assert not os.path.exists(eveDB.path)
assert not os.path.exists(bobDB.path)
help.ogler.resetLevel(level=help.ogler.level)
"""End Test"""
def test_mailboxing():
"""
Test Mailboxer Class
"""
mber = Mailboxer()
assert isinstance(mber, Mailboxer)
assert mber.name == "main"
assert mber.temp is False
assert isinstance(mber.env, lmdb.Environment)
assert mber.path.endswith("keri/mbx/main")
assert mber.env.path() == mber.path
assert os.path.exists(mber.path)
assert isinstance(mber.fels, lmdb._Database)
mber.close(clear=True)
assert not os.path.exists(mber.path)
assert not mber.opened
mber = Mailboxer(reopen=False)
assert isinstance(mber, Mailboxer)
assert mber.name == "main"
assert mber.temp is False
assert mber.opened is False
assert mber.path is None
assert mber.env is None
mber.reopen()
assert mber.opened
assert mber.path is not None
assert isinstance(mber.env, lmdb.Environment)
assert mber.path.endswith("keri/mbx/main")
assert mber.env.path() == mber.path
assert os.path.exists(mber.path)
mber.close(clear=True)
assert not os.path.exists(mber.path)
assert not mber.opened
assert isinstance(mber.exns, subing.SerderSuber)
with dbing.openLMDB(cls=Mailboxer) as mber:
assert isinstance(mber, Mailboxer)
msg = bytearray(
b'{"v":"KERI10JSON0000ac_","t":"exn","i":"E4D919wF4oiG7ck6mnBWTRD_Z-Io0wZKCxL0zjx5je9I",'
b'"dt":"2021-07-15T13:01:37.624492+00:00","r":"/credential/issue","q":{"a":"b",'
b'"b":123}}-HABE4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E'
b'-AABAAMKEkKlqSYcAbOHfNXQ_D0Rbj9bQD5FqhFqckAlDnOFozRKOIPrCWaszRzSUN20UBj80tO5ozN35KrQp9m7Z1AA'
)
dest = coring.Prefixer(
qb64="E4D919wF4oiG7ck6mnBWTRD_Z-Io0wZKCxL0zjx5je9I")
source = coring.Prefixer(
qb64="E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E")
siger = coring.Siger(
qb64=
"AAMKEkKlqSYcAbOHfNXQ_D0Rbj9bQD5FqhFqckAlDnOFozRKOIPrCWaszRzSUN20UBj80tO5ozN35KrQp9m7Z1AA"
)
d = dict(a="b", b=123)
exn = exchanging.exchange("/credential/issue",
payload=d,
recipient=dest.qb64,
date="2021-07-15T13:01:37.624492+00:00")
mber.storeEvent(serder=exn, source=source, dest=dest, sigers=[siger])
actual = mber.cloneEvtMsg(dig=exn.digb)
assert actual == msg
assert not os.path.exists(mber.path)
with dbing.openLMDB(cls=Mailboxer) as mber, \
basing.openDB(name="test") as db, \
keeping.openKS(name="test") as ks:
salt = coring.Salter(raw=b'0123456789abcdef').qb64
hab = habbing.Habitat(ks=ks, db=db, salt=salt, temp=True)
for idx in range(10):
d = dict(a="b", b=idx)
dest = coring.Prefixer(
qb64="E4D919wF4oiG7ck6mnBWTRD_Z-Io0wZKCxL0zjx5je9I")
source = coring.Prefixer(
qb64="E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E")
exn = exchanging.exchange("/credential/issue",
payload=d,
recipient=dest.qb64,
date="2021-07-15T13:01:37.624492+00:00")
sigers = hab.mgr.sign(ser=exn.raw, verfers=hab.kever.verfers)
mber.storeEvent(serder=exn,
source=source,
dest=dest,
sigers=sigers)
msgs = []
for msg in mber.clonePreIter(pre=dest.qb64b, fn=0):
msgs.append(msg)
assert (len(msgs)) == 10
for idx, msg in enumerate(msgs):
exn = coring.Serder(msg)
d = exn.ked["q"]
assert d["b"] == idx
msgs = []
for msg in mber.clonePreIter(pre=dest.qb64b, fn=10):
msgs.append(msg)
assert (len(msgs)) == 0
msgs = []
for msg in mber.clonePreIter(pre=dest.qb64b, fn=4):
msgs.append(msg)
assert (len(msgs)) == 6
def test_replay_all():
"""
Test conjoint replay all
Setup database with events from Deb, Cam, Bev, abd Art
Replay all the events in database.
"""
with basing.openDB(name="deb") as debDB, keeping.openKS(name="deb") as debKS, \
basing.openDB(name="cam") as camDB, keeping.openKS(name="cam") as camKS, \
basing.openDB(name="bev") as bevDB, keeping.openKS(name="bev") as bevKS, \
basing.openDB(name="art") as artDB, keeping.openKS(name="art") as artKS:
# setup Deb's habitat using default salt multisig already incepts
sith = ["1/2", "1/2", "1/2"] # weighted signing threshold
debHab = habbing.Habitat(ks=debKS,
db=debDB,
isith=sith,
icount=3,
temp=True)
assert debHab.ks == debKS
assert debHab.db == debDB
assert debHab.kever.prefixer.transferable
# setup Cam's habitat using default salt multisig already incepts
# Cam's receipts will be vrcs with 3 indexed sigantures attached
sith = '2' # hex str of threshold int
camHab = habbing.Habitat(ks=camKS,
db=camDB,
isith=sith,
icount=3,
temp=True)
assert camHab.ks == camKS
assert camHab.db == camDB
assert camHab.kever.prefixer.transferable
# setup Bev's habitat using default salt nonstransferable already incepts
# Bev's receipts will be rcts with a receipt couple attached
sith = '1' # hex str of threshold int
bevHab = habbing.Habitat(ks=bevKS,
db=bevDB,
isith=sith,
icount=1,
transferable=False,
temp=True)
assert bevHab.ks == bevKS
assert bevHab.db == bevDB
assert not bevHab.kever.prefixer.transferable
# setup Art's habitat using custom salt nonstransferable so not match Bev
# already incepts
# Art's receipts will be rcts with a receipt couple attached
salt = coring.Salter(raw=b'abcdef0123456789').qb64
sith = '1' # hex str of threshold int
artHab = habbing.Habitat(ks=artKS,
db=artDB,
isith=sith,
icount=1,
salt=salt,
transferable=False,
temp=True)
assert artHab.ks == artKS
assert artHab.db == artDB
assert not artHab.kever.prefixer.transferable
# Create series of event for Deb
debMsgs = bytearray()
debMsgs.extend(debHab.makeOwnInception())
debMsgs.extend(debHab.interact())
debMsgs.extend(debHab.rotate())
debMsgs.extend(debHab.interact())
debMsgs.extend(debHab.interact())
debMsgs.extend(debHab.interact())
debMsgs.extend(debHab.interact())
# Play debMsgs to Cam
# create non-local kevery for Cam to process msgs from Deb
camKevery = eventing.Kevery(db=camHab.db, lax=False, local=False)
parsing.Parser().parse(ims=bytearray(debMsgs), kvy=camKevery)
# camKevery.process(ims=bytearray(debMsgs)) # give copy to process
assert debHab.pre in camKevery.kevers
assert camKevery.kevers[debHab.pre].sn == debHab.kever.sn == 6
assert len(camKevery.cues) == 7
# get disjoints receipts (vrcs) from Cam of Deb's events by processing Cam's cues
camMsgs = camHab.processCues(camKevery.cues)
# Play camMsgs to Deb
# create non-local kevery for Deb to process msgs from Cam
debKevery = eventing.Kevery(db=debHab.db, lax=False, local=False)
parsing.Parser().parse(ims=bytearray(camMsgs), kvy=debKevery)
# debKevery.process(ims=bytearray(camMsgs)) # give copy to process
assert camHab.pre in debKevery.kevers
assert debKevery.kevers[camHab.pre].sn == camHab.kever.sn == 0
assert len(debKevery.cues) == 1
# get disjoints receipts (vrcs) from Deb of Cam's events by processing Deb's cues
debCamVrcs = debHab.processCues(debKevery.cues)
# Play disjoints debCamVrcs to Cam
parsing.Parser().parseOne(ims=bytearray(debCamVrcs), kvy=camKevery)
# camKevery.processOne(ims=bytearray(debCamVrcs)) # give copy to process
# Play debMsgs to Bev
# create non-local kevery for Bev to process msgs from Deb
bevKevery = eventing.Kevery(db=bevHab.db, lax=False, local=False)
parsing.Parser().parse(ims=bytearray(debMsgs), kvy=bevKevery)
# bevKevery.process(ims=bytearray(debMsgs)) # give copy to process
assert debHab.pre in bevKevery.kevers
assert bevKevery.kevers[debHab.pre].sn == debHab.kever.sn == 6
assert len(bevKevery.cues) == 7
# get disjoints receipts (rcts) from Bev of Deb's events by processing Bevs's cues
bevMsgs = bevHab.processCues(bevKevery.cues)
# Play bevMsgs to Deb
parsing.Parser().parse(ims=bytearray(bevMsgs), kvy=debKevery)
# debKevery.process(ims=bytearray(bevMsgs)) # give copy to process
assert bevHab.pre in debKevery.kevers
assert debKevery.kevers[bevHab.pre].sn == bevHab.kever.sn == 0
assert len(debKevery.cues) == 1
# get disjoints receipts (vrcs) from Deb of Bev's events by processing Deb's cues
debBevVrcs = debHab.processCues(debKevery.cues)
# Play disjoints debBevVrcs to Bev
parsing.Parser().parseOne(ims=bytearray(debBevVrcs), kvy=bevKevery)
# bevKevery.processOne(ims=bytearray(debBevVrcs)) # give copy to process
# now setup replay
debAllFelMsgs = debHab.replayAll()
assert len(debAllFelMsgs) == 11267
# create non-local kevery for Art to process conjoint replay msgs from Deb
artKevery = eventing.Kevery(db=artHab.db, lax=False, local=False)
# process Cam's inception so Art will proces Cam's vrcs without escrowing
camIcpMsg = camHab.makeOwnInception()
parsing.Parser().parse(ims=bytearray(camIcpMsg), kvy=artKevery)
assert camHab.pre in artKevery.kevers
assert len(artKevery.cues) == 1
# give copy to process in cloned mode
artKevery.cloned = True
parsing.Parser().parse(ims=bytearray(debAllFelMsgs), kvy=artKevery)
assert debHab.pre in artKevery.kevers
assert artKevery.kevers[debHab.pre].sn == debHab.kever.sn == 6
assert len(artKevery.cues) == 9
artAllFelMsgs = artHab.replayAll()
assert len(artAllFelMsgs) == 11016
assert not os.path.exists(artKS.path)
assert not os.path.exists(artDB.path)
assert not os.path.exists(bevKS.path)
assert not os.path.exists(bevDB.path)
assert not os.path.exists(camKS.path)
assert not os.path.exists(camDB.path)
assert not os.path.exists(debKS.path)
assert not os.path.exists(debDB.path)
"""End Test"""
def test_exchanger():
sidSalt = coring.Salter(raw=b'0123456789abcdef').qb64
redSalt = coring.Salter(raw=b'abcdef0123456789').qb64
with basing.openDB(name="sid") as sidDB, \
keeping.openKS(name="sid") as sidKS, \
basing.openDB(name="red") as redDB, \
keeping.openKS(name="red") as redKS:
limit = 1.0
tock = 0.03125
doist = doing.Doist(limit=limit, tock=tock)
# Init key pair managers
sidMgr = keeping.Manager(ks=sidKS, salt=sidSalt)
# Init Keverys
sidKvy = eventing.Kevery(db=sidDB)
redHab = habbing.Habitat(ks=redKS, db=redDB, temp=True)
redKvy = eventing.Kevery(db=redDB)
# Setup sid by creating inception event
verfers, digers, cst, nst = sidMgr.incept(
stem='sid', temp=True) # algo default salty and rooted
sidSrdr = eventing.incept(
keys=[verfer.qb64 for verfer in verfers],
nxt=coring.Nexter(digs=[diger.qb64 for diger in digers]).qb64,
code=coring.MtrDex.Blake3_256)
sidPre = sidSrdr.ked["i"]
sidMgr.move(old=verfers[0].qb64,
new=sidPre) # move key pair label to prefix
sigers = sidMgr.sign(ser=sidSrdr.raw, verfers=verfers)
excMsg = bytearray(sidSrdr.raw)
counter = coring.Counter(code=coring.CtrDex.ControllerIdxSigs,
count=len(sigers))
excMsg.extend(counter.qb64b)
for siger in sigers:
excMsg.extend(siger.qb64b)
sidIcpMsg = excMsg # save for later
parsing.Parser().parse(ims=bytearray(sidIcpMsg), kvy=redKvy)
assert redKvy.kevers[sidPre].sn == 0 # accepted event
echo = EchoDoer(tymth=doist.tymen())
redExc = exchanging.Exchanger(hab=redHab,
tymth=doist.tymen(),
handlers=[echo])
pl = dict(x="y")
sidExcSrdr = exchanging.exchange(route="/test/message", payload=pl)
# Create exn message, sign it and attack Signer Seal
sigers = sidMgr.sign(ser=sidExcSrdr.raw, verfers=verfers)
excMsg = bytearray(sidExcSrdr.raw)
excMsg.extend(
coring.Counter(coring.CtrDex.SignerSealCouples, count=1).qb64b)
excMsg.extend(sidPre.encode("utf-8"))
counter = coring.Counter(code=coring.CtrDex.ControllerIdxSigs,
count=len(sigers))
excMsg.extend(counter.qb64b)
for siger in sigers:
excMsg.extend(siger.qb64b)
parsing.Parser().parse(ims=bytearray(excMsg), kvy=redKvy, exc=redExc)
doist.do(doers=[redExc])
assert doist.tyme == limit
resp = echo.cues.popleft()
respSer = coring.Serder(raw=resp.raw)
assert respSer.ked['t'] == coring.Ilks.exn
assert respSer.ked['r'] == "/test/messageResp"
assert respSer.ked['q'] == dict(req=pl)
