def test_openkeeper(): """ test contextmanager decorator for test Keeper databases """ with keeping.openKS() as keeper: assert isinstance(keeper, keeping.Keeper) assert keeper.name == "test" assert isinstance(keeper.env, lmdb.Environment) assert keeper.path.startswith("/tmp/keri_keep_") assert keeper.path.endswith("_test/keri/keep/test") assert keeper.env.path() == keeper.path assert os.path.exists(keeper.path) assert keeper.opened assert not os.path.exists(keeper.path) assert not keeper.opened with keeping.openKS(name="blue") as keeper: assert isinstance(keeper, keeping.Keeper) assert keeper.name == "blue" assert isinstance(keeper.env, lmdb.Environment) assert keeper.path.startswith("/tmp/keri_keep_") assert keeper.path.endswith("_test/keri/keep/blue") assert keeper.env.path() == keeper.path assert os.path.exists(keeper.path) assert keeper.opened assert not os.path.exists(keeper.path) assert not keeper.opened with keeping.openKS(name="red") as red, keeping.openKS(name="tan") as tan: assert isinstance(red, keeping.Keeper) assert red.name == "red" assert red.env.path() == red.path assert os.path.exists(red.path) assert red.opened assert isinstance(tan, keeping.Keeper) assert tan.name == "tan" assert tan.env.path() == tan.path assert os.path.exists(tan.path) assert tan.opened assert not os.path.exists(red.path) assert not red.opened assert not os.path.exists(tan.path) assert not tan.opened """ End Test """
def test_direct_mode_bob_eve_demo(): """ Test direct mode bob and eve """ help.ogler.resetLevel(level=logging.DEBUG) # 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 == 'EH7Oq9oxCgYa-nnNLvwhp9sFZpALILlRYyB-6n4WDi7w' # 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 == 'EpDA1n-WiBA0A8YOqnKrB-wWQYYC49i5zY_qrIZIicQg' with dbing.openDB(name="eve") as eveDB, keeping.openKS(name="eve") as eveKS, \ dbing.openDB(name="bob") as bobDB, keeping.openKS(name="bob") as bobKS: limit = 1.0 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 bobKevers = dict() eveKevers = dict() # setup bob bobHab = directing.Habitat(name='Bob', ks=bobKS, db=bobDB, kevers=bobKevers, 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 = doing.ClientDoer(client=bobClient) bobDirector = demoing.BobDirector(hab=bobHab, client=bobClient, tock=0.125) assert bobDirector.hab == bobHab assert bobDirector.client == bobClient assert bobDirector.hab.kvy.kevers == bobKevers assert bobDirector.hab.kvy.db == bobDB assert bobDirector.tock == 0.125 bobReactor = directing.Reactor(hab=bobHab, client=bobClient) assert bobReactor.hab == bobHab assert bobReactor.client == bobClient assert bobReactor.hab.kvy.kevers == bobKevers assert bobReactor.hab.kvy.db == bobDB assert bobReactor.hab.kvy.ims == bobReactor.client.rxbs bobServer = serving.Server(host="", port=bobPort) bobServerDoer = doing.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 = directing.Habitat(name='Eve', ks=eveKS, db=eveDB, kevers=eveKevers, 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 = doing.ClientDoer(client=eveClient) eveDirector = demoing.EveDirector(hab=eveHab, client=eveClient, tock=0.125) assert eveDirector.hab == eveHab assert eveDirector.client == eveClient assert eveDirector.hab.kvy.kevers == eveKevers assert eveDirector.hab.kvy.db == eveDB eveReactor = directing.Reactor(hab=eveHab, client=eveClient) assert eveReactor.hab == eveHab assert eveReactor.client == eveClient assert eveReactor.hab.kvy.kevers == eveKevers assert eveReactor.hab.kvy.db == eveDB assert eveReactor.hab.kvy.ims == eveReactor.client.rxbs eveServer = serving.Server(host="", port=evePort) eveServerDoer = doing.ServerDoer(server=eveServer) eveDirectant = directing.Directant(hab=eveHab, server=eveServer) assert eveDirectant.hab == eveHab assert eveDirectant.server == eveServer # Eve's Reactants created on demand 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 bobHab.pre in bobHab.kevers assert eveHab.pre in eveHab.kevers assert not bobClient.txbs assert bobHab.pre in eveHab.kevers # verify final event states 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_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 dbing.openDB(name="cam") as camDB, keeping.openKS(name="cam") as camKS, \ dbing.openDB(name="van") as vanDB, keeping.openKS(name="van") as vanKS, \ dbing.openDB(name="wes") as wesDB, keeping.openKS(name="wes") as wesKS, \ dbing.openDB(name="wok") as wokDB, keeping.openKS(name="wok") as wokKS, \ dbing.openDB(name="wam") as wamDB, keeping.openKS(name="wam") as wamKS, \ dbing.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 = directing.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(kevers=wesHab.kevers, db=wesHab.db, framed=True, opre=wesHab.pre, local=False) # setup Wok's habitat nontrans # Wok's receipts will be rcts with a receipt couple attached wokHab = directing.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(kevers=wokHab.kevers, db=wokHab.db, framed=True, opre=wokHab.pre, local=False) # setup Wam's habitat nontrans # Wams's receipts will be rcts with a receipt couple attached wamHab = directing.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(kevers=wamHab.kevers, db=wamHab.db, framed=True, opre=wamHab.pre, local=False) # setup Wil's habitat nontrans # Wil's receipts will be rcts with a receipt couple attached wilHab = directing.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(kevers=wilHab.kevers, db=wilHab.db, framed=True, opre=wilHab.pre, local=False) # setup Cam's habitat trans multisig wits = [wesHab.pre, wokHab.pre, wamHab.pre] csith = 2 # hex str of threshold int camHab = directing.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(kevers=camHab.kevers, db=camHab.db, framed=True, opre=camHab.pre, local=False) # setup Van's habitat trans multisig vsith = 2 # two of three signing threshold vanHab = directing.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(kevers=vanHab.kevers, db=vanHab.db, framed=True, opre=vanHab.pre, 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] 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) == 559 rctMsgs.append(rctMsg) for msg in rctMsgs: # process rct msgs from all witnesses 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] 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 vanKvy.process( ims=bytearray(camIcpMsg)) # should escrow since not witnesses assert camHab.pre not in vanKvy.kevers 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] 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 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] 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 vanKvy.process(ims=bytearray(camIxnWitRctMsg)) vanKvy.processEscrows() assert vcKvr.sn == 0 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) == 1824 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 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] 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 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] 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 vanKvy.process(ims=bytearray(camRotWitRctMsg)) vanKvy.processEscrows() assert vcKvr.sn == 1 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_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 dbing.openDB(name="deb") as debDB, keeping.openKS(name="deb") as debKS, \ dbing.openDB(name="cam") as camDB, keeping.openKS(name="cam") as camKS, \ dbing.openDB(name="bev") as bevDB, keeping.openKS(name="bev") as bevKS, \ dbing.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 = directing.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 = directing.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 = directing.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 = directing.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 # 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 == bytearray(b'{"v":"KERI10JSON000154_","i":"E4ReNhXtuh4DAKe4_qcX__uF70MnOvW5Wa' b'pj3LcQ8CT4","s":"0","t":"icp","kt":["1/2","1/2","1/2"],"k":["DaY' b'h8uaASuDjMUd8_BoNyQs3GwupzmJL8_RBsuNtZHQg","Duzj-Z2lR2DqB0cI0421' b'oSMUVWOrN5axojx8g9fSx3PM","DRXPAmNVVqafWvQiN5qQmWUDvVupF2w8xFNGg' b'1Gays9Y"],"n":"EO5f_IQjtBoeN_-OyzfVJx1_WqBFUL-Ely4x-xmUtOW8","wt' b'":"0","w":[],"c":[]}-AADAA6Z50BRlXby_uSdkqbybLXds-5OMwQil4miux1s' b'RxJkiD3kRS4HuCpv5m-wwsPHWwn_Ku5xB2P--NJ1pl7KXjAQABDjMdRtemkn9oyk' b'LFo9MBwZsS85hGd1yaMMdFb_P1FY8_PZcHBVTc2iF5Bd6T2rGorwS-ChRa24bxUr' b'kemWD1DAACpxUYq2zrFAlMdWuxdaYTqvh12pgk4Ba-vllsaZP5ct5HcOtJw47B6c' b'VLcEePwEHk6jHlSoDGgH2YiyOwPbgSBQ{"v":"KERI10JSON000098_","i":"E4' b'ReNhXtuh4DAKe4_qcX__uF70MnOvW5Wapj3LcQ8CT4","s":"1","t":"ixn","p' b'":"Egd_fi2QDtfjjdB5p9tT6QCHuBsSWUwQP6AbarcjLgw0","a":[]}-AADAAPL' b'MNHELcDDuPT1gyI9_TEBM6FRji2xmc0iBfNBwoKJttbJfeQhH41y-ayubtyhyMzH' b'aqrq-WXaNQkpnzTTOPBAABUawpt1Nd7GR9rTwPD4ucT-M7Vy1xuxGlgRf9pgkOcX' b'BBbhomjjEpz3aid9PP2vWeJ_rvw7W5rgrTJ38Q2v8bDwACoHNjlZ-IZ1K9opgeu3' b'3TNIFBd3rNW_gKO_bFa-t2GYwOzlWoDlzF7kSRQnVKlXMeVrLBe3uwO6PjYjeZdU' b'SlDg{"v":"KERI10JSON000190_","i":"E4ReNhXtuh4DAKe4_qcX__uF70MnOv' b'W5Wapj3LcQ8CT4","s":"2","t":"rot","p":"E8MU3qwR6gzbMUqEXh0CgG4k3' b'k4WKkk9hM0iaVeCmG7E","kt":["1/2","1/2","1/2"],"k":["DIsi8qYso1KM' b'mpLOGYty3NC2BAojZmUCfzR5_5oQRiso","DkdClpaWCAoCPBYgUmqP9gwAtsGq8' b'1yyPhGQKQ6-W_F0","DKDyq4QQYKnx9ircxeCvEcraI4HUSr_ytWPelDHAM98w"]' b',"n":"E1oOvJmwenmC4uHjX7qB40LGVbeZY5rYQeZ6IK5zmdmM","wt":"0","wr' b'":[],"wa":[],"a":[]}-AADAAr5HeTAGJ_WfIMO82lbEnpAMkuqZ0iJO0yYhjwv' b'LElPYltF_jSOApKPWxepare2O7XMMOvtgxjXj9pvvqpW8WDgABKHoueBd4JgakpV' b'ydJYADwh5wMSNyHNMKXwhYMGrgApl_EvsTmEt8uS94PmrfCtRjLRbZdzLRZVkX7Y' b'x4jlNNCgACjKJlODGhL_a0S3-oDRJhOUG0sul4SCJd21Qp-KSFSfGavACAwQdEYQ' b'L43jko9lFDuhwKDt1BD8kAoy3T-tdoAw{"v":"KERI10JSON000098_","i":"E4' b'ReNhXtuh4DAKe4_qcX__uF70MnOvW5Wapj3LcQ8CT4","s":"3","t":"ixn","p' b'":"EO2hh7xg29y3i7uywQ_n0g7vk0W1oGiErUY9QpGjSUhc","a":[]}-AADAA5I' b'ox67c4HL78UrYqpSNH-UkHZRpR7X0fPQ0GEYJG8OGqCHBvPJica_yohOQP8GNOFQ' b'9UsmBa0TDji6EAaXivBwAB6BgG2CQ-Ukw8CchtCHf9L5kVsmg1Tu2OuLkcy9Sb9u' b'Vm23yLx-8I4pc6KHmZke8KCvpXjcdV65gOOE-VUIMOBwACXtTZoFqJHFhoMZABun' b'XETksrK1nNiP9xzXx13gl4uqoVZkqfwqUTL3C7q0RcxYwaz5sYSNQA8zblA8YxVy' b'FuCQ{"v":"KERI10JSON000098_","i":"E4ReNhXtuh4DAKe4_qcX__uF70MnOv' b'W5Wapj3LcQ8CT4","s":"4","t":"ixn","p":"EQI0EXdK6WvQae17PBWDUkMOd' b'OiTPpx48oMSYTUYsCl0","a":[]}-AADAAbnPY1i0cpo6q0cmvQr2bZOcipzl7LY' b'Y2h-3ixndlzB3f-4VFLzSnIUtB_qwp1H2NI_DNGqXWGACywJoxkFccAQABHDicUl' b'iz3Bl6y1T7-sQteMKxoDYZ4A8hVx3p3EjztyO8UnA6PkaV2b7AFwAfk4UbBWKMGj' b'TtpZ88S7P9EsXLBAACNFFh6nDIWNG1ZbEsqqlCG2aKLgnpHmR6cJr1dq1F4pylAF' b'1e3-on2aasDMYk3c2fj-AWErRqbsf8ejnJE3YvDg{"v":"KERI10JSON000098_"' b',"i":"E4ReNhXtuh4DAKe4_qcX__uF70MnOvW5Wapj3LcQ8CT4","s":"5","t":' b'"ixn","p":"EvrAC5XVQyu01ZuKfq1wiR0kXF2j8TjrCg4QyA0LVjKk","a":[]}' b'-AADAA1OJn3UHjLcI333fduqTj6nAJY27VtkQqW_lHalnJKtgmb0tk1tV5xUCVzp' b'al14xWDuyCdImhFzTk0sRgW4MYDQABOR8ay9qQYR3ieant4ujM_FX0Nm_mUHcVVo' b'4pCqDy8jLaM3EBNmkOKUIfxgZC-8k6OpYcy33gC-qgUpc6C2_PDwACSoZSibaYci' b'n32vY4ANzflFpJh_EF7mcGbTWSFrNLnwFrrOfhXL3i1Pf39Sk079ApSI87Nt-CvH' b'pRRdows3TABQ{"v":"KERI10JSON000098_","i":"E4ReNhXtuh4DAKe4_qcX__' b'uF70MnOvW5Wapj3LcQ8CT4","s":"6","t":"ixn","p":"EwmQtlcszNoEIDfqD' b'-Zih3N6o5B3humRKvBBln2juTEM","a":[]}-AADAAvYMCRmJgjFM7EG7rWng7Q3' b'WRfwcd908UdKL-7ZfGw4igpF9DcA-yxwliba59D4pkmhIcrW_Ax76iuaD6yD03Bw' b'AB9Wp-awBUfw2jnDRjvEU3xpFlLDHwiFLRKpom8Wnx7qDD4aEv6ERZh-H8yP3eL4' b'sNEFjP5HcRrb5MpFwOp0VyAwACdedbq9E2Exs1NobGwSNQpNxKlgDPiNDE8nOeOq' b'gXt1rAj8SAh8gX2pOgEFj3g3UB69dNGw2M-bEZ557-p9G-Aw') # Play debMsgs to Cam # create non-local kevery for Cam to process msgs from Deb camKevery = eventing.Kevery(kevers=camHab.kevers, db=camHab.db, framed=True, opre=camHab.pre, local=False) 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 == bytearray(b'{"v":"KERI10JSON000144_","i":"E_T2_p83_gRSuAYvGhqV3S0JzYEF2dIa-O' b'CPLbIhBO7Y","s":"0","t":"icp","kt":"2","k":["DaYh8uaASuDjMUd8_Bo' b'NyQs3GwupzmJL8_RBsuNtZHQg","Duzj-Z2lR2DqB0cI0421oSMUVWOrN5axojx8' b'g9fSx3PM","DRXPAmNVVqafWvQiN5qQmWUDvVupF2w8xFNGg1Gays9Y"],"n":"E' b'OySO3Oa400n3Ss9JftGYmgS5M4jgPInNnMntC_l-PEQ","wt":"0","w":[],"c"' b':[]}-AADAA5267UlFg1jHee4Dauht77SzGl8WUC_0oimYG5If3SdIOSzWM8Qs9SF' b'ajAilQcozXJVnbkY5stG_K4NbKdNB4AQABBgeqntZW3Gu4HL0h3odYz6LaZ_SMfm' b'ITL-Btoq_7OZFe3L16jmOe49Ur108wH7mnBaq2E_0U0N0c5vgrJtDpAQACTD7NDX' b'93ZGTkZBBuSeSGsAQ7u0hngpNTZTK_Um7rUZGnLRNJvo5oOnnC1J2iBQHuxoq8Py' b'jdT3BHS2LiPrs2Cg{"v":"KERI10JSON000105_","i":"E4ReNhXtuh4DAKe4_q' b'cX__uF70MnOvW5Wapj3LcQ8CT4","s":"0","t":"vrc","d":"Egd_fi2QDtfjj' b'dB5p9tT6QCHuBsSWUwQP6AbarcjLgw0","a":{"i":"E_T2_p83_gRSuAYvGhqV3' b'S0JzYEF2dIa-OCPLbIhBO7Y","s":"0","d":"EFSbLZkTmOMfRCyEYLgz53ARZo' b'ugmEu_edeW-0j2DVRY"}}-AADAA6Z50BRlXby_uSdkqbybLXds-5OMwQil4miux1' b'sRxJkiD3kRS4HuCpv5m-wwsPHWwn_Ku5xB2P--NJ1pl7KXjAQABDjMdRtemkn9oy' b'kLFo9MBwZsS85hGd1yaMMdFb_P1FY8_PZcHBVTc2iF5Bd6T2rGorwS-ChRa24bxU' b'rkemWD1DAACpxUYq2zrFAlMdWuxdaYTqvh12pgk4Ba-vllsaZP5ct5HcOtJw47B6' b'cVLcEePwEHk6jHlSoDGgH2YiyOwPbgSBQ{"v":"KERI10JSON000105_","i":"E' b'4ReNhXtuh4DAKe4_qcX__uF70MnOvW5Wapj3LcQ8CT4","s":"1","t":"vrc","' b'd":"E8MU3qwR6gzbMUqEXh0CgG4k3k4WKkk9hM0iaVeCmG7E","a":{"i":"E_T2' b'_p83_gRSuAYvGhqV3S0JzYEF2dIa-OCPLbIhBO7Y","s":"0","d":"EFSbLZkTm' b'OMfRCyEYLgz53ARZougmEu_edeW-0j2DVRY"}}-AADAAPLMNHELcDDuPT1gyI9_T' b'EBM6FRji2xmc0iBfNBwoKJttbJfeQhH41y-ayubtyhyMzHaqrq-WXaNQkpnzTTOP' b'BAABUawpt1Nd7GR9rTwPD4ucT-M7Vy1xuxGlgRf9pgkOcXBBbhomjjEpz3aid9PP' b'2vWeJ_rvw7W5rgrTJ38Q2v8bDwACoHNjlZ-IZ1K9opgeu33TNIFBd3rNW_gKO_bF' b'a-t2GYwOzlWoDlzF7kSRQnVKlXMeVrLBe3uwO6PjYjeZdUSlDg{"v":"KERI10JS' b'ON000105_","i":"E4ReNhXtuh4DAKe4_qcX__uF70MnOvW5Wapj3LcQ8CT4","s' b'":"2","t":"vrc","d":"EO2hh7xg29y3i7uywQ_n0g7vk0W1oGiErUY9QpGjSUh' b'c","a":{"i":"E_T2_p83_gRSuAYvGhqV3S0JzYEF2dIa-OCPLbIhBO7Y","s":"' b'0","d":"EFSbLZkTmOMfRCyEYLgz53ARZougmEu_edeW-0j2DVRY"}}-AADAA7JJ' b'AxJL3nhVur7YboCK2zPSmx_AaYDYeN7UsvoKcZKrYbuScUje_qfx_e9z1SM4tm8b' b'UbYJnLXTz8dOta9ZiDwABi7dsjnldn7E-L56Rlz4ZWp8XC5y8v7h4XRoZp2sO69H' b'84dhyRM27UE9_egCWQZJ_MHJKVA5g2s0hXmXvjSKrAQACo0JcZmUhiNBfb_3bBwg' b'X7KfN52vmazAzEFgJlr8wNfXSvF6rA5lED4J1EWuEnhA00vUHQqPrjk78nnRBBZl' b'VAA{"v":"KERI10JSON000105_","i":"E4ReNhXtuh4DAKe4_qcX__uF70MnOvW' b'5Wapj3LcQ8CT4","s":"3","t":"vrc","d":"EQI0EXdK6WvQae17PBWDUkMOdO' b'iTPpx48oMSYTUYsCl0","a":{"i":"E_T2_p83_gRSuAYvGhqV3S0JzYEF2dIa-O' b'CPLbIhBO7Y","s":"0","d":"EFSbLZkTmOMfRCyEYLgz53ARZougmEu_edeW-0j' b'2DVRY"}}-AADAAG1L04T2jREp2pizW-jQ0tglZ8I4CDNoKx4bN2K0ztuf_0ywQ29' b'p2kFkBVZaRPwljOZlUzJqlPU6P2R-IVORJBQAB2ss-isfVr2WpdCWwNxO_9N75eJ' b'K-2CZp1J-DicWd8FqziZIc-kAmxNBD9TjxfuYn7pQmXnaWF7g4RhCLJGBuDAACrx' b'gx3QlrBs-g369i807ntd8rGWGC4WGrrdy60cPy9hjrP10qjDtSTwa2UZPNVEUZol' b'M-lHsFqoNhjeaHmg_mDA{"v":"KERI10JSON000105_","i":"E4ReNhXtuh4DAK' b'e4_qcX__uF70MnOvW5Wapj3LcQ8CT4","s":"4","t":"vrc","d":"EvrAC5XVQ' b'yu01ZuKfq1wiR0kXF2j8TjrCg4QyA0LVjKk","a":{"i":"E_T2_p83_gRSuAYvG' b'hqV3S0JzYEF2dIa-OCPLbIhBO7Y","s":"0","d":"EFSbLZkTmOMfRCyEYLgz53' b'ARZougmEu_edeW-0j2DVRY"}}-AADAAh0E0mltmkUz1_TXMirWFa67IGAaK7fThh' b'rJ8TQyuhY7usunzf8VtWfaaLBQSpofhgppsMlf3zZxDS1g6t-7PCgABECiScuPby' b'_LbGw5s6qNTJQm2m6Dqbsig7sRdk841XWU6hV3MlD-k_SriiPEJWMAWDmY74lM-U' b'iNDvnmN4OAJCAACSc48sfSvNtYByMlUQsMPdEsDw5Z6oDX4jlZ9F5eCMcRvYWWAp' b'AD-OOi85JTIiW3y3nSdbfyt4vS6YvroA68MAQ{"v":"KERI10JSON000105_","i' b'":"E4ReNhXtuh4DAKe4_qcX__uF70MnOvW5Wapj3LcQ8CT4","s":"5","t":"vr' b'c","d":"EwmQtlcszNoEIDfqD-Zih3N6o5B3humRKvBBln2juTEM","a":{"i":"' b'E_T2_p83_gRSuAYvGhqV3S0JzYEF2dIa-OCPLbIhBO7Y","s":"0","d":"EFSbL' b'ZkTmOMfRCyEYLgz53ARZougmEu_edeW-0j2DVRY"}}-AADAAgXtG2I3AxvU5yHKz' b'fucOKOvxeKWwChKQvEQJtJnz9iIpsXqyyrgRfOyoyjhk73D-E3FbDg_3k1XK_3i-' b'yDWeAQAByUVjq4Y_sMWi9iqqWXTo2ES5pBMlBgJbAY3h61aJElQdCIxr2ldx_BSq' b'4vA-FlELEBUkSbeHnHGXeFfVi6AjCwAC6GmjxPFclVsY7smEcpmptQnZgET9LUO6' b'06SzhkCaGCe1jR2KZ3vNsgitA_7OQ_VDipLwoWGv_Kz2YnUkjKFsCw{"v":"KERI' b'10JSON000105_","i":"E4ReNhXtuh4DAKe4_qcX__uF70MnOvW5Wapj3LcQ8CT4' b'","s":"6","t":"vrc","d":"EvFMG33kYq7JGOY1fWl1_VqfAe0MfPO3IhasTID' b'kayaY","a":{"i":"E_T2_p83_gRSuAYvGhqV3S0JzYEF2dIa-OCPLbIhBO7Y","' b's":"0","d":"EFSbLZkTmOMfRCyEYLgz53ARZougmEu_edeW-0j2DVRY"}}-AADA' b'A9U_Kq0GNM1fFq1Vgp937kHkwxSBn4nT8UciTepjjOdOAR-hvsLCxQx2V2pbyQo3' b'fubs6mPd6TQ4ZUmXNrtxmBwABuFO678xi0JuYyQWnSOtOVXABknvRo6-0EWFCv7h' b'xucmqgE6Je2R4120G3nFsJ_ImTjkDibQU8m7CYBGcFh-hAQACBUqcpzMYX373ePK' b'sfKBjt9aXO2vkl9jAb5vBHFYc0h5r-pGL2TIgoyfMPMAf0zFrsKnDdmN0HmSaE1O' b'sP2hmDA') # Play camMsgs to Deb # create non-local kevery for Deb to process msgs from Cam debKevery = eventing.Kevery(kevers=debHab.kevers, db=debHab.db, framed=True, opre=debHab.pre, local=False) 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 == bytearray(b'{"v":"KERI10JSON000105_","i":"E_T2_p83_gRSuAYvGhqV3S0JzYEF2dIa-O' b'CPLbIhBO7Y","s":"0","t":"vrc","d":"EFSbLZkTmOMfRCyEYLgz53ARZougm' b'Eu_edeW-0j2DVRY","a":{"i":"E4ReNhXtuh4DAKe4_qcX__uF70MnOvW5Wapj3' b'LcQ8CT4","s":"2","d":"EO2hh7xg29y3i7uywQ_n0g7vk0W1oGiErUY9QpGjSU' b'hc"}}-AADAAmZij1Eyp2LOvVf0EevWsIIUiE9OEbhV5MvWvGHWzlvmzoaJ71KxSL' b'dMkqWG6yPyBLJjVNds_SQVVFnbpoPKwAAABNLo-_rnW2tfAu9GaP6XS2lyHTLUkG' b'TGKwjBA6hepC-E8XEiFMQekheKx-ir6xWxRPF9vBZuWwZKIqtwR2EwcDwACeHbCs' b'HbSgD7m9bWGB2ZCN8jxAfrbCMRGWersAEXqtdtkYT0Xxg33W61o5IffZjWxsHY_i' b'JQOPDVF3tA4DniWBg') # Play disjoints debCamVrcs to Cam 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(kevers=bevHab.kevers, db=bevHab.db, framed=True, opre=bevHab.pre, local=False) 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 == bytearray(b'{"v":"KERI10JSON0000ba_","i":"BaYh8uaASuDjMUd8_BoNyQs3GwupzmJL8_' b'RBsuNtZHQg","s":"0","t":"icp","kt":"1","k":["BaYh8uaASuDjMUd8_Bo' b'NyQs3GwupzmJL8_RBsuNtZHQg"],"n":"","wt":"0","w":[],"c":[]}-AABAA' b'dRmfIn6JHxhpyooEf22kqZxsa4OTpl9DVL6GDWNWlyk-MGQeo2pU5mI288Jl8SwP' b'PbTGbdeKdWUfG15bjil8AA{"v":"KERI10JSON000091_","i":"E4ReNhXtuh4D' b'AKe4_qcX__uF70MnOvW5Wapj3LcQ8CT4","s":"0","t":"rct","d":"Egd_fi2' b'QDtfjjdB5p9tT6QCHuBsSWUwQP6AbarcjLgw0"}-CABBaYh8uaASuDjMUd8_BoNy' b'Qs3GwupzmJL8_RBsuNtZHQg0B6Z50BRlXby_uSdkqbybLXds-5OMwQil4miux1sR' b'xJkiD3kRS4HuCpv5m-wwsPHWwn_Ku5xB2P--NJ1pl7KXjAQ{"v":"KERI10JSON0' b'00091_","i":"E4ReNhXtuh4DAKe4_qcX__uF70MnOvW5Wapj3LcQ8CT4","s":"' b'1","t":"rct","d":"E8MU3qwR6gzbMUqEXh0CgG4k3k4WKkk9hM0iaVeCmG7E"}' b'-CABBaYh8uaASuDjMUd8_BoNyQs3GwupzmJL8_RBsuNtZHQg0BPLMNHELcDDuPT1' b'gyI9_TEBM6FRji2xmc0iBfNBwoKJttbJfeQhH41y-ayubtyhyMzHaqrq-WXaNQkp' b'nzTTOPBA{"v":"KERI10JSON000091_","i":"E4ReNhXtuh4DAKe4_qcX__uF70' b'MnOvW5Wapj3LcQ8CT4","s":"2","t":"rct","d":"EO2hh7xg29y3i7uywQ_n0' b'g7vk0W1oGiErUY9QpGjSUhc"}-CABBaYh8uaASuDjMUd8_BoNyQs3GwupzmJL8_R' b'BsuNtZHQg0B7JJAxJL3nhVur7YboCK2zPSmx_AaYDYeN7UsvoKcZKrYbuScUje_q' b'fx_e9z1SM4tm8bUbYJnLXTz8dOta9ZiDw{"v":"KERI10JSON000091_","i":"E' b'4ReNhXtuh4DAKe4_qcX__uF70MnOvW5Wapj3LcQ8CT4","s":"3","t":"rct","' b'd":"EQI0EXdK6WvQae17PBWDUkMOdOiTPpx48oMSYTUYsCl0"}-CABBaYh8uaASu' b'DjMUd8_BoNyQs3GwupzmJL8_RBsuNtZHQg0BG1L04T2jREp2pizW-jQ0tglZ8I4C' b'DNoKx4bN2K0ztuf_0ywQ29p2kFkBVZaRPwljOZlUzJqlPU6P2R-IVORJBQ{"v":"' b'KERI10JSON000091_","i":"E4ReNhXtuh4DAKe4_qcX__uF70MnOvW5Wapj3LcQ' b'8CT4","s":"4","t":"rct","d":"EvrAC5XVQyu01ZuKfq1wiR0kXF2j8TjrCg4' b'QyA0LVjKk"}-CABBaYh8uaASuDjMUd8_BoNyQs3GwupzmJL8_RBsuNtZHQg0Bh0E' b'0mltmkUz1_TXMirWFa67IGAaK7fThhrJ8TQyuhY7usunzf8VtWfaaLBQSpofhgpp' b'sMlf3zZxDS1g6t-7PCg{"v":"KERI10JSON000091_","i":"E4ReNhXtuh4DAKe' b'4_qcX__uF70MnOvW5Wapj3LcQ8CT4","s":"5","t":"rct","d":"EwmQtlcszN' b'oEIDfqD-Zih3N6o5B3humRKvBBln2juTEM"}-CABBaYh8uaASuDjMUd8_BoNyQs3' b'GwupzmJL8_RBsuNtZHQg0BgXtG2I3AxvU5yHKzfucOKOvxeKWwChKQvEQJtJnz9i' b'IpsXqyyrgRfOyoyjhk73D-E3FbDg_3k1XK_3i-yDWeAQ{"v":"KERI10JSON0000' b'91_","i":"E4ReNhXtuh4DAKe4_qcX__uF70MnOvW5Wapj3LcQ8CT4","s":"6",' b'"t":"rct","d":"EvFMG33kYq7JGOY1fWl1_VqfAe0MfPO3IhasTIDkayaY"}-CA' b'BBaYh8uaASuDjMUd8_BoNyQs3GwupzmJL8_RBsuNtZHQg0B9U_Kq0GNM1fFq1Vgp' b'937kHkwxSBn4nT8UciTepjjOdOAR-hvsLCxQx2V2pbyQo3fubs6mPd6TQ4ZUmXNr' b'txmBw') # Play bevMsgs to Deb 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 == bytearray(b'{"v":"KERI10JSON000105_","i":"BaYh8uaASuDjMUd8_BoNyQs3GwupzmJL8_' b'RBsuNtZHQg","s":"0","t":"vrc","d":"EtTEz3ofbRmq4qeoKSc5uYWUhxeZa' b'8OjmCkZnesb0gws","a":{"i":"E4ReNhXtuh4DAKe4_qcX__uF70MnOvW5Wapj3' b'LcQ8CT4","s":"2","d":"EO2hh7xg29y3i7uywQ_n0g7vk0W1oGiErUY9QpGjSU' b'hc"}}-AADAAk0o2XsjZ8tfbaCKZZcSvmYdUxmqWMVMH1PLD6081VC04_c_nIXHfy' b'G5gRVXDsoncZk7euiZ9Q60E7rGi-FOLBQAB6xngS-To8PAVjMSz0bv4oqju1vmke' b'Hwq7EQOWMvM5WeKzLOwpgnCxCyZkYCzXU6Yyym9_TJOxL144wRVS92sAQACSG9_s' b'dTl_1t_bFi-fnkBwX7QLvB53NDNQShHwUjdvxupDMUJkx6QLwsUH_SwybCFO0rX5' b'K5TQKbTKbQ9F9TcAg') # Play disjoints debBevVrcs to Bev 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.cloneIter(pre=debHab.pre, fn=fn) # create iterator msg = next(cloner) # get zeroth event with attachments assert len(msg) == 1416 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.cloneIter(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) == 9032 cloner.close() # must close or get lmdb error upon with exit msgs = debHab.replay() assert msgs == debFelMsgs # Play Cam's messages to Bev 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 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) == 9032 # create non-local kevery for Art to process conjoint replay msgs from Deb artKevery = eventing.Kevery(kevers=artHab.kevers, db=artHab.db, framed=True, opre=artHab.pre, local=False) # process Cam's inception so Art will proces Cam's vrcs without escrowing camIcpMsg = camHab.makeOwnInception() artKevery.process(ims=bytearray(camIcpMsg)) assert camHab.pre in artKevery.kevers assert len(artKevery.cues) == 1 artKevery.process(ims=bytearray(debFelMsgs), cloned=True) # give copy to process 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) == 9032 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_weighted(): """ Test multisig with weighted threshold """ wesSalt = coring.Salter(raw=b'0123456789abcdef').qb64 # init wes Salter # init event DB and keep DB with dbing.openDB(name="wes") as wesDB, keeping.openKS( name="wes") as wesKS: # Init key pair manager wesMgr = keeping.Manager(keeper=wesKS, salt=wesSalt) # Init Kevery with event DB wesKvy = eventing.Kevery(db=wesDB) # create inception event for Wes with 3 keys each in incept and next sets # defaults are algo salty and rooted sith = ["1/2", "1/2", "1/2"] # 2 of 3 but with weighted threshold nxtsith = ["1/2", "1/2", "1/2"] verfers, digers, cst, nst = wesMgr.incept(icount=3, isith=sith, ncount=3, nsith=nxtsith, stem='wes', temp=True) assert cst == nst == sith wesSrdr = eventing.incept( keys=[verfer.qb64 for verfer in verfers], sith=sith, nxt=coring.Nexter(sith=nxtsith, digs=[diger.qb64 for diger in digers]).qb64, code=coring.MtrDex.Blake3_256) wesPre = wesSrdr.ked["i"] wesMgr.move(old=verfers[0].qb64, new=wesPre) # move key pair label to prefix sigers = wesMgr.sign(ser=wesSrdr.raw, verfers=verfers) msg = bytearray(wesSrdr.raw) counter = coring.Counter(coring.CtrDex.ControllerIdxSigs, count=len(sigers)) msg.extend(counter.qb64b) for siger in sigers: msg.extend(siger.qb64b) assert msg == bytearray( b'{"v":"KERI10JSON000154_","i":"EM8ac0UPJZCaWOw2uRcvx6FaygyxFvGzA5' b'MTob9WfbDQ","s":"0","t":"icp","kt":["1/2","1/2","1/2"],"k":["DK4' b'OJI8JOr6oEEUMeSF_X-SbKysfwpKwW-ho5KARvH5c","D1RZLgYke0GmfZm-CH8A' b'sW4HoTU4m-2mFgu8kbwp8jQU","DBVwzum-jPfuUXUcHEWdplB4YcoL3BWGXK0TM' b'oF_NeFU"],"n":"EhJGhyJQTpSlZ9oWfQT-lHNl1woMazLC42O89fRHocTI","wt' b'":"0","w":[],"c":[]}-AADAAc4jIKyjjpK7rJzywkX2AXXaNGgUGfcUgT6fm7P' b'iqL8H8tDsxHb6dcnybE7Hc34jtUq47OWWwCV3K9oCTUUAHAwABlP9qpCcMow8Lq5' b'bzE-DLHlItNuQYD9SqOQDNyJoTpk_BEW6Q8UIG012MJEM7GoFTMV5H9UUztQfSQp' b'l9Jh9lBQACVn_l3CTPIrCyGZpvW9qxVfZll0su-vIv1gvx0GQfo1qAMNk4c_7t-x' b'bXKTw3hwDPt46m5zGd38Y3qIEwQD3jCA') # apply msg to Wes's Kevery wesKvy.process(ims=bytearray(msg)) # process local copy of msg wesK = wesKvy.kevers[wesPre] # kever created so event was validated assert wesK.prefixer.qb64 == wesPre assert wesK.serder.diger.qb64 == wesSrdr.dig # key state updated so event was validated # create interaction event for Wes wesSrdr = eventing.interact(pre=wesK.prefixer.qb64, dig=wesK.serder.diger.qb64, sn=wesK.sn + 1, data=[]) sigers = wesMgr.sign(ser=wesSrdr.raw, verfers=wesK.verfers) msg = bytearray(wesSrdr.raw) counter = coring.Counter(coring.CtrDex.ControllerIdxSigs, count=len(sigers)) msg.extend(counter.qb64b) for siger in sigers: msg.extend(siger.qb64b) assert msg == bytearray( b'{"v":"KERI10JSON000098_","i":"EM8ac0UPJZCaWOw2uRcvx6FaygyxFvGzA5' b'MTob9WfbDQ","s":"1","t":"ixn","p":"E3-lhMd85oc8Uwrd_7c6xUy5tvZhr' b'b9ZHvcOO4HxHB1c","a":[]}-AADAAWmzu83wDFTn9Hc6_xskGe8Ed_PhiOpVQ2H' b'kxAx28qgLP_Zz7pwCsvmRDM1x9sL8Ygg7hQman5qDaeJS4fJm1DQABlc4hfziecy' b'_DXVN2a8AttmuBL_Oh0-Ro_Rz3Mf6KWOJTMLQIHaRJ62L01Q5vP6KmiSr2zwJUT_' b'urfGLZoaRUBwACt4l7pTFqmzfzk6p6FKlT1KGXYJ2ea2SmU7I-7agz0i4lCDNQf-' b'Y_NJWs6NTWEs5vsPOskNcGnr8nIpQ51N1qBQ') # apply msg to wes's Kevery wesKvy.process(ims=bytearray(msg)) # process local copy of msg assert wesK.serder.diger.qb64 == wesSrdr.dig # key state updated so event was validated # Create rotation event for Wes # get current keys as verfers and next digests as digers nxtsith = ["1/2", "1/2", "1/2"] # 2 of 3 but with weighted threshold verfers, digers, cst, nst = wesMgr.rotate(pre=wesPre, count=3, sith=nxtsith, temp=True) assert nst == nxtsith wesSrdr = eventing.rotate( pre=wesK.prefixer.qb64, keys=[verfer.qb64 for verfer in verfers], sith=sith, dig=wesK.serder.diger.qb64, nxt=coring.Nexter(sith=nxtsith, digs=[diger.qb64 for diger in digers]).qb64, sn=wesK.sn + 1, data=[]) sigers = wesMgr.sign(ser=wesSrdr.raw, verfers=verfers) msg = bytearray(wesSrdr.raw) counter = coring.Counter(coring.CtrDex.ControllerIdxSigs, count=len(sigers)) msg.extend(counter.qb64b) for siger in sigers: msg.extend(siger.qb64b) assert msg == bytearray( b'{"v":"KERI10JSON000190_","i":"EM8ac0UPJZCaWOw2uRcvx6FaygyxFvGzA5' b'MTob9WfbDQ","s":"2","t":"rot","p":"E6wjlP_oqJzmo65d56XuTL602ABcK' b'X0ZBEy9M-k7E1Eg","kt":["1/2","1/2","1/2"],"k":["DeonYM2bKnAwp6VZ' b'cuCXdX72kNFw56czlZ_Tc7XHHVGI","DQghKIy-2do9OkweSgazh3Ql1vCOt5bnc' b'5QF8x50tRoU","DNAUn-5dxm6b8Njo01O0jlStMRCjo9FYQA2mfqFW1_JA"],"n"' b':"EX5fxvjOg5VuDboWbqnTjTPpXa3nNIm99hlsB1EmhTo8","wt":"0","wr":[]' b',"wa":[],"a":[]}-AADAApZ3U4zacSPm5embDTRD2IxB1e4FrdAToP-tsXB-VVp' b'fX6Yk78iIdFyeNi9U_sgefzvhR3_mH5Bj_ZlfpEMCQDAABWURvCkE1HjbE_noEqj' b'BWEpdG1hUfP3_Oye5Ys0zquigDrOSv2ApXzlq1-ALDTZeqMX4lbVlqubRjDu3Qog' b'xrAgACtyNpfXHvly2emXyAdJ5sAVUVCnodONK2CG8WGipISYLGIlyfmNoTVeHw-f' b'_3ZY2tAgbmLZika4kEL8REfr5VCA') # apply msg to Wes's Kevery wesKvy.process(ims=bytearray(msg)) # process local copy of msg assert wesK.serder.diger.qb64 == wesSrdr.dig # key state updated so event was validated # Create rotation event for Wes # get current keys as verfers and next digests as digers sith = nxtsith # rotate so nxtsith is now current sith and need new nextsith # 2 of first 3 and 1 of last 2 nxtsith = [["1/2", "1/2", "1/2"], ["1/1", "1/1"]] verfers, digers, cst, nst = wesMgr.rotate(pre=wesPre, count=5, sith=nxtsith, temp=True) assert cst == sith assert nst == nxtsith wesSrdr = eventing.rotate( pre=wesK.prefixer.qb64, keys=[verfer.qb64 for verfer in verfers], sith=sith, dig=wesK.serder.diger.qb64, nxt=coring.Nexter(sith=nxtsith, digs=[diger.qb64 for diger in digers]).qb64, sn=wesK.sn + 1, data=[]) sigers = wesMgr.sign(ser=wesSrdr.raw, verfers=verfers) msg = bytearray(wesSrdr.raw) counter = coring.Counter(coring.CtrDex.ControllerIdxSigs, count=len(sigers)) msg.extend(counter.qb64b) for siger in sigers: msg.extend(siger.qb64b) assert msg == bytearray( b'{"v":"KERI10JSON000190_","i":"EM8ac0UPJZCaWOw2uRcvx6FaygyxFvGzA5' b'MTob9WfbDQ","s":"3","t":"rot","p":"E9tuWqXCN31LqElTSdfGp3lWDetle' b'T4Pa9tuSUi2V87k","kt":["1/2","1/2","1/2"],"k":["D7WWKDLVwYxYMLAj' b'DceIEs66xPMY4Afzx-RQw2x0mQzI","Dmg6Aah8qyKKDiQyNXTiO71QJwizjZfGM' b'61BA-s0A5F4","DS3fhKpvPCDL5WmfN4_PkmJMMsSCdRTxG24OQuf_EmHQ"],"n"' b':"EcM4iw7fElXWhad8V-za4Px7nBKjndxoh3XZRkohghKY","wt":"0","wr":[]' b',"wa":[],"a":[]}-AADAAO0Ma_uiLbrXrqkNsLccCNgWcfvopoo2NwZ5aJLKBa9' b'7OMuZibsiVL6bDues9r65o2Tq1hzuuQQK6cHg_OH3xDAAB-cLMTqhogxrxyhMVoP' b'RXJ-rtQaV5oEsXSqcU3phI0bxFJvtydfnySe30LXbOwnFS-_HhCRMOulhBdcAvFR' b'dKAAACXhumJPsAS1UWSjlKiSby_TCC_W82jkTcvWBB4pwrcYmno8jRpQoB0ubPyG' b'96I2RqNql0Q9p5LcMPsLtT_Zt4DA') # apply msg to Wes's Kevery wesKvy.process(ims=bytearray(msg)) # process local copy of msg assert wesK.serder.diger.qb64 == wesSrdr.dig # key state updated so event was validated # Create rotation event for Wes # get current keys as verfers and next digests as digers sith = nxtsith # rotate so nxtsith is now current sith and need new nextsith # 2 of first 3 and 1 of last 2 nxtsith = [["1/2", "1/2", "1/2"], ["1/1", "1/1"]] verfers, digers, cst, nst = wesMgr.rotate(pre=wesPre, count=5, sith=nxtsith, temp=True) assert cst == nst == nxtsith wesSrdr = eventing.rotate( pre=wesK.prefixer.qb64, keys=[verfer.qb64 for verfer in verfers], sith=sith, dig=wesK.serder.diger.qb64, nxt=coring.Nexter(sith=nxtsith, digs=[diger.qb64 for diger in digers]).qb64, sn=wesK.sn + 1, data=[]) sigers = wesMgr.sign(ser=wesSrdr.raw, verfers=verfers) msg = bytearray(wesSrdr.raw) counter = coring.Counter(coring.CtrDex.ControllerIdxSigs, count=len(sigers)) msg.extend(counter.qb64b) for siger in sigers: msg.extend(siger.qb64b) assert msg == bytearray( b'{"v":"KERI10JSON0001fe_","i":"EM8ac0UPJZCaWOw2uRcvx6FaygyxFvGzA5' b'MTob9WfbDQ","s":"4","t":"rot","p":"EkBxzyMDQGRCNmoMOWwh58wuNuERR' b'cLoMH2_F0w99Dw4","kt":[["1/2","1/2","1/2"],["1/1","1/1"]],"k":["' b'DToUWoemnetqJoLFIqDI7lxIJEfF0W7xG5ZlqAseVUQc","Drz-IZjko61q-sPMD' b'IW6n-0NGFubbXiZhzWZrO_BZ0Wc","DiGwL3hjQqiUgQlFPeA6kRR1EBXX0vSLm9' b'b6QhPS8IkQ","Dxj5pcStgZ6CbQ2YktNaj8KLE_g9YAOZF6AL9fyLcWQw","DE5z' b'r5eH8EUVQXyAaxWfQUWkGCId-QDCvvxMT77ibj2Q"],"n":"E3in3Z14va0kk4Wq' b'd3vcCAojKNtQq7ZTrQaavR8x0yu4","wt":"0","wr":[],"wa":[],"a":[]}-A' b'AFAAEjpPTMtLre--y96OaTckIov-qfWT1lqOvwNBAcdTfmsfCLIJgZO4Y2ybJqGw' b'l2Q6DqLdfNQWHiDwnyllo1zZBgABny8aZlKENxCnulxSzSWIbFsg1Kv7RrdgTt4r' b'19taFq-bmBmMTLrkidNbeMHwgsNhhT8f3KJnPTaHEZ2Myd3BDQACaJ2sc2SpEcM0' b'9qMbk-8maWuxjAdMCb8n5P1vJesnf7TW6p3Vu2Mart5HuXW44r79DQ91sAmyYB_0' b'4q--ZyNYAQAD5trFl0S9G0GQmFF7FCgMYWzKNe7x16622OvT1-HjDP-eXxf9dani' b'dlUIbVWqalLgXOdhhsCNUDasvOHLByjSBgAEs-ovUeu2--2wnCJLpfHzLZUbc5fL' b'8bpOShEoPUwxEH4H1Wxsn3xPlvL3_pe5Mun3sq2jIhl1EOjcDaKOHofZCA') # apply msg to Wes's Kevery wesKvy.process(ims=bytearray(msg)) # process local copy of msg assert wesK.serder.diger.qb64 == wesSrdr.dig # key state updated so event was validated assert not os.path.exists(wesKS.path) assert not os.path.exists(wesDB.path) """End Test"""
def test_manager(): """ test Manager class """ manager = keeping.Manager() assert isinstance(manager, keeping.Manager) assert isinstance(manager.keeper, keeping.Keeper) assert manager.keeper.opened manager.keeper.close(clear=True) assert not os.path.exists(manager.keeper.path) assert not manager.keeper.opened raw = b'0123456789abcdef' salt = coring.Salter(raw=raw).qb64 stem = "red" assert salt == '0AMDEyMzQ1Njc4OWFiY2RlZg' ser = bytes( b'{"vs":"KERI10JSON0000fb_","pre":"EvEnZMhz52iTrJU8qKwtDxzmypyosgG' b'70m6LIjkiCdoI","sn":"0","ilk":"icp","sith":"1","keys":["DSuhyBcP' b'ZEZLK-fcw5tzHn2N46wRCG_ZOoeKtWTOunRA"],"nxt":"EPYuj8mq_PYYsoBKkz' b'X1kxSPGYBWaIya3slgCOyOtlqU","toad":"0","wits":[],"cnfg":[]}-AABA' b'ApYcYd1cppVg7Inh2YCslWKhUwh59TrPpIoqWxN2A38NCbTljvmBPBjSGIFDBNOv' b'VjHpdZlty3Hgk6ilF8pVpAQ') with keeping.openKS() as keeper: manager = keeping.Manager(keeper=keeper, salt=salt) assert manager.keeper.opened assert manager._pidx == 0 assert manager._salt == '' # zeroed out assert manager._tier == coring.Tiers.low # salty algorithm incept verfers, digers, cst, nst = manager.incept( salt=salt, temp=True) # algo default salty assert len(verfers) == 1 assert len(digers) == 1 assert cst == '1' assert nst == '1' assert manager.getPidx() == 1 spre = verfers[0].qb64b assert spre == b'DVG3IcCNK4lpFfpMM-9rfkY3XVUcCu5o5cxzv1lgMqxM' pp = json.loads(bytes(manager.keeper.getPrm(key=spre)).decode("utf-8")) pp = helping.datify(keeping.PrePrm, pp) assert pp.pidx == 0 assert pp.algo == keeping.Algos.salty assert pp.salt == salt assert pp.stem == '' assert pp.tier == coring.Tiers.low ps = json.loads(bytes(manager.keeper.getSit(key=spre)).decode("utf-8")) ps = helping.datify(keeping.PreSit, ps) assert ps.old.pubs == [] assert len(ps.new.pubs) == 1 assert ps.new.pubs == ['DVG3IcCNK4lpFfpMM-9rfkY3XVUcCu5o5cxzv1lgMqxM'] assert ps.new.ridx == 0 assert ps.new.kidx == 0 assert len(ps.nxt.pubs) == 1 assert ps.nxt.pubs == ['DcHJWO4GszUP0rvVO4Tl2rUdUM1Ln5osP7BwiUeJWhdc'] assert ps.nxt.ridx == 1 assert ps.nxt.kidx == 1 keys = [verfer.qb64 for verfer in verfers] assert keys == ps.new.pubs # test .pubs db pl = json.loads( bytes(manager.keeper.getPubs( key=keeping.riKey(spre, ps.new.ridx))).decode("utf-8")) assert pl == ps.new.pubs pl = json.loads( bytes(manager.keeper.getPubs( key=keeping.riKey(spre, ps.nxt.ridx))).decode("utf-8")) assert pl == ps.nxt.pubs digs = [diger.qb64 for diger in digers] assert digs == ['E8UYvbKn7KYw9e4F2DR-iduGtdA1o16ePAYjpyCYSeYo'] oldspre = spre spre = b'DCu5o5cxzv1lgMqxMVG3IcCNK4lpFfpMM-9rfkY3XVUc' manager.move(old=oldspre, new=spre) # test .pubs db after move pl = json.loads( bytes(manager.keeper.getPubs( key=keeping.riKey(spre, ps.new.ridx))).decode("utf-8")) assert pl == ps.new.pubs pl = json.loads( bytes(manager.keeper.getPubs( key=keeping.riKey(spre, ps.nxt.ridx))).decode("utf-8")) assert pl == ps.nxt.pubs psigers = manager.sign(ser=ser, pubs=ps.new.pubs) for siger in psigers: assert isinstance(siger, coring.Siger) vsigers = manager.sign(ser=ser, verfers=verfers) psigs = [siger.qb64 for siger in psigers] vsigs = [siger.qb64 for siger in vsigers] assert psigs == vsigs assert psigs == [ 'AAGu9G-EJ0zrRjrDKnHszLVcwhbkSRxniDJFmB2eWcRiFzNFw1QM5GHQnmnXz385SgunZH4sLidCMyzhJWmp1IBw' ] # Test sign with indices indices = [3] # Test with pubs list psigers = manager.sign(ser=ser, pubs=ps.new.pubs, indices=indices) for siger in psigers: assert isinstance(siger, coring.Siger) assert psigers[0].index == indices[0] psigs = [siger.qb64 for siger in psigers] assert psigs == [ 'ADGu9G-EJ0zrRjrDKnHszLVcwhbkSRxniDJFmB2eWcRiFzNFw1QM5GHQnmnXz385SgunZH4sLidCMyzhJWmp1IBw' ] # Test with verfers list vsigers = manager.sign(ser=ser, verfers=verfers, indices=indices) for siger in vsigers: assert isinstance(siger, coring.Siger) assert psigers[0].index == indices[0] vsigs = [siger.qb64 for siger in vsigers] assert vsigs == psigs pcigars = manager.sign(ser=ser, pubs=ps.new.pubs, indexed=False) for cigar in pcigars: assert isinstance(cigar, coring.Cigar) vcigars = manager.sign(ser=ser, verfers=verfers, indexed=False) psigs = [cigar.qb64 for cigar in pcigars] vsigs = [cigar.qb64 for cigar in vcigars] assert psigs == vsigs assert psigs == [ '0BGu9G-EJ0zrRjrDKnHszLVcwhbkSRxniDJFmB2eWcRiFzNFw1QM5GHQnmnXz385SgunZH4sLidCMyzhJWmp1IBw' ] # salty algorithm rotate oldpubs = [verfer.qb64 for verfer in verfers] verfers, digers, cst, nst = manager.rotate(pre=spre.decode("utf-8")) assert len(verfers) == 1 assert len(digers) == 1 assert cst == '1' assert nst == '1' pp = json.loads(bytes(manager.keeper.getPrm(key=spre)).decode("utf-8")) pp = helping.datify(keeping.PrePrm, pp) assert pp.pidx == 0 assert pp.algo == keeping.Algos.salty assert pp.salt == salt assert pp.stem == '' assert pp.tier == coring.Tiers.low ps = json.loads(bytes(manager.keeper.getSit(key=spre)).decode("utf-8")) ps = helping.datify(keeping.PreSit, ps) assert ps.old.pubs == ['DVG3IcCNK4lpFfpMM-9rfkY3XVUcCu5o5cxzv1lgMqxM'] assert len(ps.new.pubs) == 1 assert ps.new.pubs == ['DcHJWO4GszUP0rvVO4Tl2rUdUM1Ln5osP7BwiUeJWhdc'] assert ps.new.ridx == 1 assert ps.new.kidx == 1 assert len(ps.nxt.pubs) == 1 assert ps.nxt.pubs == ['DRpGly44ejh01ur4ltL_LVrYcyqVCQyVLJnqWrVa57Yc'] assert ps.nxt.ridx == 2 assert ps.nxt.kidx == 2 keys = [verfer.qb64 for verfer in verfers] assert keys == ps.new.pubs digs = [diger.qb64 for diger in digers] assert digs == ['EJUzDm_HbdIZDp94OlIoZH1gcaSdWLZhJwqKz2rVJZrc'] assert oldpubs == ps.old.pubs # salty algorithm rotate oldpubs = [verfer.qb64 for verfer in verfers] deadpubs = ps.old.pubs verfers, digers, cst, nst = manager.rotate(pre=spre.decode("utf-8")) assert cst == '1' assert nst == '1' pp = json.loads(bytes(manager.keeper.getPrm(key=spre)).decode("utf-8")) pp = helping.datify(keeping.PrePrm, pp) assert pp.pidx == 0 ps = json.loads(bytes(manager.keeper.getSit(key=spre)).decode("utf-8")) ps = helping.datify(keeping.PreSit, ps) assert oldpubs == ps.old.pubs for pub in deadpubs: assert not manager.keeper.getPri(key=pub.encode("utf-8")) # test .pubs db pl = json.loads( bytes(manager.keeper.getPubs( key=keeping.riKey(spre, ps.new.ridx))).decode("utf-8")) assert pl == ps.new.pubs pl = json.loads( bytes(manager.keeper.getPubs( key=keeping.riKey(spre, ps.nxt.ridx))).decode("utf-8")) assert pl == ps.nxt.pubs # salty algorithm rotate to null verfers, digers, cst, nst = manager.rotate(pre=spre.decode("utf-8"), count=0) assert cst == '1' assert nst == '0' pp = json.loads(bytes(manager.keeper.getPrm(key=spre)).decode("utf-8")) pp = helping.datify(keeping.PrePrm, pp) assert pp.pidx == 0 ps = json.loads(bytes(manager.keeper.getSit(key=spre)).decode("utf-8")) ps = helping.datify(keeping.PreSit, ps) assert digers == [] assert ps.nxt.pubs == [] # attempt to rotate after null with pytest.raises(ValueError) as ex: # attempt to reincept same pre verfers, digers, cst, nst = manager.rotate( pre=spre.decode("utf-8")) assert ex.value.args[0].startswith( 'Attempt to rotate nontransferable ') # randy algo incept verfers, digers, cst, nst = manager.incept(algo=keeping.Algos.randy) assert len(verfers) == 1 assert len(digers) == 1 assert cst == '1' assert nst == '1' assert manager.getPidx() == 2 rpre = verfers[0].qb64b pp = json.loads(bytes(manager.keeper.getPrm(key=rpre)).decode("utf-8")) pp = helping.datify(keeping.PrePrm, pp) assert pp.pidx == 1 assert pp.algo == keeping.Algos.randy assert pp.salt == '' assert pp.stem == '' assert pp.tier == '' ps = json.loads(bytes(manager.keeper.getSit(key=rpre)).decode("utf-8")) ps = helping.datify(keeping.PreSit, ps) assert ps.old.pubs == [] assert len(ps.new.pubs) == 1 assert ps.new.ridx == 0 assert ps.new.kidx == 0 assert len(ps.nxt.pubs) == 1 assert ps.nxt.ridx == 1 assert ps.nxt.kidx == 1 keys = [verfer.qb64 for verfer in verfers] for key in keys: val = bytes(manager.keeper.getPri(key.encode("utf-8"))) digs = [diger.qb64 for diger in digers] assert len(digs) == 1 oldrpre = rpre rpre = b'DMqxMVG3IcCNK4lpFfCu5o5cxzv1lgpMM-9rfkY3XVUc' manager.move(old=oldrpre, new=rpre) # randy algorithm rotate oldpubs = [verfer.qb64 for verfer in verfers] verfers, digers, cst, nst = manager.rotate(pre=rpre.decode("utf-8")) assert cst == '1' assert nst == '1' pp = json.loads(bytes(manager.keeper.getPrm(key=rpre)).decode("utf-8")) pp = helping.datify(keeping.PrePrm, pp) assert pp.pidx == 1 ps = json.loads(bytes(manager.keeper.getSit(key=rpre)).decode("utf-8")) ps = helping.datify(keeping.PreSit, ps) assert oldpubs == ps.old.pubs # randy algo incept with null nxt verfers, digers, cst, nst = manager.incept(algo=keeping.Algos.randy, ncount=0) assert manager.getPidx() == 3 rpre = verfers[0].qb64b assert cst == '1' assert nst == '0' pp = json.loads(bytes(manager.keeper.getPrm(key=rpre)).decode("utf-8")) pp = helping.datify(keeping.PrePrm, pp) assert pp.pidx == 2 ps = json.loads(bytes(manager.keeper.getSit(key=rpre)).decode("utf-8")) ps = helping.datify(keeping.PreSit, ps) assert digers == [] assert ps.nxt.pubs == [] # attempt to rotate after null with pytest.raises(ValueError) as ex: # attempt to reincept same pre verfers, digers, cst, nst = manager.rotate( pre=rpre.decode("utf-8")) # salty algorithm incept with stem verfers, digers, cst, nst = manager.incept( salt=salt, stem=stem, temp=True) # algo default salty assert len(verfers) == 1 assert len(digers) == 1 assert cst == '1' assert nst == '1' assert manager.getPidx() == 4 spre = verfers[0].qb64b assert spre == b'D627iBfehzh966wPzBYjKQuGOSmIkdcR7b14nZv_ULIw' pp = json.loads(bytes(manager.keeper.getPrm(key=spre)).decode("utf-8")) pp = helping.datify(keeping.PrePrm, pp) assert pp.pidx == 3 assert pp.algo == keeping.Algos.salty assert pp.salt == salt assert pp.stem == stem == 'red' assert pp.tier == coring.Tiers.low ps = json.loads(bytes(manager.keeper.getSit(key=spre)).decode("utf-8")) ps = helping.datify(keeping.PreSit, ps) assert ps.old.pubs == [] assert len(ps.new.pubs) == 1 assert ps.new.pubs == ['D627iBfehzh966wPzBYjKQuGOSmIkdcR7b14nZv_ULIw'] assert ps.new.ridx == 0 assert ps.new.kidx == 0 assert len(ps.nxt.pubs) == 1 assert ps.nxt.pubs == ['DHNnq96NI0Bmle_VINGcgX8_VSpxbl3am7ZT6_66Fe8Q'] assert ps.nxt.ridx == 1 assert ps.nxt.kidx == 1 keys = [verfer.qb64 for verfer in verfers] assert keys == ps.new.pubs digs = [diger.qb64 for diger in digers] assert digs == ['EAQ7QvfBLj0OrGTqzJZGutLJowUht_zBA6213agRQ8hA'] # attempt to reincept same first pub with pytest.raises(ValueError) as ex: # attempt to reincept same pre verfers, digers, cst, nst = manager.incept(salt=salt, stem=stem, temp=True) assert ex.value.args[0].startswith('Already incepted pre') oldspre = spre spre = b'DCNK4lpFfpMM-9rfkY3XVUcCu5o5cxzv1lgMqxMVG3Ic' manager.move(old=oldspre, new=spre) # attempt to reincept same first pub after move pre with pytest.raises(ValueError) as ex: # attempt to reincept same pre verfers, digers, cst, nst = manager.incept(salt=salt, stem=stem, temp=True) assert ex.value.args[0].startswith('Already incepted pre') # Create nontransferable keys that are nontransferable identifier prefixes verfers, digers, cst, nst = manager.incept(ncount=0, salt=salt, stem="wit0", transferable=False, temp=True) assert cst == '1' assert nst == '0' wit0pre = verfers[0].qb64 assert verfers[ 0].qb64 == 'B5M0jhHM3vTo15w12pOUYRwxJNaIVS96wSqbFZH-inyc' assert verfers[0].code == coring.MtrDex.Ed25519N assert not digers verfers, digers, cst, nst = manager.incept(ncount=0, salt=salt, stem="wit1", transferable=False, temp=True) assert cst == '1' assert nst == '0' wit1pre = verfers[0].qb64 assert verfers[ 0].qb64 == 'BAH_nE1cfiGjEMK0Ac8U8N51npjBOjyZt3D-_QA4c4y0' assert verfers[0].code == coring.MtrDex.Ed25519N assert not digers assert wit0pre != wit1pre # test .ingest of sequences of keys secrecies = [ ['ArwXoACJgOleVZ2PY7kXn7rA0II0mHYDhc6WrBH8fDAc'], ['A6zz7M08-HQSFq92sJ8KJOT2cZ47x7pXFQLPB0pckB3Q'], ['AcwFTk-wgk3ZT2buPRIbK-zxgPx-TKbaegQvPEivN90Y'], ['Alntkt3u6dDgiQxTATr01dy8M72uuaZEf9eTdM-70Gk8'], ['A1-QxDkso9-MR1A8rZz_Naw6fgaAtayda8hrbkRVVu1E'], ['AKuYMe09COczwf2nIoD5AE119n7GLFOVFlNLxZcKuswc'], ['AxFfJTcSuEE11FINfXMqWttkZGnUZ8KaREhrnyAXTsjw'], ['ALq-w1UKkdrppwZzGTtz4PWYEeWm0-sDHzOv5sq96xJY'], ] pidx, rsalt, rtier = manager.setup() # verify current state assert pidx == 6 assert rsalt == salt == '0AMDEyMzQ1Njc4OWFiY2RlZg' assert rtier == coring.Tiers.low verferies, digers = manager.ingest(secrecies=secrecies) publicies = [] for verfers in verferies: publicies.append([verfer.qb64 for verfer in verfers]) assert publicies == [['DSuhyBcPZEZLK-fcw5tzHn2N46wRCG_ZOoeKtWTOunRA'], ['DVcuJOOJF1IE8svqEtrSuyQjGTd2HhfAkt9y2QkUtFJI'], ['DT1iAhBWCkvChxNWsby2J0pJyxBIxbAtbLA0Ljx-Grh8'], ['DKPE5eeJRzkRTMOoRGVd2m18o8fLqM2j9kaxLhV3x8AQ'], ['D1kcBE7h0ImWW6_Sp7MQxGYSshZZz6XM7OiUE5DXm0dU'], ['D4JDgo3WNSUpt-NG14Ni31_GCmrU0r38yo7kgDuyGkQM'], ['DVjWcaNX2gCkHOjk6rkmqPBCxkRCqwIJ-3OjdYmMwxf4'], ['DT1nEDepd6CSAMCE7NY_jlLdG6_mKUlKS_mW-2HJY1hg']] ipre = publicies[0][0] # test .pris db for i, pubs in enumerate(publicies): pri0 = bytes(manager.keeper.getPri(key=pubs[0])) assert pri0.decode("utf-8") == secrecies[i][0] for pub in pubs: pri = bytes(manager.keeper.getPri(key=pub)) assert pri pp = json.loads(bytes(manager.keeper.getPrm(key=ipre)).decode("utf-8")) pp = helping.datify(keeping.PrePrm, pp) assert pp.pidx == 6 assert manager.getPidx() == 7 ps = json.loads(bytes(manager.keeper.getSit(key=ipre)).decode("utf-8")) ps = helping.datify(keeping.PreSit, ps) assert ps.new.ridx == 7 assert ps.new.pubs == publicies[ps.new.ridx] # test .pubs db for i, pubs in enumerate(publicies): pl = json.loads( bytes(manager.keeper.getPubs( key=keeping.riKey(ipre, i))).decode("utf-8")) assert pl == pubs # nxt pubs pl = json.loads( bytes(manager.keeper.getPubs( key=keeping.riKey(ipre, i + 1))).decode("utf-8")) assert pl assert [diger.qb64 for diger in digers ] == ['Ewt_7B0gfSE7DnMtmNEHiy8BGPVw5at2-e_JgJ1jAfEc'] for i in range(len(publicies)): verfers, digers, cst, nst = manager.replay(ipre, i) assert verfers[0].qb64 == publicies[i][0] assert digers assert cst == nst == '1' with pytest.raises(IndexError): # Test end of replay verfers, digers = manager.replay(ipre, i + 1) with pytest.raises(ValueError): # Test past end of replay verfers, digers = manager.replay(ipre, i + 2) # test .ingest multi-sig of sequences of keys secrecies = [[ 'AgjD4nRlycmM5cPcAkfOATAp8wVldRsnc9f1tiwctXlw', 'AKUotEE0eAheKdDJh9QvNmSEmO_bjIav8V_GmctGpuCQ', 'AK-nVhMMJciMPvmF5VZE_9H-nhrgng9aJWf7_UHPtRNM' ], ['AT2cx-P5YUjIw_SLCHQ0pqoBWGk9s4N1brD-4pD_ANbs'], [ 'Ap5waegfnuP6ezC18w7jQiPyQwYYsp9Yv9rYMlKAYL8k', 'Aqlc_FWWrxpxCo7R12uIz_Y2pHUH2prHx1kjghPa8jT8', 'AagumsL8FeGES7tYcnr_5oN6qcwJzZfLKxoniKUpG4qc' ], ['ADW3o9m3udwEf0aoOdZLLJdf1aylokP0lwwI_M2J9h0s']] pidx, rsalt, rtier = manager.setup() # verify current state assert pidx == 7 assert rsalt == salt == '0AMDEyMzQ1Njc4OWFiY2RlZg' assert rtier == coring.Tiers.low verferies, digers = manager.ingest(secrecies=secrecies, ncount=3) publicies = [] for verfers in verferies: publicies.append([verfer.qb64 for verfer in verfers]) assert publicies == [ [ 'D8KY1sKmgyjAiUDdUBPNPyrSz_ad_Qf9yzhDNZlEKiMc', 'DbWeWTNGXPMQrVuJmScNQn81YF7T2fhh2kXwT8E_NbeI', 'Dmis7BM1brr-1r4DgdO5KMcCf8AnGcUUPhZYUxprI97s' ], ['DfHMsSg0CJCou4erOqaJDr3OyDEikBp5QRp7HjcJGdgw'], [ 'DOaXCkU3Qd0oBSYxGfYtJxUbN6U7VjZiKthPHIHbzabs', 'DLOmEabR-cYJLMrAd0HvQC4lecbF-j2r7w3UQIY3mGMQ', 'DAIyL2yT9nU6kChGXWce8d6q07l0vBLPNImw_f9bazeQ' ], ['D69EflciVP9zgsihNU14Dbm2bPXoNGxKHK_BBVFMQ-YU'] ] ipre = publicies[0][0] # test .pris db for i, pubs in enumerate(publicies): pri0 = bytes(manager.keeper.getPri(key=pubs[0])) assert pri0.decode("utf-8") == secrecies[i][0] for pub in pubs: pri = bytes(manager.keeper.getPri(key=pub)) assert pri pp = json.loads(bytes(manager.keeper.getPrm(key=ipre)).decode("utf-8")) pp = helping.datify(keeping.PrePrm, pp) assert pp.pidx == 7 assert manager.getPidx() == 8 ps = json.loads(bytes(manager.keeper.getSit(key=ipre)).decode("utf-8")) ps = helping.datify(keeping.PreSit, ps) assert ps.new.ridx == 3 assert ps.new.kidx == 7 assert ps.new.pubs == publicies[ps.new.ridx] assert len(ps.nxt.pubs) == 3 # test .pubs db for i, pubs in enumerate(publicies): pl = json.loads( bytes(manager.keeper.getPubs( key=keeping.riKey(ipre, i))).decode("utf-8")) assert pl == pubs # nxt pubs pl = json.loads( bytes(manager.keeper.getPubs( key=keeping.riKey(ipre, i + 1))).decode("utf-8")) assert pl assert [diger.qb64 for diger in digers] == [ 'E7Ch-T3dCZZ_i0u1ACi_Yv1lyyAMoQCT5ar81eUGoPYY', 'EhwPuWbyrJRyU5HpJaoJrq04biTLWx3heNY3TvQrlbU8', 'EJKLXis7QLnodqvtkbkTUKdciTuM-yzhEPUzS9jtxS6Y' ] for i in range(len(publicies)): verfers, digers, cst, nst = manager.replay(ipre, i) assert verfers[0].qb64 == publicies[i][0] assert digers with pytest.raises(IndexError): # Test end of replay verfers, digers = manager.replay(ipre, i + 1) with pytest.raises(ValueError): # Test past end of replay verfers, digers = manager.replay(ipre, i + 2) assert not os.path.exists(manager.keeper.path) assert not manager.keeper.opened """End Test"""
def test_keeper(): """ Test Keeper creation """ """ stat.S_ISVTX is Sticky bit. When this bit is set on a directory it means that a file in that directory can be renamed or deleted only by the owner of the file, by the owner of the directory, or by a privileged process. stat.S_IRUSR Owner has read permission. stat.S_IWUSR Owner has write permission. stat.S_IXUSR Owner has execute permission. """ dirMode = stat.S_ISVTX | stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR assert dirMode == 0o1700 # set mode to sticky bit plus rwx only for owner/user keeper = keeping.Keeper() assert isinstance(keeper, keeping.Keeper) assert keeper.name == "main" assert keeper.temp == False assert isinstance(keeper.env, lmdb.Environment) assert keeper.path.endswith("keri/keep/main") assert keeper.env.path() == keeper.path assert os.path.exists(keeper.path) assert oct(os.stat(keeper.path).st_mode)[-4:] == "1700" assert keeper.DirMode == dirMode assert isinstance(keeper.gbls, lmdb._Database) assert isinstance(keeper.pris, lmdb._Database) assert isinstance(keeper.sits, lmdb._Database) keeper.close(clear=True) assert not os.path.exists(keeper.path) assert not keeper.opened # set to unrestricted mode keeper = keeping.Keeper(dirMode=0o775) assert isinstance(keeper, keeping.Keeper) assert keeper.name == "main" assert keeper.temp == False assert isinstance(keeper.env, lmdb.Environment) assert keeper.path.endswith("keri/keep/main") assert keeper.env.path() == keeper.path assert os.path.exists(keeper.path) assert oct(os.stat(keeper.path).st_mode)[-4:] == "0775" assert isinstance(keeper.gbls, lmdb._Database) assert isinstance(keeper.pris, lmdb._Database) assert isinstance(keeper.sits, lmdb._Database) keeper.close(clear=True) assert not os.path.exists(keeper.path) assert not keeper.opened # test not opened on init keeper = keeping.Keeper(reopen=False) assert isinstance(keeper, keeping.Keeper) assert keeper.name == "main" assert keeper.temp == False assert keeper.opened == False assert keeper.path == None assert keeper.env == None keeper.reopen() assert keeper.opened assert isinstance(keeper.env, lmdb.Environment) assert keeper.path.endswith("keri/keep/main") assert keeper.env.path() == keeper.path assert os.path.exists(keeper.path) assert isinstance(keeper.gbls, lmdb._Database) assert isinstance(keeper.pris, lmdb._Database) assert isinstance(keeper.sits, lmdb._Database) keeper.close(clear=True) assert not os.path.exists(keeper.path) assert not keeper.opened # Test using context manager with keeping.openKS() as keeper: assert isinstance(keeper, keeping.Keeper) assert keeper.name == "test" assert keeper.temp == True assert isinstance(keeper.env, lmdb.Environment) assert keeper.path.startswith("/tmp/keri_keep_") assert keeper.path.endswith("_test/keri/keep/test") assert keeper.env.path() == keeper.path assert os.path.exists(keeper.path) assert isinstance(keeper.gbls, lmdb._Database) assert isinstance(keeper.pris, lmdb._Database) assert isinstance(keeper.sits, lmdb._Database) salta = b'0AZxWJGkCkpDcHuVG4GM1KVw' saltb = b'0AHuVG4GM1KVwZxWJGkCkpDc' pria = b'AaOa6eOCJQcgEozYb1GgV9zE2yPgBXiP6h_J2cZeCy4M' prib = b'AE2yPgBXiP6h_J2cZeCy4MaOa6eOCJQcgEozYb1GgV9z' puba = b'DGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4' pubb = b'DoXvbGv9IPb0foWTZvI_4GAPkzNZMtX-QiVgbRbyAIZG' pubc = b'DAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4G' prea = b'EWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc' preb = b'EQPYGGwTmuupUhPx5_yZ-Wk1x4ejhccWzwEHHzq7K0gz' # test .gbls sub db methods key = b'pidx' pidxa = b'%x' % 0 # "{:x}".format(pidx).encode("utf-8") pidxb = b'%x' % 1 # "{:x}".format(pidx).encode("utf-8" assert keeper.getPri(key) == None assert keeper.delPri(key) == False assert keeper.putPri(key, val=pidxa) == True assert keeper.getPri(key) == pidxa assert keeper.putPri(key, val=pidxb) == False assert keeper.getPri(key) == pidxa assert keeper.setPri(key, val=pidxb) == True assert keeper.getPri(key) == pidxb assert keeper.delPri(key) == True assert keeper.getPri(key) == None key = b'salt' assert keeper.getPri(key) == None assert keeper.delPri(key) == False assert keeper.putPri(key, val=salta) == True assert keeper.getPri(key) == salta assert keeper.putPri(key, val=saltb) == False assert keeper.getPri(key) == salta assert keeper.setPri(key, val=saltb) == True assert keeper.getPri(key) == saltb assert keeper.delPri(key) == True assert keeper.getPri(key) == None key = b'tier' assert keeper.getPri(key) == None assert keeper.delPri(key) == False assert keeper.putPri(key, val=coring.Tiers.low) == True assert keeper.getPri(key) == coring.Tiers.low.encode("utf-8") assert keeper.putPri(key, val=coring.Tiers.med) == False assert keeper.getPri(key) == coring.Tiers.low.encode("utf-8") assert keeper.setPri(key, val=coring.Tiers.med) == True assert keeper.getPri(key) == coring.Tiers.med.encode("utf-8") assert keeper.delPri(key) == True assert keeper.getPri(key) == None # test .pris sub db methods key = puba assert keeper.getPri(key) == None assert keeper.delPri(key) == False assert keeper.putPri(key, val=pria) == True assert keeper.getPri(key) == pria assert keeper.putPri(key, val=prib) == False assert keeper.getPri(key) == pria assert keeper.setPri(key, val=prib) == True assert keeper.getPri(key) == prib assert keeper.delPri(key) == True assert keeper.getPri(key) == None # test .pres sub db methods key = puba assert keeper.getPre(key) == None assert keeper.delPre(key) == False assert keeper.putPre(key, val=prea) == True assert keeper.getPre(key) == prea assert keeper.putPre(key, val=preb) == False assert keeper.getPre(key) == prea assert keeper.setPre(key, val=preb) == True assert keeper.getPre(key) == preb assert keeper.delPre(key) == True assert keeper.getPre(key) == None # test .prms sub db methods key = prea prma = json.dumps( dict( pidx=0, algo='salty', salt=salta.decode("utf-8"), stem='', tier='low', )).encode("utf-8") prmb = json.dumps( dict( pidx=1, algo='randy', salt='', stem='', level='', )).encode("utf-8") assert keeper.getPrm(key) == None assert keeper.delPrm(key) == False assert keeper.putPrm(key, val=prma) == True assert keeper.getPrm(key) == prma assert keeper.putPrm(key, val=prmb) == False assert keeper.getPrm(key) == prma assert keeper.setPrm(key, val=prmb) == True assert keeper.getPrm(key) == prmb assert keeper.delPrm(key) == True assert keeper.getPrm(key) == None # test .sits sub db methods with pubs key = prea sita = json.dumps( dict(old=dict(pubs=[], ridx=0, kidx=0, st='0', dt=''), new=dict(pubs=[puba.decode("utf-8")], ridx=1, kidx=1, st='1', dt=helping.nowIso8601()), nxt=dict(pubs=[pubb.decode("utf-8")], ridx=2, kidx=2, st='1', dt=helping.nowIso8601()))).encode("utf-8") sitb = json.dumps( dict(old=dict(pubs=[puba.decode("utf-8")], ridx=0, kidx=0, st='1', dt=helping.nowIso8601()), new=dict(pubs=[pubb.decode("utf-8")], ridx=1, kidx=1, st='1', dt=helping.nowIso8601()), nxt=dict(pubs=[pubc.decode("utf-8")], ridx=2, kidx=2, st='1', dt=helping.nowIso8601()))).encode("utf-8") assert keeper.getSit(key) == None assert keeper.delSit(key) == False assert keeper.putSit(key, val=sita) == True assert keeper.getSit(key) == sita assert keeper.putSit(key, val=sitb) == False assert keeper.getSit(key) == sita assert keeper.setSit(key, val=sitb) == True assert keeper.getSit(key) == sitb assert keeper.delSit(key) == True assert keeper.getSit(key) == None # test .pubs sub db methods key0 = keeping.riKey(prea, 0) pubs1 = [puba.decode("utf-8"), pubb.decode("utf-8")] pubs2 = [pubc.decode("utf-8")] spubs1 = json.dumps(pubs1).encode("utf-8") assert spubs1 == (b'["DGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4", ' b'"DoXvbGv9IPb0foWTZvI_4GAPkzNZMtX-QiVgbRbyAIZG"]') spubs2 = json.dumps(pubs2).encode("utf-8") assert spubs2 == b'["DAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4G"]' assert keeper.getPubs(key0) == None assert keeper.delPubs(key0) == False assert keeper.putPubs(key0, val=spubs1) == True assert keeper.getPubs(key0) == spubs1 assert keeper.putPubs(key0, val=spubs2) == False assert keeper.getPubs(key0) == spubs1 assert keeper.setPubs(key0, val=spubs2) == True assert keeper.getPubs(key0) == spubs2 assert keeper.delPubs(key0) == True assert keeper.getPubs(key0) == None assert not os.path.exists(keeper.path) """ End Test """
def test_delegation(): """ Test creation and validation of delegated identifer prefixes and events """ # bob is the delegator del is bob's delegate bobSalt = coring.Salter(raw=b'0123456789abcdef').qb64 delSalt = coring.Salter(raw=b'abcdef0123456789').qb64 with dbing.openDB(name="bob") as bobDB, \ keeping.openKS(name="bob") as bobKS, \ dbing.openDB(name="del") as delDB, \ keeping.openKS(name="del") as delKS: # Init key pair managers bobMgr = keeping.Manager(keeper=bobKS, salt=bobSalt) delMgr = keeping.Manager(keeper=delKS, salt=delSalt) # Init Keverys bobKvy = eventing.Kevery(db=bobDB) delKvy = eventing.Kevery(db=delDB) # Setup Bob by creating inception event verfers, digers, cst, nst = bobMgr.incept( stem='bob', temp=True) # algo default salty and rooted bobSrdr = 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) bobPre = bobSrdr.ked["i"] assert bobPre == 'EiBlVttjqvySMbA4ShN19rSrz3D0ioNW-Uj92Ri7XnFE' bobMgr.move(old=verfers[0].qb64, new=bobPre) # move key pair label to prefix sigers = bobMgr.sign(ser=bobSrdr.raw, verfers=verfers) msg = bytearray(bobSrdr.raw) counter = coring.Counter(code=coring.CtrDex.ControllerIdxSigs, count=len(sigers)) msg.extend(counter.qb64b) for siger in sigers: msg.extend(siger.qb64b) assert msg == bytearray( b'{"v":"KERI10JSON0000e6_","i":"EiBlVttjqvySMbA4ShN19rSrz3D0ioNW-U' b'j92Ri7XnFE","s":"0","t":"icp","kt":"1","k":["DqI2cOZ06RwGNwCovYU' b'WExmdKU983IasmUKMmZflvWdQ"],"n":"E7FuL3Z_KBgt_QAwuZi1lUFNC69wvyH' b'SxnMFUsKjZHss","wt":"0","w":[],"c":[]}-AABAAQPFdtnncXLz6dE6A-tXG' b'YYK0BHu3I3Pj-G8DxlbzC3yx5MV8yucZILqAA5toZNODnHVHZtPIMkDknqldL4utBQ' ) # apply msg to bob's Kevery bobKvy.process(ims=bytearray(msg)) # process local copy of msg bobK = bobKvy.kevers[bobPre] assert bobK.prefixer.qb64 == bobPre assert bobK.serder.diger.qb64 == bobSrdr.dig assert bobK.serder.diger.qb64 == 'EvP2kWxEjTMI3auc6x64EpU-nMQZHiBeKeuavcGdRB24' # apply msg to del's Kevery delKvy.process(ims=bytearray(msg)) # process remote copy of msg assert bobPre in delKvy.kevers # Setup Del's inception event assuming that Bob's next event will be an ixn delegating event verfers, digers, cst, nst = delMgr.incept( stem='del', temp=True) # algo default salty and rooted seal = eventing.SealLocation(i=bobK.prefixer.qb64, s="{:x}".format(bobK.sn + 1), t=coring.Ilks.ixn, p=bobK.serder.diger.qb64) assert seal._asdict() == dict( i='EiBlVttjqvySMbA4ShN19rSrz3D0ioNW-Uj92Ri7XnFE', s='1', t='ixn', p='EvP2kWxEjTMI3auc6x64EpU-nMQZHiBeKeuavcGdRB24') delSrdr = eventing.delcept( keys=[verfer.qb64 for verfer in verfers], seal=seal, nxt=coring.Nexter(digs=[diger.qb64 for diger in digers]).qb64) delPre = delSrdr.ked["i"] assert delPre == 'ErLe2qWp4VCmDp7v_R01tC-ha13ZEZY0VGcgYtPRhqPs' delMgr.move(old=verfers[0].qb64, new=delPre) # move key pair label to prefix assert delSrdr.dig == 'ESDuaqpoI8-HLD8-eLijUMZpXqYFkNArJFDvt3ABYr9I' # Now create delegating event seal = eventing.SealEvent(i=delPre, s=delSrdr.ked["s"], d=delSrdr.dig) bobSrdr = eventing.interact(pre=bobK.prefixer.qb64, dig=bobK.serder.diger.qb64, sn=bobK.sn + 1, data=[seal._asdict()]) sigers = bobMgr.sign(ser=bobSrdr.raw, verfers=bobK.verfers) msg = bytearray(bobSrdr.raw) counter = coring.Counter(code=coring.CtrDex.ControllerIdxSigs, count=len(sigers)) msg.extend(counter.qb64b) for siger in sigers: msg.extend(siger.qb64b) assert msg == bytearray( b'{"v":"KERI10JSON000107_","i":"EiBlVttjqvySMbA4ShN19rSrz3D0ioNW-U' b'j92Ri7XnFE","s":"1","t":"ixn","p":"EvP2kWxEjTMI3auc6x64EpU-nMQZH' b'iBeKeuavcGdRB24","a":[{"i":"ErLe2qWp4VCmDp7v_R01tC-ha13ZEZY0VGcg' b'YtPRhqPs","s":"0","d":"ESDuaqpoI8-HLD8-eLijUMZpXqYFkNArJFDvt3ABY' b'r9I"}]}-AABAAZ4V2cSIXYEPg5BtkJSHVBj-A0dGI6rH2XGaVt1kewqGeJjpy4uz' b'ObPWnoBpaEojFa5AnrUJEgMytORoWMqEhCw') # apply msg to bob's Kevery bobKvy.process(ims=bytearray(msg)) # process local copy of msg assert bobK.serder.diger.qb64 == bobSrdr.dig # key state updated so event was validated assert bobK.serder.diger.qb64 == 'EtzXPztLsGC5DGyooSdHdBGIOHjhblBWtZ_AOhGS-hDE' # apply msg to del's Kevery delKvy.process(ims=bytearray(msg)) # process remote copy of msg assert delKvy.kevers[bobPre].serder.diger.qb64 == bobSrdr.dig # now create msg with Del's delegated inception event sigers = delMgr.sign(ser=delSrdr.raw, verfers=verfers) msg = bytearray(delSrdr.raw) counter = coring.Counter(code=coring.CtrDex.ControllerIdxSigs, count=len(sigers)) msg.extend(counter.qb64b) for siger in sigers: msg.extend(siger.qb64b) assert msg == bytearray( b'{"v":"KERI10JSON000165_","i":"ErLe2qWp4VCmDp7v_R01tC-ha13ZEZY0VG' b'cgYtPRhqPs","s":"0","t":"dip","kt":"1","k":["DuK1x8ydpucu3480Jpd' b'1XBfjnCwb3dZ3x5b1CJmuUphA"],"n":"EWWkjZkZDXF74O2bOQ4H5hu4nXDlKg2' b'm4CBEBkUxibiU","wt":"0","w":[],"c":[],"da":{"i":"EiBlVttjqvySMbA' b'4ShN19rSrz3D0ioNW-Uj92Ri7XnFE","s":"1","t":"ixn","p":"EvP2kWxEjT' b'MI3auc6x64EpU-nMQZHiBeKeuavcGdRB24"}}-AABAADv-a3LeXEStuY1LHknepu' b'J7mBcTByugqQ1TNRMrIa0rctfjKsh-hkkkpwDj6M_OLLaFtLqBpmdNTUgBPANLzCQ' ) # apply Del's delegated inception event message to bob's Kevery bobKvy.process(ims=bytearray(msg)) # process local copy of msg assert delPre in bobKvy.kevers # successfully validated delK = bobKvy.kevers[delPre] assert delK.delegated assert delK.serder.diger.qb64 == delSrdr.dig # key state updated so event was validated assert delK.serder.diger.qb64 == 'ESDuaqpoI8-HLD8-eLijUMZpXqYFkNArJFDvt3ABYr9I' # apply msg to del's Kevery delKvy.process(ims=bytearray(msg)) # process remote copy of msg assert delKvy.kevers[delPre].serder.diger.qb64 == delSrdr.dig # Setup Del rotation event assuming that Bob's next event will be an ixn delegating event verfers, digers, cst, nst = delMgr.rotate(pre=delPre, temp=True) seal = eventing.SealLocation(i=bobK.prefixer.qb64, s="{:x}".format(bobK.sn + 1), t=coring.Ilks.ixn, p=bobK.serder.diger.qb64) assert seal._asdict() == { 'i': 'EiBlVttjqvySMbA4ShN19rSrz3D0ioNW-Uj92Ri7XnFE', 's': '2', 't': 'ixn', 'p': 'EtzXPztLsGC5DGyooSdHdBGIOHjhblBWtZ_AOhGS-hDE' } delSrdr = eventing.deltate( pre=delK.prefixer.qb64, keys=[verfer.qb64 for verfer in verfers], dig=delK.serder.diger.qb64, seal=seal, sn=delK.sn + 1, nxt=coring.Nexter(digs=[diger.qb64 for diger in digers]).qb64) assert delSrdr.dig == 'E-dZsWLp2IIPVDbGdGS-yvuw4HeV_w_w76FHsofmuiq0' # Now create delegating rotation event seal = eventing.SealEvent(i=delK.prefixer.qb64, s=delSrdr.ked["s"], d=delSrdr.dig) bobSrdr = eventing.interact(pre=bobK.prefixer.qb64, dig=bobK.serder.diger.qb64, sn=bobK.sn + 1, data=[seal._asdict()]) sigers = bobMgr.sign(ser=bobSrdr.raw, verfers=bobK.verfers) msg = bytearray(bobSrdr.raw) counter = coring.Counter(code=coring.CtrDex.ControllerIdxSigs, count=len(sigers)) msg.extend(counter.qb64b) for siger in sigers: msg.extend(siger.qb64b) assert msg == bytearray( b'{"v":"KERI10JSON000107_","i":"EiBlVttjqvySMbA4ShN19rSrz3D0ioNW-U' b'j92Ri7XnFE","s":"2","t":"ixn","p":"EtzXPztLsGC5DGyooSdHdBGIOHjhb' b'lBWtZ_AOhGS-hDE","a":[{"i":"ErLe2qWp4VCmDp7v_R01tC-ha13ZEZY0VGcg' b'YtPRhqPs","s":"1","d":"E-dZsWLp2IIPVDbGdGS-yvuw4HeV_w_w76FHsofmu' b'iq0"}]}-AABAAmloDxOwz6ztvRR_4N8Hn-6ZJk6_0nQhfNE7bzX6NpJRfYDwmUw3' b'rXod0g46iFOLqEWw12oaFVzVH85NYAh67Ag') # apply msg to bob's Kevery bobKvy.process(ims=bytearray(msg)) # process local copy of msg assert bobK.serder.diger.qb64 == bobSrdr.dig # key state updated so event was validated # apply msg to del's Kevery delKvy.process(ims=bytearray(msg)) # process remote copy of msg assert delKvy.kevers[bobPre].serder.diger.qb64 == bobSrdr.dig # now create msg from Del's delegated rotation event sigers = delMgr.sign(ser=delSrdr.raw, verfers=verfers) msg = bytearray(delSrdr.raw) counter = coring.Counter(code=coring.CtrDex.ControllerIdxSigs, count=len(sigers)) msg.extend(counter.qb64b) for siger in sigers: msg.extend(siger.qb64b) assert msg == bytearray( b'{"v":"KERI10JSON0001a1_","i":"ErLe2qWp4VCmDp7v_R01tC-ha13ZEZY0VG' b'cgYtPRhqPs","s":"1","t":"drt","p":"ESDuaqpoI8-HLD8-eLijUMZpXqYFk' b'NArJFDvt3ABYr9I","kt":"1","k":["DTf6QZWoet154o9wvzeMuNhLQRr8JaAU' b'eiC6wjB_4_08"],"n":"E8kyiXDfkE7idwWnAZQjHbUZMz-kd_yIMH0miptIFFPo' b'","wt":"0","wr":[],"wa":[],"a":[],"da":{"i":"EiBlVttjqvySMbA4ShN' b'19rSrz3D0ioNW-Uj92Ri7XnFE","s":"2","t":"ixn","p":"EtzXPztLsGC5DG' b'yooSdHdBGIOHjhblBWtZ_AOhGS-hDE"}}-AABAAXcUl6KlY4VOx8ZumFMc0uR4iH' b'BGmPQo4IAx0nIiiEDB_u2ewkvgIDIp1ELDGxfc2VVUkl38Z7PqwydBdpIK0DA') # apply Del's delegated inception event message to bob's Kevery bobKvy.process(ims=bytearray(msg)) # process local copy of msg assert delK.delegated assert delK.serder.diger.qb64 == delSrdr.dig # key state updated so event was validated assert delK.serder.diger.qb64 == 'E-dZsWLp2IIPVDbGdGS-yvuw4HeV_w_w76FHsofmuiq0' # apply msg to del's Kevery delKvy.process(ims=bytearray(msg)) # process remote copy of msg assert delKvy.kevers[delPre].serder.diger.qb64 == delSrdr.dig assert not os.path.exists(delKS.path) assert not os.path.exists(delDB.path) assert not os.path.exists(bobKS.path) assert not os.path.exists(bobDB.path) """End Test"""
def test_directing_basic(): """ Test directing """ help.ogler.resetLevel(level=logging.DEBUG) # 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 dbing.openDB(name="eve") as eveDB, keeping.openKS(name="eve") as eveKS, \ dbing.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 bobKevers = dict() eveKevers = dict() # setup bob bobHab = directing.Habitat(ks=bobKS, db=bobDB, kevers=bobKevers, 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 = doing.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(bobKevers) 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(bobKevers) assert bobReactor.hab.kvy.db == bobDB assert id(bobReactor.kevery.ims) == id(bobReactor.client.rxbs) assert id(bobReactor.client.rxbs) == id(bobDirector.client.rxbs) bobServer = serving.Server(host="", port=bobPort) bobServerDoer = doing.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 = directing.Habitat(ks=eveKS, db=eveDB, kevers=eveKevers, 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 = doing.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(eveKevers) 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(eveKevers) assert eveReactor.hab.kvy.db == eveDB assert id(eveReactor.kevery.ims) == id(eveReactor.client.rxbs) assert id(eveReactor.client.rxbs) == id(eveDirector.client.rxbs) eveServer = serving.Server(host="", port=evePort) eveServerDoer = doing.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_direct_mode_with_manager(): """ Test direct mode with transferable validator event receipts """ # manual process to generate a list of secrets # root = pysodium.randombytes(pysodium.crypto_pwhash_SALTBYTES) # secrets = generateSecrets(root=root, count=8) # Direct Mode initiated by coe is controller, val is validator # but goes both ways once initiated. # set of secrets (seeds for private keys) coeSalt = Salter(raw=b'0123456789abcdea').qb64 # set of secrets (seeds for private keys) valSalt = Salter(raw=b'1123456789abcdea').qb64 with openDB("controller") as coeLogger, openDB("validator") as valLogger, openKS(name="controller") as coeKpr, openKS(name="validator") as valKpr: # Init key pair manager coeMgr = Manager(keeper=coeKpr, salt=coeSalt) coeVerfers, coeDigers = coeMgr.incept(icount=1, ncount=1) # init Keverys coeKevery = Kevery(db=coeLogger) valKevery = Kevery(db=valLogger) coe_event_digs = [] # list of controller's own event log digs to verify against database val_event_digs = [] # list of validator's own event log digs to verify against database # init sequence numbers for both controller and validator csn = cesn = 0 # sn and last establishment sn = esn vsn = vesn = 0 # sn and last establishment sn = esn # Controller Event 0 Inception Transferable (nxt digest not empty) coeSerder = incept(keys=[coeVerfers[0].qb64], nxt=Nexter(digs=[coeDigers[0].qb64]).qb64, code=MtrDex.Blake3_256) assert csn == int(coeSerder.ked["s"], 16) == 0 coepre = coeSerder.ked["i"] assert coepre == 'EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBOCJnPYabcas' coe_event_digs.append(coeSerder.dig) # sign serialization sigers = coeMgr.sign(ser=coeSerder.raw, verfers=coeVerfers) # create serialized message cmsg = messagize(coeSerder, sigers) assert cmsg == bytearray(b'{"v":"KERI10JSON0000e6_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBO' b'CJnPYabcas","s":"0","t":"icp","kt":"1","k":["Dpt7mGZ3y5UmhT1NLEx' b'b1IW8vMJ8ylQW3K44LfkTgAqE"],"n":"Erpltchg7BUv21Qz3ZXhOhVu63m7S7Y' b'bPb21lSeGYd90","wt":"0","w":[],"c":[]}-AABAA2dW-FXhcUiGQZh1JhRrh' b'_JDqEPU678KT0U8F_a-l8Q3sO25xJAs3Iu2bBonBPZjVo_Zc8FVqrqXjQxxUPt4ICg') # create own Controller Kever in Controller's Kevery coeKevery.processOne(ims=bytearray(cmsg)) # send copy of cmsg coeKever = coeKevery.kevers[coepre] assert coeKever.prefixer.qb64 == coepre # Validator Event 0 Inception Transferable (nxt digest not empty) # Init key pair manager valMgr = Manager(keeper=valKpr, salt=valSalt) valVerfers, valDigers = valMgr.incept(icount=1, ncount=1) valSerder = incept(keys=[valVerfers[0].qb64], nxt=Nexter(digs=[valDigers[0].qb64]).qb64, code=MtrDex.Blake3_256) assert vsn == int(valSerder.ked["s"], 16) == 0 valpre = valSerder.ked["i"] assert valpre == 'EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDyVSOXYW0' val_event_digs.append(valSerder.dig) # sign serialization sigers = valMgr.sign(valSerder.raw, verfers=valVerfers) # return Siger if index # create serialized message vmsg = messagize(valSerder, sigers) assert vmsg == bytearray(b'{"v":"KERI10JSON0000e6_","i":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqF' b'BDyVSOXYW0","s":"0","t":"icp","kt":"1","k":["DLSBUmklGu6eLqnA5DA' b'gj41jetAJYkyn34crqejwXxVw"],"n":"EwmUJaS6DSPRQprlGp_3CIg8BZwmaJl' b'KPlE4LHcx0Zms","wt":"0","w":[],"c":[]}-AABAAxvl1581mKQME95XZrjsy' b'CXxJ3fCnmNSG_Bc1I4FcxEoeQbgdLAQ8sudwb0FHOYXfqRE6Z7PraaU82YQDyVShDw') # create own Validator Kever in Validator's Kevery valKevery.processOne(ims=bytearray(vmsg)) # send copy of vmsg valKever = valKevery.kevers[valpre] assert valKever.prefixer.qb64 == valpre # simulate sending of controller's inception message to validator valKevery.process(ims=bytearray(cmsg)) # make copy of msg assert coepre in valKevery.kevers # creates Kever for controller in validator's .kevers # create receipt of controller's inception # create seal of validator's last establishment event seal = SealEvent(i=valpre, s="{:x}".format(valKever.lastEst.s), d=valKever.lastEst.d) coeK = valKevery.kevers[coepre] # lookup coeKever from validator's .kevers # create validator receipt reserder = chit(pre=coeK.prefixer.qb64, sn=coeK.sn, dig=coeK.serder.diger.qb64, seal=seal) # Validate receipt assert reserder.raw == (b'{"v":"KERI10JSON000105_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBOCJnPYabcas",' b'"s":"0","t":"vrc","d":"Ey2pXEnaoQVwxA4jB6k0QH5G2Us-0juFL5hOAHAwIEkc","a":{"i' b'":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDyVSOXYW0","s":"0","d":"ElsHFkbZQjRb7x' b'HnuE-wyiarIZ9j-1CEQ89I0E3WevcE"}}') # sign controller's event not receipt # look up event to sign from validator's kever for coe coeIcpDig = bytes(valKevery.db.getKeLast(key=snKey(pre=coepre, sn=csn))) assert coeIcpDig == coeK.serder.diger.qb64b == b'Ey2pXEnaoQVwxA4jB6k0QH5G2Us-0juFL5hOAHAwIEkc' coeIcpRaw = bytes(valKevery.db.getEvt(key=dgKey(pre=coepre, dig=coeIcpDig))) assert coeIcpRaw == (b'{"v":"KERI10JSON0000e6_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBOCJnPYabcas",' b'"s":"0","t":"icp","kt":"1","k":["Dpt7mGZ3y5UmhT1NLExb1IW8vMJ8ylQW3K44LfkTgAq' b'E"],"n":"Erpltchg7BUv21Qz3ZXhOhVu63m7S7YbPb21lSeGYd90","wt":"0","w":[],"c":[' b']}') counter = Counter(CtrDex.ControllerIdxSigs) assert counter.qb64 == '-AAB' sigers = valMgr.sign(ser=coeIcpRaw, verfers=valVerfers) # return Siger if index # process own validator receipt in validator's Kevery so have copy in own log rmsg = messagize(reserder, sigers) assert rmsg == bytearray(b'{"v":"KERI10JSON000105_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBOCJnPYabcas",' b'"s":"0","t":"vrc","d":"Ey2pXEnaoQVwxA4jB6k0QH5G2Us-0juFL5hOAHAwIEkc","a":{"i' b'":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDyVSOXYW0","s":"0","d":"ElsHFkbZQjRb7x' b'HnuE-wyiarIZ9j-1CEQ89I0E3WevcE"}}-AABAARG0my55RTX81fFzUbbcfygZXfz04VglNA8Zwy' b'qst_ZvLo05jau9GsF0IS9Vm6yGr8QQPdB7M4oVkrd9IEZ8PDA') valKevery.processOne(ims=bytearray(rmsg)) # process copy of rmsg # attach receipt message to existing message with validators inception message # simulate streaming. validator first sends it's inception event, then sends a receipt to controller vmsg.extend(rmsg) assert vmsg == bytearray(b'{"v":"KERI10JSON0000e6_","i":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqF' b'BDyVSOXYW0","s":"0","t":"icp","kt":"1","k":["DLSBUmklGu6eLqnA5DA' b'gj41jetAJYkyn34crqejwXxVw"],"n":"EwmUJaS6DSPRQprlGp_3CIg8BZwmaJl' b'KPlE4LHcx0Zms","wt":"0","w":[],"c":[]}-AABAAxvl1581mKQME95XZrjsy' b'CXxJ3fCnmNSG_Bc1I4FcxEoeQbgdLAQ8sudwb0FHOYXfqRE6Z7PraaU82YQDyVSh' b'Dw{"v":"KERI10JSON000105_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14Vk' b'BOCJnPYabcas","s":"0","t":"vrc","d":"Ey2pXEnaoQVwxA4jB6k0QH5G2Us' b'-0juFL5hOAHAwIEkc","a":{"i":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFB' b'DyVSOXYW0","s":"0","d":"ElsHFkbZQjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3W' b'evcE"}}-AABAARG0my55RTX81fFzUbbcfygZXfz04VglNA8Zwyqst_ZvLo05jau9' b'GsF0IS9Vm6yGr8QQPdB7M4oVkrd9IEZ8PDA') # Simulate sending validator's inception event and receipt of controller's inception message to controller coeKevery.process(ims=vmsg) # controller process validator's inception and receipt # check if validator's Kever in controller's .kevers assert valpre in coeKevery.kevers # check if receipt quadruple from validator in receipt database result = coeKevery.db.getVrcs(key=dgKey(pre=coeKever.prefixer.qb64, dig=coeKever.serder.diger.qb64)) assert bytes(result[0]) == (valKever.prefixer.qb64b + Seqner(sn=valKever.sn).qb64b + valKever.serder.diger.qb64b + sigers[0].qb64b) assert bytes(result[0]) == (b'EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDyVSOXYW00AAAAAAAAAAAAAAAAAAAAAAAElsHFkbZ' b'QjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3WevcEAARG0my55RTX81fFzUbbcfygZXfz04VglNA8Zwyq' b'st_ZvLo05jau9GsF0IS9Vm6yGr8QQPdB7M4oVkrd9IEZ8PDA') # create receipt to escrow use invalid digest and sequence number so not in controller's db fake = reserder.dig # some other digest reserder = chit(pre=coeK.prefixer.qb64, sn=10, dig=fake, seal=seal) # sign event not receipt sigers = valMgr.sign(ser=coeIcpRaw, verfers=valVerfers) # return Siger if index # create receipt message vmsg = messagize(reserder, sigers) assert vmsg == bytearray(b'{"v":"KERI10JSON000105_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBO' b'CJnPYabcas","s":"a","t":"vrc","d":"EwxY7Vhkeyr7LBnLAzdGXZzSmTmJV' b'RctQfNUO0YUqeOU","a":{"i":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDy' b'VSOXYW0","s":"0","d":"ElsHFkbZQjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3Wev' b'cE"}}-AABAARG0my55RTX81fFzUbbcfygZXfz04VglNA8Zwyqst_ZvLo05jau9Gs' b'F0IS9Vm6yGr8QQPdB7M4oVkrd9IEZ8PDA') coeKevery.process(ims=vmsg) # controller process the escrow receipt from validator # check if receipt quadruple in escrow database result = coeKevery.db.getVres(key=snKey(pre=coeKever.prefixer.qb64, sn=10)) assert bytes(result[0]) == (fake.encode("utf-8") + valKever.prefixer.qb64b + Seqner(sn=valKever.sn).qb64b + valKever.serder.diger.qb64b + sigers[0].qb64b) # Send receipt from controller to validator # create receipt of validator's inception # create seal of controller's last establishment event seal = SealEvent(i=coepre, s="{:x}".format(coeKever.lastEst.s), d=coeKever.lastEst.d) valK = coeKevery.kevers[valpre] # lookup valKever from controller's .kevers # create validator receipt reserder = chit(pre=valK.prefixer.qb64, sn=valK.sn, dig=valK.serder.diger.qb64, seal=seal) # sign validator's event not receipt # look up event to sign from controller's kever for validator valIcpDig = bytes(coeKevery.db.getKeLast(key=snKey(pre=valpre, sn=vsn))) assert valIcpDig == valK.serder.diger.qb64b == b'ElsHFkbZQjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3WevcE' valIcpRaw = bytes(coeKevery.db.getEvt(key=dgKey(pre=valpre, dig=valIcpDig))) assert valIcpRaw == (b'{"v":"KERI10JSON0000e6_","i":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqF' b'BDyVSOXYW0","s":"0","t":"icp","kt":"1","k":["DLSBUmklGu6eLqnA5DA' b'gj41jetAJYkyn34crqejwXxVw"],"n":"EwmUJaS6DSPRQprlGp_3CIg8BZwmaJl' b'KPlE4LHcx0Zms","wt":"0","w":[],"c":[]}') counter = Counter(CtrDex.ControllerIdxSigs) assert counter.qb64 == '-AAB' sigers = coeMgr.sign(ser=valIcpRaw, verfers=coeVerfers) # return Siger if index # create receipt message cmsg = messagize(reserder, sigers) assert cmsg == bytearray(b'{"v":"KERI10JSON000105_","i":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqF' b'BDyVSOXYW0","s":"0","t":"vrc","d":"ElsHFkbZQjRb7xHnuE-wyiarIZ9j-' b'1CEQ89I0E3WevcE","a":{"i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBOCJn' b'PYabcas","s":"0","d":"Ey2pXEnaoQVwxA4jB6k0QH5G2Us-0juFL5hOAHAwIE' b'kc"}}-AABAAKXFMBGw559YHoxyeDrmpilQo5JMbr5WSfYTn1IXV_rMtg23_GHrNQ' b'Ua7y45UkNftT48O0MekxT7geRBU84dACA') # controller process own receipt in own Kevery so have copy in own log coeKevery.processOne(ims=bytearray(cmsg)) # make copy # Simulate sending controller's receipt of validator's inception message to validator valKevery.process(ims=cmsg) # controller process validator's inception and receipt # check if receipt quadruple from controller in validator's receipt database result = valKevery.db.getVrcs(key=dgKey(pre=valKever.prefixer.qb64, dig=valKever.serder.diger.qb64)) assert bytes(result[0]) == (coeKever.prefixer.qb64b + Seqner(sn=coeKever.sn).qb64b + coeKever.serder.diger.qb64b + sigers[0].qb64b) assert bytes(result[0]) == (b'EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBOCJnPYabcas0AAAAAAAAAAAAAAAAAAAAAAAEy2pXEna' b'oQVwxA4jB6k0QH5G2Us-0juFL5hOAHAwIEkcAAKXFMBGw559YHoxyeDrmpilQo5JMbr5WSfYTn1I' b'XV_rMtg23_GHrNQUa7y45UkNftT48O0MekxT7geRBU84dACA') # Controller Event 1 Rotation Transferable csn += 1 cesn += 1 assert csn == cesn == 1 coeVerfers, coeDigers = coeMgr.rotate(coeVerfers[0].qb64) coeSerder = rotate(pre=coeKever.prefixer.qb64, keys=[coeVerfers[0].qb64], dig=coeKever.serder.diger.qb64, nxt=Nexter(digs=[coeDigers[0].qb64]).qb64, sn=csn) coe_event_digs.append(coeSerder.dig) # sign serialization sigers = coeMgr.sign(coeSerder.raw, verfers=coeVerfers) # returns sigers # create serialized message cmsg = messagize(coeSerder, sigers) assert cmsg == bytearray(b'{"v":"KERI10JSON000122_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBO' b'CJnPYabcas","s":"1","t":"rot","p":"Ey2pXEnaoQVwxA4jB6k0QH5G2Us-0' b'juFL5hOAHAwIEkc","kt":"1","k":["D-HwiqmaETxls3vAVSh0xpXYTs94NUJX' b'6juupWj_EgsA"],"n":"ED6lKZwg-BWl_jlCrjosQkOEhqKD4BJnlqYqWmhqPhaU' b'","wt":"0","wr":[],"wa":[],"a":[]}-AABAAsDhyw43CAo29zyTZ7WIuztBG' b'L3WELM78qSwaEYh8NzwNAPqDtiuL-QmKd22om1qYGDU7cuFM-AlTKaFjsVOzBg') # update controller's key event verifier state coeKevery.processOne(ims=bytearray(cmsg)) # make copy # verify controller's copy of controller's event stream is updated assert coeKever.sn == csn assert coeKever.serder.diger.qb64 == coeSerder.dig # simulate send message from controller to validator valKevery.process(ims=cmsg) # verify validator's copy of controller's event stream is updated assert coeK.sn == csn assert coeK.serder.diger.qb64 == coeSerder.dig # create receipt of controller's rotation # create seal of validator's last establishment event seal = SealEvent(i=valpre, s="{:x}".format(valKever.lastEst.s), d=valKever.lastEst.d) # create validator receipt reserder = chit(pre=coeK.prefixer.qb64, sn=coeK.sn, dig=coeK.serder.diger.qb64, seal=seal) # sign controller's event not receipt # look up event to sign from validator's kever for controller coeRotDig = bytes(valKevery.db.getKeLast(key=snKey(pre=coepre, sn=csn))) assert coeRotDig == coeK.serder.diger.qb64b == b'EO7V6wDClWWiN_7sfGDTD8KsfRQaHyap6fz_O4CYvsek' coeRotRaw = bytes(valKevery.db.getEvt(key=dgKey(pre=coepre, dig=coeRotDig))) assert coeRotRaw == (b'{"v":"KERI10JSON000122_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBOCJnPYabcas",' b'"s":"1","t":"rot","p":"Ey2pXEnaoQVwxA4jB6k0QH5G2Us-0juFL5hOAHAwIEkc","kt":"1' b'","k":["D-HwiqmaETxls3vAVSh0xpXYTs94NUJX6juupWj_EgsA"],"n":"ED6lKZwg-BWl_jlC' b'rjosQkOEhqKD4BJnlqYqWmhqPhaU","wt":"0","wr":[],"wa":[],"a":[]}') sigers = valMgr.sign(ser=coeRotRaw, verfers=valVerfers) # validator create receipt message vmsg = messagize(reserder, sigers) assert vmsg == bytearray(b'{"v":"KERI10JSON000105_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBO' b'CJnPYabcas","s":"1","t":"vrc","d":"EO7V6wDClWWiN_7sfGDTD8KsfRQaH' b'yap6fz_O4CYvsek","a":{"i":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDy' b'VSOXYW0","s":"0","d":"ElsHFkbZQjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3Wev' b'cE"}}-AABAAjVFBjhbM2RdHKEk2rtHA0tXMe0iswn6IS5ShALtR3JHMz-NePCN_f' b'lUEUbV2F22CGRgmnCe71n42ywWyzsFmDg') # validator process own receipt in own kevery so have copy in own log valKevery.processOne(ims=bytearray(vmsg)) # make copy # Simulate send to controller of validator's receipt of controller's rotation message coeKevery.process(ims=vmsg) # controller process validator's incept and receipt # check if receipt quadruple from validator in receipt database result = coeKevery.db.getVrcs(key=dgKey(pre=coeKever.prefixer.qb64, dig=coeKever.serder.diger.qb64)) assert bytes(result[0]) == (valKever.prefixer.qb64b + Seqner(sn=valKever.sn).qb64b + valKever.serder.diger.qb64b + sigers[0].qb64b) assert bytes(result[0]) == (b'EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDyVSOXYW00AAAAAAAAAAAAAAAAAAAAAAAElsHFkbZ' b'QjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3WevcEAAjVFBjhbM2RdHKEk2rtHA0tXMe0iswn6IS5ShAL' b'tR3JHMz-NePCN_flUEUbV2F22CGRgmnCe71n42ywWyzsFmDg') # Next Event 2 Controller Interaction csn += 1 # do not increment esn assert csn == 2 assert cesn == 1 coeSerder = interact(pre=coeKever.prefixer.qb64, dig=coeKever.serder.diger.qb64, sn=csn) coe_event_digs.append(coeSerder.dig) # sign serialization sigers = coeMgr.sign(coeSerder.raw, verfers=coeVerfers) # create msg cmsg = messagize(coeSerder, sigers) assert cmsg == bytearray(b'{"v":"KERI10JSON000098_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBO' b'CJnPYabcas","s":"2","t":"ixn","p":"EO7V6wDClWWiN_7sfGDTD8KsfRQaH' b'yap6fz_O4CYvsek","a":[]}-AABAAstaU9Hu1ti8erlnFwEdCrXWkkkW_ydYgrr' b'ryB6EtEOrWY_tQh5jZLGRWrClefeX6AfDDw7JS5JY15n8_ueJWBQ') # update controller's key event verifier state coeKevery.processOne(ims=bytearray(cmsg)) # make copy # verify controller's copy of controller's event stream is updated assert coeKever.sn == csn assert coeKever.serder.diger.qb64 == coeSerder.dig # simulate send message from controller to validator valKevery.process(ims=cmsg) # verify validator's copy of controller's event stream is updated assert coeK.sn == csn assert coeK.serder.diger.qb64 == coeSerder.dig # create receipt of controller's interaction # create seal of validator's last est event seal = SealEvent(i=valpre, s="{:x}".format(valKever.lastEst.s), d=valKever.lastEst.d) # create validator receipt reserder = chit(pre=coeK.prefixer.qb64, sn=coeK.sn, dig=coeK.serder.diger.qb64, seal=seal) # sign controller's event not receipt # look up event to sign from validator's kever for controller coeIxnDig = bytes(valKevery.db.getKeLast(key=snKey(pre=coepre, sn=csn))) assert coeIxnDig == coeK.serder.diger.qb64b == b'EuCLxtdKdRgzzgBnPhTwFKz36u58DqQyMqhX5CUrurPE' coeIxnRaw = bytes(valKevery.db.getEvt(key=dgKey(pre=coepre, dig=coeIxnDig))) assert coeIxnRaw == (b'{"v":"KERI10JSON000098_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBOCJnPYabcas",' b'"s":"2","t":"ixn","p":"EO7V6wDClWWiN_7sfGDTD8KsfRQaHyap6fz_O4CYvsek","a":[]}') sigers = valMgr.sign(ser=coeIxnRaw, verfers=valVerfers) # create receipt message vmsg = messagize(reserder, sigers) assert vmsg == bytearray(b'{"v":"KERI10JSON000105_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBO' b'CJnPYabcas","s":"2","t":"vrc","d":"EuCLxtdKdRgzzgBnPhTwFKz36u58D' b'qQyMqhX5CUrurPE","a":{"i":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDy' b'VSOXYW0","s":"0","d":"ElsHFkbZQjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3Wev' b'cE"}}-AABAAboeSfNNgX04wuUrQp-3eY0oUzcLYnLUmtqYETBZqXEL97pjSjmm81' b'1KzCRu2cnSHVlKqzIaEBaXyBpWBDexLBQ') # ------------------------------END CONVERTED CODE------------------------------ # validator process own receipt in own kevery so have copy in own log valKevery.processOne(ims=bytearray(vmsg)) # make copy # Simulate send to controller of validator's receipt of controller's rotation message coeKevery.process(ims=vmsg) # controller process validator's incept and receipt # check if receipt quadruple from validator in receipt database result = coeKevery.db.getVrcs(key=dgKey(pre=coeKever.prefixer.qb64, dig=coeKever.serder.diger.qb64)) assert bytes(result[0]) == (valKever.prefixer.qb64b + Seqner(sn=valKever.sn).qb64b + valKever.serder.diger.qb64b + sigers[0].qb64b) assert bytes(result[0]) == (b'EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDyVSOXYW00AAAAAAAAAAAAAAAAAAAAAAAElsHFkbZ' b'QjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3WevcEAAboeSfNNgX04wuUrQp-3eY0oUzcLYnLUmtqYETB' b'ZqXEL97pjSjmm811KzCRu2cnSHVlKqzIaEBaXyBpWBDexLBQ') # verify final controller event state assert coeKever.sn == coeK.sn == csn db_digs = [bytes(v).decode("utf-8") for v in coeKever.baser.getKelIter(coepre)] assert len(db_digs) == len(coe_event_digs) == csn + 1 assert db_digs == coe_event_digs == ['Ey2pXEnaoQVwxA4jB6k0QH5G2Us-0juFL5hOAHAwIEkc', 'EO7V6wDClWWiN_7sfGDTD8KsfRQaHyap6fz_O4CYvsek', 'EuCLxtdKdRgzzgBnPhTwFKz36u58DqQyMqhX5CUrurPE'] db_digs = [bytes(v).decode("utf-8") for v in valKever.baser.getKelIter(coepre)] assert len(db_digs) == len(coe_event_digs) == csn + 1 assert db_digs == coe_event_digs # verify final validator event state assert valKever.sn == valK.sn == vsn db_digs = [bytes(v).decode("utf-8") for v in valKever.baser.getKelIter(valpre)] assert len(db_digs) == len(val_event_digs) == vsn + 1 assert db_digs == val_event_digs == ['ElsHFkbZQjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3WevcE'] db_digs = [bytes(v).decode("utf-8") for v in coeKever.baser.getKelIter(valpre)] assert len(db_digs) == len(val_event_digs) == vsn + 1 assert db_digs == val_event_digs assert not os.path.exists(valKevery.db.path) assert not os.path.exists(coeKever.baser.path)
def test_direct_mode_with_manager(): """ Test direct mode with transferable validator event receipts """ # manual process to generate a list of secrets # root = pysodium.randombytes(pysodium.crypto_pwhash_SALTBYTES) # secrets = generateSecrets(root=root, count=8) # Direct Mode initiated by coe is controller, val is validator # but goes both ways once initiated. # set of secrets (seeds for private keys) coeSalt = Salter(raw=b'0123456789abcdea').qb64 # set of secrets (seeds for private keys) valSalt = Salter(raw=b'1123456789abcdea').qb64 with openDB("controller") as coeLogger, openDB( "validator") as valLogger, openKS( name="controller") as coeKpr, openKS( name="validator") as valKpr: # Init key pair manager coeMgr = Manager(keeper=coeKpr, salt=coeSalt) coeVerfers, coeDigers, cst, nst = coeMgr.incept(icount=1, ncount=1) # init Keverys coeKevery = Kevery(db=coeLogger) valKevery = Kevery(db=valLogger) coe_event_digs = [ ] # list of controller's own event log digs to verify against database val_event_digs = [ ] # list of validator's own event log digs to verify against database # init sequence numbers for both controller and validator csn = cesn = 0 # sn and last establishment sn = esn vsn = vesn = 0 # sn and last establishment sn = esn # Controller Event 0 Inception Transferable (nxt digest not empty) coeSerder = incept(keys=[coeVerfers[0].qb64], nxt=Nexter(digs=[coeDigers[0].qb64]).qb64, code=MtrDex.Blake3_256) assert csn == int(coeSerder.ked["s"], 16) == 0 coepre = coeSerder.ked["i"] coe_event_digs.append(coeSerder.dig) # sign serialization sigers = coeMgr.sign(ser=coeSerder.raw, verfers=coeVerfers) # create serialized message cmsg = messagize(coeSerder, sigers=sigers) # create own Controller Kever in Controller's Kevery coeKevery.processOne(ims=bytearray(cmsg)) # send copy of cmsg coeKever = coeKevery.kevers[coepre] assert coeKever.prefixer.qb64 == coepre # Validator Event 0 Inception Transferable (nxt digest not empty) # Init key pair manager valMgr = Manager(keeper=valKpr, salt=valSalt) valVerfers, valDigers, cst, nst = valMgr.incept(icount=1, ncount=1) valSerder = incept(keys=[valVerfers[0].qb64], nxt=Nexter(digs=[valDigers[0].qb64]).qb64, code=MtrDex.Blake3_256) assert vsn == int(valSerder.ked["s"], 16) == 0 valpre = valSerder.ked["i"] val_event_digs.append(valSerder.dig) # sign serialization sigers = valMgr.sign(valSerder.raw, verfers=valVerfers) # return Siger if index # create serialized message vmsg = messagize(valSerder, sigers=sigers) # create own Validator Kever in Validator's Kevery valKevery.processOne(ims=bytearray(vmsg)) # send copy of vmsg valKever = valKevery.kevers[valpre] assert valKever.prefixer.qb64 == valpre # simulate sending of controller's inception message to validator valKevery.process(ims=bytearray(cmsg)) # make copy of msg assert coepre in valKevery.kevers # creates Kever for controller in validator's .kevers # create receipt of controller's inception # create seal of validator's last establishment event seal = SealEvent(i=valpre, s="{:x}".format(valKever.lastEst.s), d=valKever.lastEst.d) coeK = valKevery.kevers[ coepre] # lookup coeKever from validator's .kevers # create validator receipt reserder = chit(pre=coeK.prefixer.qb64, sn=coeK.sn, dig=coeK.serder.diger.qb64, seal=seal) # Validate receipt # sign controller's event not receipt # look up event to sign from validator's kever for coe coeIcpDig = bytes( valKevery.db.getKeLast(key=snKey(pre=coepre, sn=csn))) assert coeIcpDig == coeK.serder.diger.qb64b coeIcpRaw = bytes( valKevery.db.getEvt(key=dgKey(pre=coepre, dig=coeIcpDig))) counter = Counter(CtrDex.ControllerIdxSigs) assert counter.qb64 == '-AAB' sigers = valMgr.sign(ser=coeIcpRaw, verfers=valVerfers) # return Siger if index # process own validator receipt in validator's Kevery so have copy in own log rmsg = messagize(reserder, sigers=sigers) valKevery.processOne(ims=bytearray(rmsg)) # process copy of rmsg # attach receipt message to existing message with validators inception message # simulate streaming. validator first sends it's inception event, then sends a receipt to controller vmsg.extend(rmsg) # Simulate sending validator's inception event and receipt of controller's inception message to controller coeKevery.process( ims=vmsg) # controller process validator's inception and receipt # check if validator's Kever in controller's .kevers assert valpre in coeKevery.kevers # check if receipt quadruple from validator in receipt database result = coeKevery.db.getVrcs(key=dgKey( pre=coeKever.prefixer.qb64, dig=coeKever.serder.diger.qb64)) assert bytes( result[0]) == (valKever.prefixer.qb64b + Seqner(sn=valKever.sn).qb64b + valKever.serder.diger.qb64b + sigers[0].qb64b) # create receipt to escrow use invalid digest and sequence number so not in controller's db fake = reserder.dig # some other digest reserder = chit(pre=coeK.prefixer.qb64, sn=10, dig=fake, seal=seal) # sign event not receipt sigers = valMgr.sign(ser=coeIcpRaw, verfers=valVerfers) # return Siger if index # create receipt message vmsg = messagize(reserder, sigers=sigers) coeKevery.process( ims=vmsg) # controller process the escrow receipt from validator # check if receipt quadruple in escrow database result = coeKevery.db.getVres( key=snKey(pre=coeKever.prefixer.qb64, sn=10)) assert bytes( result[0]) == (fake.encode("utf-8") + valKever.prefixer.qb64b + Seqner(sn=valKever.sn).qb64b + valKever.serder.diger.qb64b + sigers[0].qb64b) # Send receipt from controller to validator # create receipt of validator's inception # create seal of controller's last establishment event seal = SealEvent(i=coepre, s="{:x}".format(coeKever.lastEst.s), d=coeKever.lastEst.d) valK = coeKevery.kevers[ valpre] # lookup valKever from controller's .kevers # create validator receipt reserder = chit(pre=valK.prefixer.qb64, sn=valK.sn, dig=valK.serder.diger.qb64, seal=seal) # sign validator's event not receipt # look up event to sign from controller's kever for validator valIcpDig = bytes( coeKevery.db.getKeLast(key=snKey(pre=valpre, sn=vsn))) assert valIcpDig == valK.serder.diger.qb64b valIcpRaw = bytes( coeKevery.db.getEvt(key=dgKey(pre=valpre, dig=valIcpDig))) counter = Counter(CtrDex.ControllerIdxSigs) assert counter.qb64 == '-AAB' sigers = coeMgr.sign(ser=valIcpRaw, verfers=coeVerfers) # return Siger if index # create receipt message cmsg = messagize(reserder, sigers=sigers) # controller process own receipt in own Kevery so have copy in own log coeKevery.processOne(ims=bytearray(cmsg)) # make copy # Simulate sending controller's receipt of validator's inception message to validator valKevery.process( ims=cmsg) # controller process validator's inception and receipt # check if receipt quadruple from controller in validator's receipt database result = valKevery.db.getVrcs(key=dgKey( pre=valKever.prefixer.qb64, dig=valKever.serder.diger.qb64)) assert bytes( result[0]) == (coeKever.prefixer.qb64b + Seqner(sn=coeKever.sn).qb64b + coeKever.serder.diger.qb64b + sigers[0].qb64b) # Controller Event 1 Rotation Transferable csn += 1 cesn += 1 assert csn == cesn == 1 coeVerfers, coeDigers, cst, nst = coeMgr.rotate(pre=coeVerfers[0].qb64) coeSerder = rotate(pre=coeKever.prefixer.qb64, keys=[coeVerfers[0].qb64], dig=coeKever.serder.diger.qb64, nxt=Nexter(digs=[coeDigers[0].qb64]).qb64, sn=csn) coe_event_digs.append(coeSerder.dig) # sign serialization sigers = coeMgr.sign(coeSerder.raw, verfers=coeVerfers) # returns sigers # create serialized message cmsg = messagize(coeSerder, sigers=sigers) # update controller's key event verifier state coeKevery.processOne(ims=bytearray(cmsg)) # make copy # verify controller's copy of controller's event stream is updated assert coeKever.sn == csn assert coeKever.serder.diger.qb64 == coeSerder.dig # simulate send message from controller to validator valKevery.process(ims=cmsg) # verify validator's copy of controller's event stream is updated assert coeK.sn == csn assert coeK.serder.diger.qb64 == coeSerder.dig # create receipt of controller's rotation # create seal of validator's last establishment event seal = SealEvent(i=valpre, s="{:x}".format(valKever.lastEst.s), d=valKever.lastEst.d) # create validator receipt reserder = chit(pre=coeK.prefixer.qb64, sn=coeK.sn, dig=coeK.serder.diger.qb64, seal=seal) # sign controller's event not receipt # look up event to sign from validator's kever for controller coeRotDig = bytes( valKevery.db.getKeLast(key=snKey(pre=coepre, sn=csn))) assert coeRotDig == coeK.serder.diger.qb64b coeRotRaw = bytes( valKevery.db.getEvt(key=dgKey(pre=coepre, dig=coeRotDig))) sigers = valMgr.sign(ser=coeRotRaw, verfers=valVerfers) # validator create receipt message vmsg = messagize(reserder, sigers=sigers) # validator process own receipt in own kevery so have copy in own log valKevery.processOne(ims=bytearray(vmsg)) # make copy # Simulate send to controller of validator's receipt of controller's rotation message coeKevery.process( ims=vmsg) # controller process validator's incept and receipt # check if receipt quadruple from validator in receipt database result = coeKevery.db.getVrcs(key=dgKey( pre=coeKever.prefixer.qb64, dig=coeKever.serder.diger.qb64)) assert bytes( result[0]) == (valKever.prefixer.qb64b + Seqner(sn=valKever.sn).qb64b + valKever.serder.diger.qb64b + sigers[0].qb64b) # Next Event 2 Controller Interaction csn += 1 # do not increment esn assert csn == 2 assert cesn == 1 coeSerder = interact(pre=coeKever.prefixer.qb64, dig=coeKever.serder.diger.qb64, sn=csn) coe_event_digs.append(coeSerder.dig) # sign serialization sigers = coeMgr.sign(coeSerder.raw, verfers=coeVerfers) # create msg cmsg = messagize(coeSerder, sigers=sigers) # update controller's key event verifier state coeKevery.processOne(ims=bytearray(cmsg)) # make copy # verify controller's copy of controller's event stream is updated assert coeKever.sn == csn assert coeKever.serder.diger.qb64 == coeSerder.dig # simulate send message from controller to validator valKevery.process(ims=cmsg) # verify validator's copy of controller's event stream is updated assert coeK.sn == csn assert coeK.serder.diger.qb64 == coeSerder.dig # create receipt of controller's interaction # create seal of validator's last est event seal = SealEvent(i=valpre, s="{:x}".format(valKever.lastEst.s), d=valKever.lastEst.d) # create validator receipt reserder = chit(pre=coeK.prefixer.qb64, sn=coeK.sn, dig=coeK.serder.diger.qb64, seal=seal) # sign controller's event not receipt # look up event to sign from validator's kever for controller coeIxnDig = bytes( valKevery.db.getKeLast(key=snKey(pre=coepre, sn=csn))) assert coeIxnDig == coeK.serder.diger.qb64b coeIxnRaw = bytes( valKevery.db.getEvt(key=dgKey(pre=coepre, dig=coeIxnDig))) sigers = valMgr.sign(ser=coeIxnRaw, verfers=valVerfers) # create receipt message vmsg = messagize(reserder, sigers=sigers) # validator process own receipt in own kevery so have copy in own log valKevery.processOne(ims=bytearray(vmsg)) # make copy # Simulate send to controller of validator's receipt of controller's rotation message coeKevery.process( ims=vmsg) # controller process validator's incept and receipt # check if receipt quadruple from validator in receipt database result = coeKevery.db.getVrcs(key=dgKey( pre=coeKever.prefixer.qb64, dig=coeKever.serder.diger.qb64)) assert bytes( result[0]) == (valKever.prefixer.qb64b + Seqner(sn=valKever.sn).qb64b + valKever.serder.diger.qb64b + sigers[0].qb64b) # verify final controller event state assert coeKever.sn == coeK.sn == csn db_digs = [ bytes(v).decode("utf-8") for v in coeKever.baser.getKelIter(coepre) ] assert len(db_digs) == len(coe_event_digs) == csn + 1 assert db_digs == coe_event_digs db_digs = [ bytes(v).decode("utf-8") for v in valKever.baser.getKelIter(coepre) ] assert len(db_digs) == len(coe_event_digs) == csn + 1 assert db_digs == coe_event_digs # verify final validator event state assert valKever.sn == valK.sn == vsn db_digs = [ bytes(v).decode("utf-8") for v in valKever.baser.getKelIter(valpre) ] assert len(db_digs) == len(val_event_digs) == vsn + 1 assert db_digs == val_event_digs db_digs = [ bytes(v).decode("utf-8") for v in coeKever.baser.getKelIter(valpre) ] assert len(db_digs) == len(val_event_digs) == vsn + 1 assert db_digs == val_event_digs assert not os.path.exists(valKevery.db.path) assert not os.path.exists(coeKever.baser.path)
def test_weighted(): """ Test multisig with weighted threshold """ wesSalt = coring.Salter(raw=b'0123456789abcdef').qb64 # init wes Salter # init event DB and keep DB with dbing.openDB(name="wes") as wesDB, keeping.openKS( name="wes") as wesKS: # Init key pair manager wesMgr = keeping.Manager(keeper=wesKS, salt=wesSalt) # Init Kevery with event DB wesKvy = eventing.Kevery(db=wesDB) # create inception event for Wes with 3 keys each in incept and next sets # defaults are algo salty and rooted sith = ["1/2", "1/2", "1/2"] # 2 of 3 but with weighted threshold nxtsith = ["1/2", "1/2", "1/2"] verfers, digers, cst, nst = wesMgr.incept(icount=3, isith=sith, ncount=3, nsith=nxtsith, stem='wes', temp=True) assert cst == nst == sith wesSrdr = eventing.incept( keys=[verfer.qb64 for verfer in verfers], sith=sith, nxt=coring.Nexter(sith=nxtsith, digs=[diger.qb64 for diger in digers]).qb64, code=coring.MtrDex.Blake3_256) wesPre = wesSrdr.ked["i"] wesMgr.move(old=verfers[0].qb64, new=wesPre) # move key pair label to prefix sigers = wesMgr.sign(ser=wesSrdr.raw, verfers=verfers) msg = bytearray(wesSrdr.raw) counter = coring.Counter(coring.CtrDex.ControllerIdxSigs, count=len(sigers)) msg.extend(counter.qb64b) for siger in sigers: msg.extend(siger.qb64b) assert msg == bytearray( b'{"v":"KERI10JSON00015b_","i":"EX0WJtv6vc0IWzOqa92Pv9v9pgs1f0BfIV' b'rSch648Zf0","s":"0","t":"icp","kt":["1/2","1/2","1/2"],"k":["DK4' b'OJI8JOr6oEEUMeSF_X-SbKysfwpKwW-ho5KARvH5c","D1RZLgYke0GmfZm-CH8A' b'sW4HoTU4m-2mFgu8kbwp8jQU","DBVwzum-jPfuUXUcHEWdplB4YcoL3BWGXK0TM' b'oF_NeFU"],"n":"EhJGhyJQTpSlZ9oWfQT-lHNl1woMazLC42O89fRHocTI","bt' b'":"0","b":[],"c":[],"a":[]}-AADAAKWMK8k4Po2A0rBrUBjBom73DfTCNg_b' b'iwR-_LWm6DMHZHGDfCuOmEyR8sEdp7cPxhsavq4istIZ_QQ42yyUcDAABeTClYkN' b'-yjbW3Kz3ot6MvAt5Se-jmcjhu-Cfsv4m_GKYgc_qwel1SbAcqF0TiY0EHFdjNKv' b'Ikg3q19KlhSbuBgACA6QMnsnZuy66xrZVg3c84mTodZCEvOFrAIDQtm8jeXeCTg7' b'yFauoQECZyNIlUnnxVHuk2_Fqi5xK_Lu9Pt76Aw') # apply msg to Wes's Kevery wesKvy.process(ims=bytearray(msg)) # process local copy of msg wesK = wesKvy.kevers[wesPre] # kever created so event was validated assert wesK.prefixer.qb64 == wesPre assert wesK.serder.diger.qb64 == wesSrdr.dig # key state updated so event was validated # create interaction event for Wes wesSrdr = eventing.interact(pre=wesK.prefixer.qb64, dig=wesK.serder.diger.qb64, sn=wesK.sn + 1, data=[]) sigers = wesMgr.sign(ser=wesSrdr.raw, verfers=wesK.verfers) msg = bytearray(wesSrdr.raw) counter = coring.Counter(coring.CtrDex.ControllerIdxSigs, count=len(sigers)) msg.extend(counter.qb64b) for siger in sigers: msg.extend(siger.qb64b) assert msg == bytearray( b'{"v":"KERI10JSON000098_","i":"EX0WJtv6vc0IWzOqa92Pv9v9pgs1f0BfIV' b'rSch648Zf0","s":"1","t":"ixn","p":"EInuqF20s1O0JhVJaOuKCZZDDyw6D' b'YxATbiuC5Hv3WXs","a":[]}-AADAAmg8UoBCTlnENiySBpn6j7mR1w0gdkfC8Ai' b'aYL5NCFfePp5ZK3CmnP7oQdj_ggiNp9FZNE0Q69A99wNK5FrwzDgABQZZunmJr2X' b'3BYgX34-6SOpzkHZQS99ZL0tDsDyUIL7jZhD1e1203Fh6BnkDjzum2au2dGHJcIP' b'giFGfDsrI5DwACwwYqqYYdEXeLpx_o6LTSKU-Fz_WF2gebP9Z72bZ75atg7_ZM3H' b'g6hhztstGt8TthRQ0TJn6rkvatkbn6yzRjBw') # apply msg to wes's Kevery wesKvy.process(ims=bytearray(msg)) # process local copy of msg assert wesK.serder.diger.qb64 == wesSrdr.dig # key state updated so event was validated # Create rotation event for Wes # get current keys as verfers and next digests as digers nxtsith = ["1/2", "1/2", "1/2"] # 2 of 3 but with weighted threshold verfers, digers, cst, nst = wesMgr.rotate(pre=wesPre, count=3, sith=nxtsith, temp=True) assert nst == nxtsith wesSrdr = eventing.rotate( pre=wesK.prefixer.qb64, keys=[verfer.qb64 for verfer in verfers], sith=sith, dig=wesK.serder.diger.qb64, nxt=coring.Nexter(sith=nxtsith, digs=[diger.qb64 for diger in digers]).qb64, sn=wesK.sn + 1, data=[]) sigers = wesMgr.sign(ser=wesSrdr.raw, verfers=verfers) msg = bytearray(wesSrdr.raw) counter = coring.Counter(coring.CtrDex.ControllerIdxSigs, count=len(sigers)) msg.extend(counter.qb64b) for siger in sigers: msg.extend(siger.qb64b) assert bytearray( b'{"v":"KERI10JSON000190_","i":"EX0WJtv6vc0IWzOqa92Pv9v9pgs1f0BfIV' b'rSch648Zf0","s":"2","t":"rot","p":"EznUtmH2XJF04dyqpUHLzwkNgwk6D' b'jbDFbjXVI3UJLe0","kt":["1/2","1/2","1/2"],"k":["DeonYM2bKnAwp6VZ' b'cuCXdX72kNFw56czlZ_Tc7XHHVGI","DQghKIy-2do9OkweSgazh3Ql1vCOt5bnc' b'5QF8x50tRoU","DNAUn-5dxm6b8Njo01O0jlStMRCjo9FYQA2mfqFW1_JA"],"n"' b':"EX5fxvjOg5VuDboWbqnTjTPpXa3nNIm99hlsB1EmhTo8","bt":"0","br":[]' b',"ba":[],"a":[]}-AADAAahiASmZJY2KjXKRvVwdRSESmesNsfxUnOQ6buEk6S-' b'4rxRdztde_6_CX2Q4MyUSErHMtmLhesrKjenPBairZAQABbnbZ3lOKcKCMmLYtpT' b'hDEm-tRTsnEh_8loXpA6G3q1oJZNeVJphJjPm2HR0mX2ptC2DEt6p9i4GH1Y56HY' b'TsAgACqF6e_29QkxgXvqDLEUnAIB_XJ7SUhDNpt3cYk6pF1-ULgrhGdZLS1h-c_V' b'KpKITRx3ZTvme7sKbvr_NfR-0ECg') # apply msg to Wes's Kevery wesKvy.process(ims=bytearray(msg)) # process local copy of msg assert wesK.serder.diger.qb64 == wesSrdr.dig # key state updated so event was validated # Create rotation event for Wes # get current keys as verfers and next digests as digers sith = nxtsith # rotate so nxtsith is now current sith and need new nextsith # 2 of first 3 and 1 of last 2 nxtsith = [["1/2", "1/2", "1/2"], ["1/1", "1/1"]] verfers, digers, cst, nst = wesMgr.rotate(pre=wesPre, count=5, sith=nxtsith, temp=True) assert cst == sith assert nst == nxtsith wesSrdr = eventing.rotate( pre=wesK.prefixer.qb64, keys=[verfer.qb64 for verfer in verfers], sith=sith, dig=wesK.serder.diger.qb64, nxt=coring.Nexter(sith=nxtsith, digs=[diger.qb64 for diger in digers]).qb64, sn=wesK.sn + 1, data=[]) sigers = wesMgr.sign(ser=wesSrdr.raw, verfers=verfers) msg = bytearray(wesSrdr.raw) counter = coring.Counter(coring.CtrDex.ControllerIdxSigs, count=len(sigers)) msg.extend(counter.qb64b) for siger in sigers: msg.extend(siger.qb64b) assert msg == bytearray( b'{"v":"KERI10JSON000190_","i":"EX0WJtv6vc0IWzOqa92Pv9v9pgs1f0BfIV' b'rSch648Zf0","s":"3","t":"rot","p":"EK1BTah7lTyaaol7sLdg9uObplAjP' b'o_JOz1m4WPaLJBw","kt":["1/2","1/2","1/2"],"k":["D7WWKDLVwYxYMLAj' b'DceIEs66xPMY4Afzx-RQw2x0mQzI","Dmg6Aah8qyKKDiQyNXTiO71QJwizjZfGM' b'61BA-s0A5F4","DS3fhKpvPCDL5WmfN4_PkmJMMsSCdRTxG24OQuf_EmHQ"],"n"' b':"EcM4iw7fElXWhad8V-za4Px7nBKjndxoh3XZRkohghKY","bt":"0","br":[]' b',"ba":[],"a":[]}-AADAAl6FtC6Ynm8RAoa2utkIqJX5xW1ZxIkEH7I_MUCXL0p' b'OUT8P0lCgPzn9dvmUagHbzZ4GIwOBqGI-lQJbeESnZBQAB_nJLQJTf9t1NJxNoP5' b'gve9QEQbHFkn2aX6O78_bzOGUf01y8KSl-ugi0_B9-w0dk4J7gjYbv7RhG-TmFPE' b'mEAAACEpJiOTGarwK4jWZ9ZKue05uYPDW5wp4HC8VIt6R93h7WHLqqLVH1m3n5jd' b'AkiM4RFdhUqBwt-jKBfHQmVoBBCA') # apply msg to Wes's Kevery wesKvy.process(ims=bytearray(msg)) # process local copy of msg assert wesK.serder.diger.qb64 == wesSrdr.dig # key state updated so event was validated # Create rotation event for Wes # get current keys as verfers and next digests as digers sith = nxtsith # rotate so nxtsith is now current sith and need new nextsith # 2 of first 3 and 1 of last 2 nxtsith = [["1/2", "1/2", "1/2"], ["1/1", "1/1"]] verfers, digers, cst, nst = wesMgr.rotate(pre=wesPre, count=5, sith=nxtsith, temp=True) assert cst == nst == nxtsith wesSrdr = eventing.rotate( pre=wesK.prefixer.qb64, keys=[verfer.qb64 for verfer in verfers], sith=sith, dig=wesK.serder.diger.qb64, nxt=coring.Nexter(sith=nxtsith, digs=[diger.qb64 for diger in digers]).qb64, sn=wesK.sn + 1, data=[]) sigers = wesMgr.sign(ser=wesSrdr.raw, verfers=verfers) msg = bytearray(wesSrdr.raw) counter = coring.Counter(coring.CtrDex.ControllerIdxSigs, count=len(sigers)) msg.extend(counter.qb64b) for siger in sigers: msg.extend(siger.qb64b) assert msg == bytearray( b'{"v":"KERI10JSON0001fe_","i":"EX0WJtv6vc0IWzOqa92Pv9v9pgs1f0BfIV' b'rSch648Zf0","s":"4","t":"rot","p":"EVfMO5GK8tg4KE8XCelX1s_TG_Hqr' b'_kzb3ghIBYvzC6U","kt":[["1/2","1/2","1/2"],["1/1","1/1"]],"k":["' b'DToUWoemnetqJoLFIqDI7lxIJEfF0W7xG5ZlqAseVUQc","Drz-IZjko61q-sPMD' b'IW6n-0NGFubbXiZhzWZrO_BZ0Wc","DiGwL3hjQqiUgQlFPeA6kRR1EBXX0vSLm9' b'b6QhPS8IkQ","Dxj5pcStgZ6CbQ2YktNaj8KLE_g9YAOZF6AL9fyLcWQw","DE5z' b'r5eH8EUVQXyAaxWfQUWkGCId-QDCvvxMT77ibj2Q"],"n":"E3in3Z14va0kk4Wq' b'd3vcCAojKNtQq7ZTrQaavR8x0yu4","bt":"0","br":[],"ba":[],"a":[]}-A' b'AFAAdxx4UfoNYdXckLY9nSYvqYLJzvIRhixshBbqkQ6uwvqaVmwPqmvck0V9xl5x' b'3ssVclasm8Ga3FTkcbmbV2jXDgABBWUhku-qDq8wYn5XMQuKzidAsA6bth8-EsCx' b'9WwTIqWBR-AecW-3X1haAyJshqplDsS9MnZfVgmSHokwdLnRCQACp2tB0pFRv_C7' b'nUXPf9rFKvlWUllrsY6Y1_F4bAOMvyCU-PES4HwyUQv3kQnLxEqnf0fbOYdHJNGo' b'sXi-UqL9BAADW89YpsS5m3IASAtXvXEPez-0y11JRP8bAiUUBdIxGB9ms79jPZnQ' b'tF3045byf3m0Dvi91Y9d4sh-xkzZ15v9DAAE6QR9qNXnHXLisg4Mbadav9AdMjS4' b'uz6jNG1AL6UCa7P90Y53v1V6VRaOPu_RTWXcXYRGqA9BHJ2rLNYWJTJTBA') # apply msg to Wes's Kevery wesKvy.process(ims=bytearray(msg)) # process local copy of msg assert wesK.serder.diger.qb64 == wesSrdr.dig # key state updated so event was validated assert not os.path.exists(wesKS.path) assert not os.path.exists(wesDB.path) """End Test"""
def test_issuer(): with dbing.openDB(name="bob") as db, keeping.openKS(name="bob") as kpr: hab = buildHab(db, kpr) # setup issuer with defaults for allowBackers, backers and estOnly issuer = Issuer(hab=hab, name="test") assert issuer.incept == (b'{"v":"KERI10JSON0000a9_","i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkD' b'GeLWHb9vSY","ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY",' b'"s":"0","t":"vcp","c":[],"bt":"0","b":[]}-eABEaKJ0FoLxO1TYmyuprg' b'uKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAAAAAAAAAAAAAAQEoDaZfC2yqtPwKJ' b'BrhAGzP20SOslMZ-eQ7hAbl3w4JP0') assert issuer.ianchor == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"1","t":"ixn","p":"Eg3wsIOW3RdCqhcG4xZ4uZhTA_qTE' b'24DoLeyjFBB8rks","a":["EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9' b'vSY","0","EvpB-_BWD7tOhLI0cDyEQbziBt6IMyQnkrh0booR4vhg"]}-AABAAw' b'3jupSvehfh-Ow0v_E3Er49HUvwQp0Qa0P9KYNdaf9ihtzZU0bJtrbIW1z6eMoR3B' b'52SDSxw9gfMmqlZRZfaBQ') # ensure the digest in the seal from the key event matches the transacript event digest ser = Serder(raw=issuer.incept) assert ser.diger.qb64 == 'EvpB-_BWD7tOhLI0cDyEQbziBt6IMyQnkrh0booR4vhg' tevt, kevt = issuer.rotate(adds=["EqoNZAX5Lu8RuHzwwyn5tCZTe-mDBq5zusCrRo5TDugs"]) assert tevt == (b'{"v":"KERI10JSON0000d8_","i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkD' b'GeLWHb9vSY","p":"EvpB-_BWD7tOhLI0cDyEQbziBt6IMyQnkrh0booR4vhg","' b's":"1","t":"vrt","bt":"1","br":[],"ba":["EqoNZAX5Lu8RuHzwwyn5tCZ' b'Te-mDBq5zusCrRo5TDugs"]}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5' b'aMtSrMtY0AAAAAAAAAAAAAAAAAAAAAAgEoDJpf8xcmVXj3chkgVpVXvFgAaHyohm' b'v-Bkgjsf5yf4') assert kevt == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"2","t":"ixn","p":"EoDaZfC2yqtPwKJBrhAGzP20SOslM' b'Z-eQ7hAbl3w4JP0","a":["EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9' b'vSY","1","Ex1ZICku_jaiYzNIjfw1Q46T_srpyz7YJwpqS1xA9xuo"]}-AABAAG' b'XF1gyvCxtP3GaL-MenYOYSAqf0_BzzyRknY6mhCohXK5cIA0CrJfkPandYmDvGxo' b'63K0BPxCR3ey6PbjabkBg') ser = Serder(raw=tevt) assert ser.diger.qb64 == 'Ex1ZICku_jaiYzNIjfw1Q46T_srpyz7YJwpqS1xA9xuo' tevt, kevt = issuer.issue(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8") assert tevt == (b'{"v":"KERI10JSON000105_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z-i0d8","ii":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9vSY",' b'"s":"0","t":"bis","ra":{"i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDG' b'eLWHb9vSY","s":1,"d":"Ex1ZICku_jaiYzNIjfw1Q46T_srpyz7YJwpqS1xA9x' b'uo"}}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAA' b'AAAAAAAAAAAAwEJDkcdO3kE_gFLxSZA53HsEr9DK3gI1j6qEcwsZjzcZo') assert kevt == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"3","t":"ixn","p":"EoDJpf8xcmVXj3chkgVpVXvFgAaHy' b'ohmv-Bkgjsf5yf4","a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i' b'0d8","0","E_RmCtCYGKOUj9-r2HbZlTOTzrViYvlthhlhZFElyjzw"]}-AABAAN' b'bk_fVhHJVPZpwLA2Bmj9ZvD6T885Krwd8RJn2AGgQHVux7fsr-ZW4BXtFT7DW9Cj' b'jXkxP8gBSmIQt9gHPljBA') ser = Serder(raw=tevt) assert ser.diger.qb64 == 'E_RmCtCYGKOUj9-r2HbZlTOTzrViYvlthhlhZFElyjzw' tevt, kevt = issuer.revoke(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8") assert tevt == (b'{"v":"KERI10JSON000104_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z-i0d8","s":"1","t":"brv","p":"E_RmCtCYGKOUj9-r2HbZlTOTzrViY' b'vlthhlhZFElyjzw","ra":{"i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGe' b'LWHb9vSY","s":1,"d":"Ex1ZICku_jaiYzNIjfw1Q46T_srpyz7YJwpqS1xA9xu' b'o"}}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAAA' b'AAAAAAAAAABAEUQewfkI5B3VEU1w0BPpikSBdchw52PW4MrMcgizKVpc') assert kevt == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"4","t":"ixn","p":"EJDkcdO3kE_gFLxSZA53HsEr9DK3g' b'I1j6qEcwsZjzcZo","a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i' b'0d8","1","Ei1-r5vju2kh44KY09nd1KzeB1mq5_a33CwlYFs0tH3c"]}-AABAA3' b'3POBHT4hao0mAXiOAsji3ft-NLbGRAVJ1kh1VBu9eTddSO6mUYwZpQCDgQc2SwqS' b'C7VuegB_UVHbRtQcNiLCA') ser = Serder(raw=tevt) assert ser.diger.qb64 == 'Ei1-r5vju2kh44KY09nd1KzeB1mq5_a33CwlYFs0tH3c' # issuer, not allowed to issue backers issuer = Issuer(hab=hab, name="test", allowBackers=False) assert issuer.incept == (b'{"v":"KERI10JSON0000ad_","i":"Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEG' b'I0egFyLehw","ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY",' b'"s":"0","t":"vcp","c":["NB"],"bt":"0","b":[]}-eABEaKJ0FoLxO1TYmy' b'uprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAAAAAAAAAAAAABQEAUius1E3mN' b'za_tVygjmKAd5tIz9JVAP8PTLaEHwnx7w') assert issuer.ianchor == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"5","t":"ixn","p":"EUQewfkI5B3VEU1w0BPpikSBdchw5' b'2PW4MrMcgizKVpc","a":["Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyL' b'ehw","0","ElYstqTocyQixLLz4zYCAs2unaFco_p6LqH0W01loIg4"]}-AABAAN' b'Tokkv5aZ_MPLauMFsgzASyFs5qMb4-fo7HIofmpRa-XMfDS9vccchXXZb47774Be' b'YR6Nljg9m_ehk3b8NnTCg') with pytest.raises(ValueError): issuer.rotate(adds=["EqoNZAX5Lu8RuHzwwyn5tCZTe-mDBq5zusCrRo5TDugs"]) tevt, kevt = issuer.issue(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8") assert tevt == (b'{"v":"KERI10JSON000092_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z-i0d8","s":"0","t":"iss","ri":"Ezm53Qww2LTJ1yksEL06Wtt-5D23' b'QKdJEGI0egFyLehw"}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrM' b'tY0AAAAAAAAAAAAAAAAAAAAABgErPUCiDOsokTzqSx3ktSFx6P6bhfWLps3PbvbY' b'ZIdjMw') assert kevt == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"6","t":"ixn","p":"EAUius1E3mNza_tVygjmKAd5tIz9J' b'VAP8PTLaEHwnx7w","a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i' b'0d8","0","EXTVuADWAm9XOG6XKMyKRs8FO2dYPFo12rinap96BUjU"]}-AABAAf' b'tQ5Ccj6aiZCVArCRlcBPhUKnO0m5q75dRgs316rxbsbEdXC3lB2AC4TWCMB0EVv5' b'rzGRu6Gnw6134VpkkrPCw') tevt, kevt = issuer.revoke(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8") assert tevt == (b'{"v":"KERI10JSON000091_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z-i0d8","s":"1","t":"rev","p":"EXTVuADWAm9XOG6XKMyKRs8FO2dYP' b'Fo12rinap96BUjU"}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMt' b'Y0AAAAAAAAAAAAAAAAAAAAABwEpzwTULkTXErmB12S-vR4Ysi22kFCtqaV9_uoP2' b'zBWNE') assert kevt == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"7","t":"ixn","p":"ErPUCiDOsokTzqSx3ktSFx6P6bhfW' b'Lps3PbvbYZIdjMw","a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i' b'0d8","1","EgaGSsEExjY_19HbFsfWjtrj_nmtYmDU23qaod0KSr2o"]}-AABAAM' b'w_8vSj-GBc1dMDTeNZg1sRhqOOBIROUDXAEvY5nICWhgp1RP-XYOYaVlJpLOLN6M' b'nm6JU_z3rvsq475D4WsBQ') # issuer, allowed backers, initial set of backers issuer = Issuer(hab=hab, name="test", baks=["EqoNZAX5Lu8RuHzwwyn5tCZTe-mDBq5zusCrRo5TDugs"]) assert issuer.incept == (b'{"v":"KERI10JSON0000d7_","i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78' b'p90WN3sG3I","ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY",' b'"s":"0","t":"vcp","c":[],"bt":"1","b":["EqoNZAX5Lu8RuHzwwyn5tCZT' b'e-mDBq5zusCrRo5TDugs"]}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5a' b'MtSrMtY0AAAAAAAAAAAAAAAAAAAAACAERI1IUUGtVVKDEqLw59qPJzIIwRFVU1sN' b'n__B8Z6GgXk') assert issuer.ianchor == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"8","t":"ixn","p":"EpzwTULkTXErmB12S-vR4Ysi22kFC' b'tqaV9_uoP2zBWNE","a":["EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78p90WN3s' b'G3I","0","EMMt2bfrg5ACOrCLQRuU21qWMBxDPwzIhOANvHKAGJWc"]}-AABAAZ' b'Zo51JRK2aU0zppx12N584195BP-UjAtCly9_Z1dfuoUQz5yV4m_NJSt-w86t9VsH' b'UMDtI20EbRtenypM3NyDw') tevt, kevt = issuer.issue(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8") assert tevt == (b'{"v":"KERI10JSON000105_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z-i0d8","ii":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78p90WN3sG3I",' b'"s":"0","t":"bis","ra":{"i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78p' b'90WN3sG3I","s":0,"d":"EMMt2bfrg5ACOrCLQRuU21qWMBxDPwzIhOANvHKAGJ' b'Wc"}}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAA' b'AAAAAAAAAAACQETPkpmuLwJY4SXHPw0kjrKG5CYTTkf-OMxTgDnBFx7_k') assert kevt == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"9","t":"ixn","p":"ERI1IUUGtVVKDEqLw59qPJzIIwRFV' b'U1sNn__B8Z6GgXk","a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i' b'0d8","0","Eu9JBjmUh10w5FLNORAdHuICsQ0VJ7WLoxvAA56fQr0w"]}-AABAAY' b'Dm3lQah_ZQhX9wJmgHY6eWTtFozD2HLA004TIm-w2LIdqS-tw6pHSNgYQKBvNt0T' b'4t2Y1pL0rsDBTGAEaw_Cg') tevt, kevt = issuer.rotate(adds=["EtEBUSHpJDMfzHdDt3QCtrA-iVlP-0DT03AdqeeDa7vs", "ERVZTggTUOPmLcWBESrxcI-VsB48FerF6sz2boziikcY"]) vrtser = Serder(raw=tevt) assert tevt == (b'{"v":"KERI10JSON000107_","i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78' b'p90WN3sG3I","p":"EMMt2bfrg5ACOrCLQRuU21qWMBxDPwzIhOANvHKAGJWc","' b's":"1","t":"vrt","bt":"3","br":[],"ba":["EtEBUSHpJDMfzHdDt3QCtrA' b'-iVlP-0DT03AdqeeDa7vs","ERVZTggTUOPmLcWBESrxcI-VsB48FerF6sz2bozi' b'ikcY"]}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAA' b'AAAAAAAAAAAAACgE58EtRRxJROE7qmMnHV6fnP8FeFTBkX8eMlZbMNDFY6w') assert kevt == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"a","t":"ixn","p":"ETPkpmuLwJY4SXHPw0kjrKG5CYTTk' b'f-OMxTgDnBFx7_k","a":["EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78p90WN3s' b'G3I","1","EKwtenOwTRhQCzIiBWTPWPCWB6PQ9sF0pnPrsCS_YhuA"]}-AABAAp' b'fZ6LoLMi4L_nabHRQZgW59NT3xt6IYrZ5D4lc7gUoalP-VraZ-TIThFSJSKsZER7' b'W0Ev1FD6Zn5pb1JTAgKAg') tevt, kevt = issuer.revoke(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8") assert tevt == (b'{"v":"KERI10JSON000104_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z-i0d8","s":"1","t":"brv","p":"Eu9JBjmUh10w5FLNORAdHuICsQ0VJ' b'7WLoxvAA56fQr0w","ra":{"i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78p9' b'0WN3sG3I","s":1,"d":"EKwtenOwTRhQCzIiBWTPWPCWB6PQ9sF0pnPrsCS_Yhu' b'A"}}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAAA' b'AAAAAAAAAACwE71WIaYxok1t0xzC9OYyX1TYjsKG1o9LCnj_o_gsGH4M') assert kevt == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"b","t":"ixn","p":"E58EtRRxJROE7qmMnHV6fnP8FeFTB' b'kX8eMlZbMNDFY6w","a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i' b'0d8","1","E9lcc71zkJXoc5E7qcCKOjZrhsNqqenXhTJMShSVek04"]}-AABAAq' b'1GKbPLjSoNJLTiAbSP6EM0j2d3IOzw9LTbGGrXw3GVT6P6P-S9y8kPdmIXszP5PB' b'CDJehu8GsgvxLR2f_alCg') # ensure the ra seal digest matches the vrt event digest assert vrtser.diger.qb64 == 'EKwtenOwTRhQCzIiBWTPWPCWB6PQ9sF0pnPrsCS_YhuA' # issuer, no backers allowed, establishment events only issuer = Issuer(hab=hab, name="test", allowBackers=False, estOnly=True) assert issuer.incept == (b'{"v":"KERI10JSON0000ad_","i":"Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEG' b'I0egFyLehw","ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY",' b'"s":"0","t":"vcp","c":["NB"],"bt":"0","b":[]}-eABEaKJ0FoLxO1TYmy' b'uprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAAAAAAAAAAAAADAEE4ISn-pS8v' b'oter-KsYyHlMb8pxiG_Uazvjw-cNRlm8s') assert issuer.ianchor == (b'{"v":"KERI10JSON000183_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"c","t":"rot","p":"E71WIaYxok1t0xzC9OYyX1TYjsKG1' b'o9LCnj_o_gsGH4M","kt":"1","k":["DKPE5eeJRzkRTMOoRGVd2m18o8fLqM2j' b'9kaxLhV3x8AQ"],"n":"ELqHYQwWR0h2vP1_cxTsutU0wKJ_NrwBVKJCgPgWGgwc' b'","bt":"0","br":[],"ba":[],"a":["Ezm53Qww2LTJ1yksEL06Wtt-5D23QKd' b'JEGI0egFyLehw","0","ElYstqTocyQixLLz4zYCAs2unaFco_p6LqH0W01loIg4' b'"]}-AABAATpTzNLJAV5CLD8znuTh2w73ZwqlsrOJIXa-XK2uY7QhnFHAD16yoDma' b'BhdNFEKhFhqFLWnwUVe8myYkVnh8YCQ') tevt, kevt = issuer.issue(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z") assert tevt == (b'{"v":"KERI10JSON00008d_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z","s":"0","t":"iss","ri":"Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJE' b'GI0egFyLehw"}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AA' b'AAAAAAAAAAAAAAAAAAADQEDrLbf5h3GE06g3v-Ox2fFoolQyrvKW_sTrIxtQxuZAU') assert kevt == (b'{"v":"KERI10JSON00017e_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"d","t":"rot","p":"EE4ISn-pS8voter-KsYyHlMb8pxiG' b'_Uazvjw-cNRlm8s","kt":"1","k":["DSuhyBcPZEZLK-fcw5tzHn2N46wRCG_Z' b'OoeKtWTOunRA"],"n":"EPYuj8mq_PYYsoBKkzX1kxSPGYBWaIya3slgCOyOtlqU' b'","bt":"0","br":[],"ba":[],"a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH' b'3ULvaU6Z","0","EnZpkCQXGps7J8hO5BbFrVG7KSaEd1J3u-mAL8-E-JoY"]}-A' b'ABAANcQvSou7f1vUanuNPB0QWSsv0_NUupscqNl4sY7HijmH0eUDxiz9ryWa-UdQ' b'nzHLI-gY7ITVB5JgXJMtxKkxBw') ser = Serder(raw=tevt) assert ser.diger.qb64 == 'EnZpkCQXGps7J8hO5BbFrVG7KSaEd1J3u-mAL8-E-JoY' tevt, kevt = issuer.revoke(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z") assert tevt == (b'{"v":"KERI10JSON00008c_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z","s":"1","t":"rev","p":"EnZpkCQXGps7J8hO5BbFrVG7KSaEd1J3u-' b'mAL8-E-JoY"}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAA' b'AAAAAAAAAAAAAAAAAADgE9-23oNfUrdBvXi-x89tgF8cO6mLCW5rGdQZ-C6agszE') assert kevt == (b'{"v":"KERI10JSON00017e_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"e","t":"rot","p":"EDrLbf5h3GE06g3v-Ox2fFoolQyrv' b'KW_sTrIxtQxuZAU","kt":"1","k":["DVcuJOOJF1IE8svqEtrSuyQjGTd2HhfA' b'kt9y2QkUtFJI"],"n":"E-dapdcC6XR1KWmWDsNl4J_OxcGxNZw1Xd95JH5a34fI' b'","bt":"0","br":[],"ba":[],"a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH' b'3ULvaU6Z","1","EVFiCQMPCoXtMpK-yoLWIVfwifQkLSH1Dj4RtzyOCVuo"]}-A' b'ABAArUM8moanrzuFmxW48V4XE06zRkvnRHmtQtxt-q8ZqDoZeU0fTvJu_qQC0Qrb' b'KVfVBNQ8ajphcJDdRP82d5aWAQ') with pytest.raises(ValueError): issuer.rotate(adds=["EqoNZAX5Lu8RuHzwwyn5tCZTe-mDBq5zusCrRo5TDugs"]) # issuer, backers allowed, initial backer, establishment events only issuer = Issuer(hab=hab, name="test", baks=["EqoNZAX5Lu8RuHzwwyn5tCZTe-mDBq5zusCrRo5TDugs"], estOnly=True) assert issuer.incept == (b'{"v":"KERI10JSON0000d7_","i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78' b'p90WN3sG3I","ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY",' b'"s":"0","t":"vcp","c":[],"bt":"1","b":["EqoNZAX5Lu8RuHzwwyn5tCZT' b'e-mDBq5zusCrRo5TDugs"]}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5a' b'MtSrMtY0AAAAAAAAAAAAAAAAAAAAADwEvDmjSZQmSLqNzTJDq9rdDd7X-ffGPt6z' b'uD2n51EFRLw') assert issuer.ianchor == (b'{"v":"KERI10JSON000183_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"f","t":"rot","p":"E9-23oNfUrdBvXi-x89tgF8cO6mLC' b'W5rGdQZ-C6agszE","kt":"1","k":["DT1iAhBWCkvChxNWsby2J0pJyxBIxbAt' b'bLA0Ljx-Grh8"],"n":"EDs-qIrh79lTtoIz4K9q_vu7-avDc79YkNCfK49HpwQg' b'","bt":"0","br":[],"ba":[],"a":["EZRowynuVBviCH0ZfUx24mkMWn-jGRB' b'm78p90WN3sG3I","0","EMMt2bfrg5ACOrCLQRuU21qWMBxDPwzIhOANvHKAGJWc' b'"]}-AABAAmTxyOx_38hK74779sN9vPXxcRHV49li9vt0RvAKlfuCBKG2hwWyy0P-' b'9tFF_2VMvAfrWChEsjWPm9lsPeWIwBw') ser = Serder(raw=issuer.incept) assert ser.diger.qb64 == 'EMMt2bfrg5ACOrCLQRuU21qWMBxDPwzIhOANvHKAGJWc' tevt, kevt = issuer.rotate(adds=["EtEBUSHpJDMfzHdDt3QCtrA-iVlP-0DT03AdqeeDa7vs", "ERVZTggTUOPmLcWBESrxcI-VsB48FerF6sz2boziikcY"]) vrtser = Serder(raw=tevt) assert tevt == (b'{"v":"KERI10JSON000107_","i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78' b'p90WN3sG3I","p":"EMMt2bfrg5ACOrCLQRuU21qWMBxDPwzIhOANvHKAGJWc","' b's":"1","t":"vrt","bt":"3","br":[],"ba":["EtEBUSHpJDMfzHdDt3QCtrA' b'-iVlP-0DT03AdqeeDa7vs","ERVZTggTUOPmLcWBESrxcI-VsB48FerF6sz2bozi' b'ikcY"]}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAA' b'AAAAAAAAAAAAAEAEKKopp_VUWhCpagBvKuWMfuSwRe5gcmh4LO4kJB1rItE') assert kevt == (b'{"v":"KERI10JSON000184_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"10","t":"rot","p":"EvDmjSZQmSLqNzTJDq9rdDd7X-ff' b'GPt6zuD2n51EFRLw","kt":"1","k":["D4JDgo3WNSUpt-NG14Ni31_GCmrU0r3' b'8yo7kgDuyGkQM"],"n":"EvbWtNrsw7dfaWRiDMXcF6P90KM1gdfPhg7FWTIwD39' b'c","bt":"0","br":[],"ba":[],"a":["EZRowynuVBviCH0ZfUx24mkMWn-jGR' b'Bm78p90WN3sG3I","1","EKwtenOwTRhQCzIiBWTPWPCWB6PQ9sF0pnPrsCS_Yhu' b'A"]}-AABAAonXgmX0PD7e94oqW9yhkm9ydZjwivpNWEPPLIQkOzzvfqGlI79io4x' b'FF8-8K8UWok5dfb9j9fhrqR-e9p23bBw') tevt, kevt = issuer.issue(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z") assert tevt == (b'{"v":"KERI10JSON000100_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z","ii":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78p90WN3sG3I","s":"' b'0","t":"bis","ra":{"i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78p90WN3' b'sG3I","s":1,"d":"EKwtenOwTRhQCzIiBWTPWPCWB6PQ9sF0pnPrsCS_YhuA"}}' b'-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAAAAAAA' b'AAAAAAEQEoRSZSkIHCJjvW9KDO26tFW4VQkhZXVXuYm8OrfxUfh8') assert kevt == (b'{"v":"KERI10JSON00017f_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"11","t":"rot","p":"EKKopp_VUWhCpagBvKuWMfuSwRe5' b'gcmh4LO4kJB1rItE","kt":"1","k":["DVjWcaNX2gCkHOjk6rkmqPBCxkRCqwI' b'J-3OjdYmMwxf4"],"n":"EpusdZwamtwTwqtwOenXWKQ0FpX9yWnq0XHlOEgQmss' b'0","bt":"0","br":[],"ba":[],"a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZ' b'H3ULvaU6Z","0","EXklP9Aj6ZXeC4Ox-TFExo_pk5u-ocMacfq82evq0rVo"]}-' b'AABAAIcH6E9px8Tcz2kbJd8vmOvcvnb4Pe2QYL5Y6hkbIPsymR7awzvThHx8qkXB' b'G51sJIgUExNoyaAOnkp20psoeAQ') assert vrtser.diger.qb64 == 'EKwtenOwTRhQCzIiBWTPWPCWB6PQ9sF0pnPrsCS_YhuA' # rotate to no backers tevt, kevt = issuer.rotate(cuts=["EqoNZAX5Lu8RuHzwwyn5tCZTe-mDBq5zusCrRo5TDugs"]) assert tevt == (b'{"v":"KERI10JSON0000d8_","i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78' b'p90WN3sG3I","p":"EKwtenOwTRhQCzIiBWTPWPCWB6PQ9sF0pnPrsCS_YhuA","' b's":"2","t":"vrt","bt":"0","br":["EqoNZAX5Lu8RuHzwwyn5tCZTe-mDBq5' b'zusCrRo5TDugs"],"ba":[]}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5' b'aMtSrMtY0AAAAAAAAAAAAAAAAAAAAAEgEX0HvF8uLvwvQcbnMq1JaMqoPSiJ0RqZ' b'dhyM7gWfYS4g') assert kevt == (b'{"v":"KERI10JSON000184_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"12","t":"rot","p":"EoRSZSkIHCJjvW9KDO26tFW4VQkh' b'ZXVXuYm8OrfxUfh8","kt":"1","k":["DT1nEDepd6CSAMCE7NY_jlLdG6_mKUl' b'KS_mW-2HJY1hg"],"n":"ER0SqaQnpyIxxtL_UFvE8wpooAjKNiq36zhpwwbfuZo' b'w","bt":"0","br":[],"ba":[],"a":["EZRowynuVBviCH0ZfUx24mkMWn-jGR' b'Bm78p90WN3sG3I","2","ETtfhi2rdeM4yqMuBb1fLXMjZlG_n_I3N00JMfaIBUn' b's"]}-AABAARKOiQnD9BSRUqFg63Q3lUjyMAJ-cZiVVCHO4POe0iEAXdIRp4Ylzdt' b'PJzVTRpuJC2YecICPXkEehBbnQhXwHBg') vrtser = Serder(raw=tevt) tevt, kevt = issuer.revoke(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z") assert tevt == (b'{"v":"KERI10JSON0000ff_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z","s":"1","t":"brv","p":"EXklP9Aj6ZXeC4Ox-TFExo_pk5u-ocMacf' b'q82evq0rVo","ra":{"i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78p90WN3s' b'G3I","s":2,"d":"ETtfhi2rdeM4yqMuBb1fLXMjZlG_n_I3N00JMfaIBUns"}}-' b'eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAAAAAAAA' b'AAAAAEwE97hmLY8BYtFhPxzmN0ZweLfeU_hU7RVgD8e6BvZA92U') assert kevt == (b'{"v":"KERI10JSON00017f_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"13","t":"rot","p":"EX0HvF8uLvwvQcbnMq1JaMqoPSiJ' b'0RqZdhyM7gWfYS4g","kt":"1","k":["DiDeeYNZLsQncGJZ6DR54gAy-HySmzz' b'gl61KFMZ4iR0U"],"n":"E9IUWbvzBjn0ubo_lpKsjCb6ajDS1V23iLHrJFHZ2rV' b'k","bt":"0","br":[],"ba":[],"a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZ' b'H3ULvaU6Z","1","EI_uyS9EE7t3s_TD5PpqqpLXb3PfPt8K0J7VnNLF50-o"]}-' b'AABAAdKHkxbgf1PgVw8dfg4taD8igLLzGlZkifbMcVL3cLOciDn6Ovi39Xsk36Y8' b'a3xHh8WJkIfOaONYscc_bz-jJBw') assert vrtser.diger.qb64 == 'ETtfhi2rdeM4yqMuBb1fLXMjZlG_n_I3N00JMfaIBUns' """ End Test """
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 dbing.openDB(name="deb") as debDB, keeping.openKS(name="deb") as debKS, \ dbing.openDB(name="cam") as camDB, keeping.openKS(name="cam") as camKS, \ dbing.openDB(name="bev") as bevDB, keeping.openKS(name="bev") as bevKS, \ dbing.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 = directing.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 = directing.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 = directing.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 = directing.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 # 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":"EBfdpo5wnI3XTcdUIgJRf1-xLhy8Ud8lry' b'kGGHz2vlMw","s":"0","t":"icp","kt":["1/2","1/2","1/2"],"k":["DaY' b'h8uaASuDjMUd8_BoNyQs3GwupzmJL8_RBsuNtZHQg","Duzj-Z2lR2DqB0cI0421' b'oSMUVWOrN5axojx8g9fSx3PM","DRXPAmNVVqafWvQiN5qQmWUDvVupF2w8xFNGg' b'1Gays9Y"],"n":"EO5f_IQjtBoeN_-OyzfVJx1_WqBFUL-Ely4x-xmUtOW8","bt' b'":"0","b":[],"c":[],"a":[]}-AADAA1G77zOmX-GYRN5yk5X704dneyog8BHJ' b'ItCZdLmXl4Tlfd-bE3K8WpbApL_-n1o18Ato90tRhAIZjuBIlxF9vAgAByElIwoU' b'aqbuJzHevggmdBySCIropnrylNFmSETWjOwLT2ifZgCJ1lm27IbknR_33LPPIyN3' b'U6dbIAG3kko7IDgACdOTaaqRtwquJiBZJfWYKtH48gZTezMLzXviMUeo2Z1cJ-_M' b'xQvDNh85FjXAOEQ-3hPEiqmY1SpjElZIXGs13DA{"v":"KERI10JSON000098_",' b'"i":"EBfdpo5wnI3XTcdUIgJRf1-xLhy8Ud8lrykGGHz2vlMw","s":"1","t":"' b'ixn","p":"E5OQH-DOSjcX8JlBtznPaaawhP0iuZhjf9cxWVAXNTX0","a":[]}-' b'AADAAO7JjY0oHH5z68S4ZlYUAOAFnMfRu6OZB9hMGgu6teSzvL_3kzAiiPig6vch' b'lnXDxmKFWMDLXAZsCBN3T0chVCwAB_I3BVOYI2K_VSeLDcq32czYe-kTyPZ1E0wd' b'-F78Ixsz99mQwwylJsbRBb2l1Q2-1UnbQ4NZzj0w2xo5fEBv4BAACHO5PyuMrekU' b'FWbirPNt7etpA3cUVAR94XFlJDUYYSE4tq1gD6Pab-L2PP3ifFlluO-aoVpf3G8h' b'Sl75t2k7rCg{"v":"KERI10JSON000190_","i":"EBfdpo5wnI3XTcdUIgJRf1-' b'xLhy8Ud8lrykGGHz2vlMw","s":"2","t":"rot","p":"EjevD0KmiBZQHqVNND' b'mpTfrp0lqZI5eicRRNf3OqLW9o","kt":["1/2","1/2","1/2"],"k":["DIsi8' b'qYso1KMmpLOGYty3NC2BAojZmUCfzR5_5oQRiso","DkdClpaWCAoCPBYgUmqP9g' b'wAtsGq81yyPhGQKQ6-W_F0","DKDyq4QQYKnx9ircxeCvEcraI4HUSr_ytWPelDH' b'AM98w"],"n":"E1oOvJmwenmC4uHjX7qB40LGVbeZY5rYQeZ6IK5zmdmM","bt":' b'"0","br":[],"ba":[],"a":[]}-AADAAfELYptGBeOzZ1ex7MIxYAUN_f4mr0gZ' b'gUZAQTZQbZKsTykDGqTcsbuLurhFviHttWylHBBjDwfCRF8eFCpLkDgABRLbYyJQ' b'W8plPZ3PcdBLHgl4NWnB5NeTOI9tjW53DL4le2N-nVPVXr_fAvWcksevbGNRZxCU' b'ePoDlThcBShDdBwACSPQd27SozRqfeW7YWWQS87JXdgy-ZGTrhrT1bUTTQKAngwE' b'1hwWgIYw8LUgz3YH6SZC5zAWUN_Fv3OzSb_BXBg{"v":"KERI10JSON000098_",' b'"i":"EBfdpo5wnI3XTcdUIgJRf1-xLhy8Ud8lrykGGHz2vlMw","s":"3","t":"' b'ixn","p":"Ew3t8tlmqfRSwyyRF1nsKLjNOySvj-KTd-SmDu_AjzuA","a":[]}-' b'AADAAJ4MM4lGyFUsszt7fXksb13wqyiBTd3AirhQaTO3udtTilMfviCutx-ipkgT' b'u56huDbWLiA47LqUzqP63rKv3DQAB9hmDtEawFFGHMeS92RBuuMMQroBM5fodzeo' b'leSrV0IyETDSpjaRhcsDf25EqNTJUcnv-_jSzRPEtM8GEv3AJCgACxWtyOC4ks1F' b'8-YdHSM32VLysW0ypRBpfYDOHyfmtktb1XQjdAAJpkSDe9wvrttvE2xJ5GzyfpVv' b'Ps4zK54pCDA{"v":"KERI10JSON000098_","i":"EBfdpo5wnI3XTcdUIgJRf1-' b'xLhy8Ud8lrykGGHz2vlMw","s":"4","t":"ixn","p":"EY_w2vUVqsE6jdgdxJ' b'VvMW3434NG1w_asCW7ohG1nmMY","a":[]}-AADAANw16XHQyB4Edm0MF4b0m8Ez' b'8jOZSYr_bYn7ilsFTNBypC_tSIcLnOUarG1xuhFU21WjXiSHWt2t2BSIHulgtDgA' b'Bm1DN8JigUofEC8mXb7YgklycIqDt7F7p8s6x8VHlAqLsCiMsXGQlRCwUwF7DFeu' b'6Fw_43Io6evqKpzaTR31SCwACJE0jOjykDr4SU59Mpd-EBTwKc8hUUWeIQTF3qU4' b'H56jqKozmgsyzzViob_DZ828OGBLRG_WoIQxTvstXql3QDw{"v":"KERI10JSON0' b'00098_","i":"EBfdpo5wnI3XTcdUIgJRf1-xLhy8Ud8lrykGGHz2vlMw","s":"' b'5","t":"ixn","p":"EwJ79SUIE69dA0my9ai9hK3yH8cqqyD9CS62lyRTDn-o",' b'"a":[]}-AADAAhAypLrhzTbvSPdErva4IzRRSq6EZCC_dCe3pkLGpPcVHdi3Mu2B' b'-c0oW1My7HFFa1-JNTbjnNtgK-Or297PmAgABM1DYwa0Khbr79SbRaC6l8rAwsxs' b'Vopeid8KfS-7pt60y9drfLpXIUFzt5rk24KUuZROO33KiHmfKNbviW6GVCgACQRj' b'qwHlELgvpFJwQx-6yBVuAgbsT7AK1mbxfsUo2XfzkAUTbn9H1vxOQX1Rg_3cLYZv' b'ryKcP4MdjZFfFYaNmBQ{"v":"KERI10JSON000098_","i":"EBfdpo5wnI3XTcd' b'UIgJRf1-xLhy8Ud8lrykGGHz2vlMw","s":"6","t":"ixn","p":"EBjW8_7rqn' b'AXV0Il5BJ4XWZcIb355Ltj-9F9JRZLn75c","a":[]}-AADAAbbH94e474Pflg_Y' b'dlivHMQQL_7rUlr1DEut8SSbEs6cmUixWHW8SuZG2UlpKoqsAL-STNALsRCmDw_2' b'wWsmWAAABnedMdYxUbNgwJpG5AcNsxMIZCjuu486-wuiUm3BO_1h40_qvoMicneV' b'edtBOLxD5zKtdZhBHZqtd3-qQDmIVDgACqms_mYs0LAwAi2zGN6lpKmdqs2twyJz' b'9xiyPeERHG7D2FiTZqow19UieVYobmhGeHuoS5WxNPgcponbhHeFnDA') # Play debMsgs to Cam # create non-local kevery for Cam to process msgs from Deb camKevery = eventing.Kevery(kevers=camHab.kevers, db=camHab.db, framed=True, opre=camHab.pre, local=False) 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":"EiRjCnZfca8gUZqecerjGpjkiY8dIkGudP' b'6GfapWi5MU","s":"0","t":"icp","kt":"2","k":["DaYh8uaASuDjMUd8_Bo' b'NyQs3GwupzmJL8_RBsuNtZHQg","Duzj-Z2lR2DqB0cI0421oSMUVWOrN5axojx8' b'g9fSx3PM","DRXPAmNVVqafWvQiN5qQmWUDvVupF2w8xFNGg1Gays9Y"],"n":"E' b'OySO3Oa400n3Ss9JftGYmgS5M4jgPInNnMntC_l-PEQ","bt":"0","b":[],"c"' b':[],"a":[]}-AADAATacW---OhatYudCOUeNdVpYq8Vk_LIKMQML86xz4b1ZQG9r' b'ahEGEHMtDacANGyKFSkJBq4F3x8h30lWfrth2BQABnyZMjYDQs2IgFuVcRKCLi9F' b'DFOw7uPqIvwossbC4H2Eu4_cIntaKeEmH7LBEzDbfQaQxWdgZ2YTnfFkoznL3AgA' b'Ckf4d23ErgdwPZWJf_0jVtzVwoKsh_6W0V6BclmrbnL1NWM8ox2m3ff7LzZeSjF5' b'9AvO-QmqCD325H3igOF0HCg{"v":"KERI10JSON000105_","i":"EBfdpo5wnI3' b'XTcdUIgJRf1-xLhy8Ud8lrykGGHz2vlMw","s":"0","t":"vrc","d":"E5OQH-' b'DOSjcX8JlBtznPaaawhP0iuZhjf9cxWVAXNTX0","a":{"i":"EiRjCnZfca8gUZ' b'qecerjGpjkiY8dIkGudP6GfapWi5MU","s":"0","d":"E1tSV5RBIG7dGPN2Oof' b'5DmZCqgGgpF7P9BbfOTnOEEpM"}}-AADAA1G77zOmX-GYRN5yk5X704dneyog8BH' b'JItCZdLmXl4Tlfd-bE3K8WpbApL_-n1o18Ato90tRhAIZjuBIlxF9vAgAByElIwo' b'UaqbuJzHevggmdBySCIropnrylNFmSETWjOwLT2ifZgCJ1lm27IbknR_33LPPIyN' b'3U6dbIAG3kko7IDgACdOTaaqRtwquJiBZJfWYKtH48gZTezMLzXviMUeo2Z1cJ-_' b'MxQvDNh85FjXAOEQ-3hPEiqmY1SpjElZIXGs13DA{"v":"KERI10JSON000105_"' b',"i":"EBfdpo5wnI3XTcdUIgJRf1-xLhy8Ud8lrykGGHz2vlMw","s":"1","t":' b'"vrc","d":"EjevD0KmiBZQHqVNNDmpTfrp0lqZI5eicRRNf3OqLW9o","a":{"i' b'":"EiRjCnZfca8gUZqecerjGpjkiY8dIkGudP6GfapWi5MU","s":"0","d":"E1' b'tSV5RBIG7dGPN2Oof5DmZCqgGgpF7P9BbfOTnOEEpM"}}-AADAAO7JjY0oHH5z68' b'S4ZlYUAOAFnMfRu6OZB9hMGgu6teSzvL_3kzAiiPig6vchlnXDxmKFWMDLXAZsCB' b'N3T0chVCwAB_I3BVOYI2K_VSeLDcq32czYe-kTyPZ1E0wd-F78Ixsz99mQwwylJs' b'bRBb2l1Q2-1UnbQ4NZzj0w2xo5fEBv4BAACHO5PyuMrekUFWbirPNt7etpA3cUVA' b'R94XFlJDUYYSE4tq1gD6Pab-L2PP3ifFlluO-aoVpf3G8hSl75t2k7rCg{"v":"K' b'ERI10JSON000105_","i":"EBfdpo5wnI3XTcdUIgJRf1-xLhy8Ud8lrykGGHz2v' b'lMw","s":"2","t":"vrc","d":"Ew3t8tlmqfRSwyyRF1nsKLjNOySvj-KTd-Sm' b'Du_AjzuA","a":{"i":"EiRjCnZfca8gUZqecerjGpjkiY8dIkGudP6GfapWi5MU' b'","s":"0","d":"E1tSV5RBIG7dGPN2Oof5DmZCqgGgpF7P9BbfOTnOEEpM"}}-A' b'ADAABkB5LzkcturaQSzTGH_KrWsEJR-x_CH8UPl9FQ1Dc461z5-Fdn3TLJ7DpUw-' b'6VrbKGGjuDy2Nkg0xJdzh4F8CQABPgHmWCG4uUicqcBiHOJcygFsSqFMU2jkOgU7' b'3eG-Jony_ZwctQl_1BCQ8eVTli44Uou4YMdgvRMfmiRGTuxeAwAC386oYzhQFZCk' b'S6TM9vIFahT8vf0cQ7t2v5MqKhyJxBgA6CHJeQ8mxS8P7trjcEOGl79jwb6L-jyt' b'qAnNPDJFCA{"v":"KERI10JSON000105_","i":"EBfdpo5wnI3XTcdUIgJRf1-x' b'Lhy8Ud8lrykGGHz2vlMw","s":"3","t":"vrc","d":"EY_w2vUVqsE6jdgdxJV' b'vMW3434NG1w_asCW7ohG1nmMY","a":{"i":"EiRjCnZfca8gUZqecerjGpjkiY8' b'dIkGudP6GfapWi5MU","s":"0","d":"E1tSV5RBIG7dGPN2Oof5DmZCqgGgpF7P' b'9BbfOTnOEEpM"}}-AADAAraP5JCHU-ZQwsDAWuLu_fvvYmkpVEu071l5P7fwHzqL' b'bJ7kkvpSsXcGs2HpW_Bw_fjp07LfnN4de5zn7-owxAgABQUHJIy3inow-7ctn-jO' b'F6r2IvOsC-Pl2jAueDZfH9p2pS_L9OhgHBr9ToilY4H_1bbIZK2kERtt47Qd0VVq' b'qDAAC_0A73HjuuB42XhAqgPMWt1Fm-FwO55oT0z7TJR9PQ4ppaEuip5FUp-miRS9' b'Rnoq0ZYPWskncUmLgcqxsOksvBw{"v":"KERI10JSON000105_","i":"EBfdpo5' b'wnI3XTcdUIgJRf1-xLhy8Ud8lrykGGHz2vlMw","s":"4","t":"vrc","d":"Ew' b'J79SUIE69dA0my9ai9hK3yH8cqqyD9CS62lyRTDn-o","a":{"i":"EiRjCnZfca' b'8gUZqecerjGpjkiY8dIkGudP6GfapWi5MU","s":"0","d":"E1tSV5RBIG7dGPN' b'2Oof5DmZCqgGgpF7P9BbfOTnOEEpM"}}-AADAApIX866iuD6j14MFQbVdiJHMeTM' b'Svd2EoibE7PPfwU7f6HcDCwmLmMCNpRVwM-Kf1kKIor7TETSX80jrliA_XBgAB1h' b'phj5XH3E0oTANv6GVwJ5s0ZnLIPSYoBuvXaPOzWgW3nynVPwWnqCNuP7rdh-1NVB' b'QUc9QHqrDWVnJaoVo5CQAC9PBjGWWN9J6jQXcLmQOfQxrWL3NFm93r7-nDiSbG-T' b'KDvbcXcnoLfCitTt_B96JlvIpe6cI8DJZw3_SERLsaCg{"v":"KERI10JSON0001' b'05_","i":"EBfdpo5wnI3XTcdUIgJRf1-xLhy8Ud8lrykGGHz2vlMw","s":"5",' b'"t":"vrc","d":"EBjW8_7rqnAXV0Il5BJ4XWZcIb355Ltj-9F9JRZLn75c","a"' b':{"i":"EiRjCnZfca8gUZqecerjGpjkiY8dIkGudP6GfapWi5MU","s":"0","d"' b':"E1tSV5RBIG7dGPN2Oof5DmZCqgGgpF7P9BbfOTnOEEpM"}}-AADAApBHqjI7V9' b'yrCqUP1ZsnSHov3nNF90QNZEwPGZToAf6l3KeXPh4UQMZU70-5Cbbs2mswX8_Tg4' b'5orHQz_mQkMCgABF3FoOib-wh0KQ26kdzfEBtnenPVN12GiP7NpIy2j3wW-enfJc' b'gRTEE3XWVekl3IkU3o70Cnk4K1PONYCrO6hAwACWMhg7tNGae9I4mLtv5rVpb9Rr' b'G70zGIwBDxN4QahABHlAvRdDpaSE5BpJ7nlOkShOZIva-qdcWS5TiRX8I43DQ{"v' b'":"KERI10JSON000105_","i":"EBfdpo5wnI3XTcdUIgJRf1-xLhy8Ud8lrykGG' b'Hz2vlMw","s":"6","t":"vrc","d":"E8BEZ7sVSL-vamQnB8Oc72ov-gpiXJzL' b'GXeiAW9_Vht8","a":{"i":"EiRjCnZfca8gUZqecerjGpjkiY8dIkGudP6GfapW' b'i5MU","s":"0","d":"E1tSV5RBIG7dGPN2Oof5DmZCqgGgpF7P9BbfOTnOEEpM"' b'}}-AADAAlQ8kt9KwijVTzAS8-LUziqMPwvLDhoU9sVHN0a9wkICnezEmzrb4skeO' b'wdNVbpek3Wn6xcRxa5wCuF9ub3T-CAAByaYGW-0ZX6oDmjk70BOpkRl8JvgVCm9w' b'skxESXXFcMs_FWssXcUH1oDRzA2q7BMW80DpEtKtcY8phmbH8TTBBwACQd7bqYf-' b'hcHe2B_FESYMXH2SloJ1o7XOry4KyBxZ9oJwtoa0iR4JPScb4_ix1p8p9n3HGMXT' b'_Lou1q1l6AGAAQ') # Play camMsgs to Deb # create non-local kevery for Deb to process msgs from Cam debKevery = eventing.Kevery(kevers=debHab.kevers, db=debHab.db, framed=True, opre=debHab.pre, local=False) 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":"KERI10JSON000105_","i":"EiRjCnZfca8gUZqecerjGpjkiY8dIkGudP' b'6GfapWi5MU","s":"0","t":"vrc","d":"E1tSV5RBIG7dGPN2Oof5DmZCqgGgp' b'F7P9BbfOTnOEEpM","a":{"i":"EBfdpo5wnI3XTcdUIgJRf1-xLhy8Ud8lrykGG' b'Hz2vlMw","s":"2","d":"Ew3t8tlmqfRSwyyRF1nsKLjNOySvj-KTd-SmDu_Ajz' b'uA"}}-AADAAII8AatcRUlekxpknQfnpZJ2KBrATxmFRLxb_zpdPOaG3pCQg6vqP0' b'G96WmJO0hFwaGL-xheGy-SvX_5Q8b0gDQABRgVbtBmb3lR7UjuBjHmny7QkJ6waR' b'MTwz2B_1ANJu9yDa5qsgJiMQ7aTc7lCpLJgZNyKUJaUmW8YJL6JrzteDwAC1zKj3' b'HCcHwhw7OtEVXrgIobJO27d6389xdPXpkdVENb6XbsQLDEPNtv3g2POvWx1vESlp' b'pIfOxaY8VATudBBBg') # Play disjoints debCamVrcs to Cam 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(kevers=bevHab.kevers, db=bevHab.db, framed=True, opre=bevHab.pre, local=False) 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":"BaYh8uaASuDjMUd8_BoNyQs3GwupzmJL8_' b'RBsuNtZHQg","s":"0","t":"icp","kt":"1","k":["BaYh8uaASuDjMUd8_Bo' b'NyQs3GwupzmJL8_RBsuNtZHQg"],"n":"","bt":"0","b":[],"c":[],"a":[]' b'}-AABAA8dCt6i3swKOHoV10pEEOT7LOHxDWCfPWJm0Qvf6CXNaxTEOthHVgLihIz' b'1ZwQYc_nvunt0Hkh5TnnG4OmnulCQ{"v":"KERI10JSON000091_","i":"EBfdp' b'o5wnI3XTcdUIgJRf1-xLhy8Ud8lrykGGHz2vlMw","s":"0","t":"rct","d":"' b'E5OQH-DOSjcX8JlBtznPaaawhP0iuZhjf9cxWVAXNTX0"}-CABBaYh8uaASuDjMU' b'd8_BoNyQs3GwupzmJL8_RBsuNtZHQg0B1G77zOmX-GYRN5yk5X704dneyog8BHJI' b'tCZdLmXl4Tlfd-bE3K8WpbApL_-n1o18Ato90tRhAIZjuBIlxF9vAg{"v":"KERI' b'10JSON000091_","i":"EBfdpo5wnI3XTcdUIgJRf1-xLhy8Ud8lrykGGHz2vlMw' b'","s":"1","t":"rct","d":"EjevD0KmiBZQHqVNNDmpTfrp0lqZI5eicRRNf3O' b'qLW9o"}-CABBaYh8uaASuDjMUd8_BoNyQs3GwupzmJL8_RBsuNtZHQg0BO7JjY0o' b'HH5z68S4ZlYUAOAFnMfRu6OZB9hMGgu6teSzvL_3kzAiiPig6vchlnXDxmKFWMDL' b'XAZsCBN3T0chVCw{"v":"KERI10JSON000091_","i":"EBfdpo5wnI3XTcdUIgJ' b'Rf1-xLhy8Ud8lrykGGHz2vlMw","s":"2","t":"rct","d":"Ew3t8tlmqfRSwy' b'yRF1nsKLjNOySvj-KTd-SmDu_AjzuA"}-CABBaYh8uaASuDjMUd8_BoNyQs3Gwup' b'zmJL8_RBsuNtZHQg0BBkB5LzkcturaQSzTGH_KrWsEJR-x_CH8UPl9FQ1Dc461z5' b'-Fdn3TLJ7DpUw-6VrbKGGjuDy2Nkg0xJdzh4F8CQ{"v":"KERI10JSON000091_"' b',"i":"EBfdpo5wnI3XTcdUIgJRf1-xLhy8Ud8lrykGGHz2vlMw","s":"3","t":' b'"rct","d":"EY_w2vUVqsE6jdgdxJVvMW3434NG1w_asCW7ohG1nmMY"}-CABBaY' b'h8uaASuDjMUd8_BoNyQs3GwupzmJL8_RBsuNtZHQg0BraP5JCHU-ZQwsDAWuLu_f' b'vvYmkpVEu071l5P7fwHzqLbJ7kkvpSsXcGs2HpW_Bw_fjp07LfnN4de5zn7-owxA' b'g{"v":"KERI10JSON000091_","i":"EBfdpo5wnI3XTcdUIgJRf1-xLhy8Ud8lr' b'ykGGHz2vlMw","s":"4","t":"rct","d":"EwJ79SUIE69dA0my9ai9hK3yH8cq' b'qyD9CS62lyRTDn-o"}-CABBaYh8uaASuDjMUd8_BoNyQs3GwupzmJL8_RBsuNtZH' b'Qg0BpIX866iuD6j14MFQbVdiJHMeTMSvd2EoibE7PPfwU7f6HcDCwmLmMCNpRVwM' b'-Kf1kKIor7TETSX80jrliA_XBg{"v":"KERI10JSON000091_","i":"EBfdpo5w' b'nI3XTcdUIgJRf1-xLhy8Ud8lrykGGHz2vlMw","s":"5","t":"rct","d":"EBj' b'W8_7rqnAXV0Il5BJ4XWZcIb355Ltj-9F9JRZLn75c"}-CABBaYh8uaASuDjMUd8_' b'BoNyQs3GwupzmJL8_RBsuNtZHQg0BpBHqjI7V9yrCqUP1ZsnSHov3nNF90QNZEwP' b'GZToAf6l3KeXPh4UQMZU70-5Cbbs2mswX8_Tg45orHQz_mQkMCg{"v":"KERI10J' b'SON000091_","i":"EBfdpo5wnI3XTcdUIgJRf1-xLhy8Ud8lrykGGHz2vlMw","' b's":"6","t":"rct","d":"E8BEZ7sVSL-vamQnB8Oc72ov-gpiXJzLGXeiAW9_Vh' b't8"}-CABBaYh8uaASuDjMUd8_BoNyQs3GwupzmJL8_RBsuNtZHQg0BlQ8kt9Kwij' b'VTzAS8-LUziqMPwvLDhoU9sVHN0a9wkICnezEmzrb4skeOwdNVbpek3Wn6xcRxa5' b'wCuF9ub3T-CA') # Play bevMsgs to Deb 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":"KERI10JSON000105_","i":"BaYh8uaASuDjMUd8_BoNyQs3GwupzmJL8_' b'RBsuNtZHQg","s":"0","t":"vrc","d":"EW4yC5ZUXv8xhM3gXDvKwOCZkltCh' b'RZe-hTb2mi1Zf04","a":{"i":"EBfdpo5wnI3XTcdUIgJRf1-xLhy8Ud8lrykGG' b'Hz2vlMw","s":"2","d":"Ew3t8tlmqfRSwyyRF1nsKLjNOySvj-KTd-SmDu_Ajz' b'uA"}}-AADAAmQ-kOahYYNCaatYN5YHfuruD93tOhJNQCt7Wy6LUCCkITxSj7Ogux' b'aDrBo15FN7wk-BTgEV8ufOIsxhqVfmVBgAB5DhNTiOesOQxfxSn-0D7Ec9_S80xO' b'9ck6Q6FKROXz2Evd4_TwfzMbgJKjSPXqkA16zju5GN6aDWeGWCJOTceDwACrkW_1' b'_sKmtEWtlcON3IGzRygPc0tF-f5qTRJewOEIRIhCB81WnDi8PBa7F43YzSoJiSGV' b'_PgAcg6zh6q8wxVDQ') # Play disjoints debBevVrcs to Bev 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.cloneIter(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.cloneIter(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 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 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(kevers=artHab.kevers, db=artHab.db, framed=True, opre=artHab.pre, local=False) # process Cam's inception so Art will proces Cam's vrcs without escrowing camIcpMsg = camHab.makeOwnInception() artKevery.process(ims=bytearray(camIcpMsg)) assert camHab.pre in artKevery.kevers assert len(artKevery.cues) == 1 artKevery.process(ims=bytearray(debFelMsgs), cloned=True) # give copy to process 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"""