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)