def gen_nontransferable_serialized_aid(): with openDB() as bsr: # Inception: Non-transferable (ephemeral) case signer0 = Signer( transferable=False) # original signing keypair non transferable assert signer0.code == CryOneDex.Ed25519_Seed assert signer0.verfer.code == CryOneDex.Ed25519N keys0 = [signer0.verfer.qb64] serder = incept(keys=keys0) # default nxt is empty so abandoned # Derive AID from ked aid0 = Prefixer(ked=serder.ked, code=CryOneDex.Ed25519N) # update ked with pre serder.ked["pre"] = aid0.qb64 # Serialize ked0 tser0 = Serder(ked=serder.ked) # sign serialization skp0 = Signer() # original signing keypair transferable default tsig0 = skp0.sign(tser0.raw, index=0) # verify signature assert skp0.verfer.verify(tsig0.raw, tser0.raw) # not sure why this errors out when enabled; I guess kevers can't be used with nontransferable ids # kever = Kever(serder=tser0, sigers=[tsig0], baser=bsr) # no error # return base 64 serialization of signed aid return tsig0.qb64
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_serder_suber(): """ Test SerderSuber LMDBer sub database class """ with dbing.openLMDB() as db: assert isinstance(db, dbing.LMDBer) assert db.name == "test" assert db.opened sdb = subing.SerderSuber(db=db, subkey='bags.') assert isinstance(sdb, subing.SerderSuber) pre = "BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc" srdr0 = eventing.incept(keys=[pre]) keys = (pre, srdr0.dig) sdb.put(keys=keys, srdr=srdr0) actual = sdb.get(keys=keys) assert isinstance(actual, coring.Serder) assert actual.dig == srdr0.dig sdb.rem(keys) actual = sdb.get(keys=keys) assert actual is None sdb.put(keys=keys, srdr=srdr0) actual = sdb.get(keys=keys) assert isinstance(actual, coring.Serder) assert actual.dig == srdr0.dig srdr1 = eventing.rotate(pre=pre, keys=[pre], dig=srdr0.dig) result = sdb.put(keys=keys, srdr=srdr1) assert not result assert isinstance(actual, coring.Serder) assert actual.dig == srdr0.dig result = sdb.pin(keys=keys, srdr=srdr1) assert result actual = sdb.get(keys=keys) assert isinstance(actual, coring.Serder) assert actual.dig == srdr1.dig # test with keys as string not tuple keys = "{}.{}".format(pre, srdr1.dig) sdb.put(keys=keys, srdr=srdr1) actual = sdb.get(keys=keys) assert isinstance(actual, coring.Serder) assert actual.dig == srdr1.dig sdb.rem(keys) actual = sdb.get(keys=keys) assert actual is None # test missing entry at keys badkey = "badkey" actual = sdb.get(badkey) assert actual is None # test iteritems sdb = subing.SerderSuber(db=db, subkey='pugs.') assert isinstance(sdb, subing.SerderSuber) sdb.put(keys=("a", "1"), srdr=srdr0) sdb.put(keys=("a", "2"), srdr=srdr1) items = [(keys, srdr.dig) for keys, srdr in sdb.getItemIter()] assert items == [(('a', '1'), srdr0.dig), (('a', '2'), srdr1.dig)] assert not os.path.exists(db.path) assert not db.opened
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_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 = eventing.Kevery(db=coeLogger) valKevery = eventing.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=eventing.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 parsing.Parser().parseOne(ims=bytearray(cmsg), kvy=coeKevery) # 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=eventing.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 parsing.Parser().parseOne(ims=bytearray(vmsg), kvy=valKevery) # 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 parsing.Parser().parse(ims=bytearray(cmsg), kvy=valKevery) # 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 trans receipt reserder = receipt(pre=coeK.prefixer.qb64, sn=coeK.sn, dig=coeK.serder.diger.qb64) #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, seal=seal) assert len(rmsg) == 353 parsing.Parser().parseOne(ims=bytearray(rmsg), kvy=valKevery) # 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 parsing.Parser().parse(ims=vmsg, kvy=coeKevery) # 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 = receipt(pre=coeK.prefixer.qb64, sn=10, dig=fake) # sign event not receipt sigers = valMgr.sign(ser=coeIcpRaw, verfers=valVerfers) # return Siger if index # create receipt message vmsg = messagize(reserder, sigers=sigers, seal=seal) parsing.Parser().parse(ims=bytearray(vmsg), kvy=coeKevery) # 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 trans receipt reserder = receipt(pre=valK.prefixer.qb64, sn=valK.sn, dig=valK.serder.diger.qb64,) # 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))) sigers = coeMgr.sign(ser=valIcpRaw, verfers=coeVerfers) # return Siger if index # create receipt message cmsg = messagize(reserder, sigers=sigers, seal=seal) # controller process own receipt in own Kevery so have copy in own log parsing.Parser().parseOne(ims=bytearray(cmsg), kvy=coeKevery) # coeKevery.processOne(ims=bytearray(cmsg)) # make copy # Simulate sending controller's receipt of validator's inception message to validator parsing.Parser().parse(ims=cmsg, kvy=valKevery) # 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=eventing.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 parsing.Parser().parseOne(ims=bytearray(cmsg), kvy=coeKevery) # 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 parsing.Parser().parse(ims=cmsg, kvy=valKevery) # 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 = receipt(pre=coeK.prefixer.qb64, sn=coeK.sn, dig=coeK.serder.diger.qb64) # 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, seal=seal) # validator process own receipt in own kevery so have copy in own log parsing.Parser().parseOne(ims=bytearray(vmsg), kvy=valKevery) # valKevery.processOne(ims=bytearray(vmsg)) # make copy # Simulate send to controller of validator's receipt of controller's rotation message parsing.Parser().parse(ims=vmsg, kvy=coeKevery) # 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 parsing.Parser().parseOne(ims=bytearray(cmsg), kvy=coeKevery) # 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 parsing.Parser().parse(ims=cmsg, kvy=valKevery) # 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 = receipt(pre=coeK.prefixer.qb64, sn=coeK.sn, dig=coeK.serder.diger.qb64) # 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, seal=seal) # validator process own receipt in own kevery so have copy in own log parsing.Parser().parseOne(ims=bytearray(vmsg), kvy=valKevery) # valKevery.processOne(ims=bytearray(vmsg)) # make copy # Simulate send to controller of validator's receipt of controller's rotation message parsing.Parser().parse(ims=bytearray(vmsg), kvy=coeKevery) # 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_uselogger(): """ Test using logger to """ # Some secrets to use on the events secrets = [ 'ArwXoACJgOleVZ2PY7kXn7rA0II0mHYDhc6WrBH8fDAc', 'A6zz7M08-HQSFq92sJ8KJOT2cZ47x7pXFQLPB0pckB3Q', 'AcwFTk-wgk3ZT2buPRIbK-zxgPx-TKbaegQvPEivN90Y', 'Alntkt3u6dDgiQxTATr01dy8M72uuaZEf9eTdM-70Gk8', 'A1-QxDkso9-MR1A8rZz_Naw6fgaAtayda8hrbkRVVu1E', 'AKuYMe09COczwf2nIoD5AE119n7GLFOVFlNLxZcKuswc', 'AxFfJTcSuEE11FINfXMqWttkZGnUZ8KaREhrnyAXTsjw', 'ALq-w1UKkdrppwZzGTtz4PWYEeWm0-sDHzOv5sq96xJY' ] # create signers from the secrets signers = [Signer(qb64=secret) for secret in secrets] # faster assert [siger.qb64 for siger in signers] == secrets with openLogger() as lgr: # Event 0 Inception Transferable (nxt digest not empty) 2 0f 3 multisig keys = [ signers[0].verfer.qb64, signers[1].verfer.qb64, signers[2].verfer.qb64 ] count = len(keys) nxtkeys = [ signers[3].verfer.qb64, signers[4].verfer.qb64, signers[5].verfer.qb64 ] sith = 2 code = CryOneDex.Blake3_256 # Blake3 digest of incepting data serder = incept(keys=keys, code=code, sith=sith, nxt=Nexter(keys=nxtkeys).qb64) # sign serialization sigers = [signers[i].sign(serder.raw, index=i) for i in range(count)] # create key event verifier state kever = Kever(serder=serder, sigers=sigers, logger=lgr) # Event 1 Rotation Transferable keys = nxtkeys nxtkeys = [ signers[5].verfer.qb64, signers[6].verfer.qb64, signers[7].verfer.qb64 ] serder = rotate(pre=kever.prefixer.qb64, keys=keys, sith=sith, dig=kever.diger.qb64, nxt=Nexter(keys=nxtkeys).qb64, sn=1) # sign serialization sigers = [ signers[i].sign(serder.raw, index=i - count) for i in range(count, count + count) ] # update key event verifier state kever.update(serder=serder, sigers=sigers) # Event 2 Interaction serder = interact(pre=kever.prefixer.qb64, dig=kever.diger.qb64, sn=2) # sign serialization (keys don't change for signing) sigers = [ signers[i].sign(serder.raw, index=i - count) for i in range(count, count + count) ] # update key event verifier state kever.update(serder=serder, sigers=sigers) assert not os.path.exists(lgr.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 basing.openDB(name="bob") as bobDB, \ keeping.openKS(name="bob") as bobKS, \ basing.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) bob = bobSrdr.ked["i"] assert bob == 'Eta8KLf1zrE5n-HZpgRAnDmxLASZdXEiU9u6aahqR8TI' bobMgr.move(old=verfers[0].qb64, new=bob) # 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 == ( b'{"v":"KERI10JSON0000ed_","i":"Eta8KLf1zrE5n-HZpgRAnDmxLASZdXEiU9' b'u6aahqR8TI","s":"0","t":"icp","kt":"1","k":["DqI2cOZ06RwGNwCovYU' b'WExmdKU983IasmUKMmZflvWdQ"],"n":"E7FuL3Z_KBgt_QAwuZi1lUFNC69wvyH' b'SxnMFUsKjZHss","bt":"0","b":[],"c":[],"a":[]}-AABAAp8S6RgfLwdCEi' b'z0jL9cXaDwTJF6MLuKyXp7EfJtrp2myOikOJVUB-w9UGZc1Y8dnURxhXPSca-ZEU' b'AV73XOaAw') # apply msg to bob's Kevery parsing.Parser().parse(ims=bytearray(msg), kvy=bobKvy) # bobKvy.process(ims=bytearray(msg)) # process local copy of msg bobK = bobKvy.kevers[bob] assert bobK.prefixer.qb64 == bob assert bobK.serder.diger.qb64 == bobSrdr.dig assert bobK.serder.diger.qb64 == 'E1-QL0TCdsBTRaKoakLjFhjSlELK60Vv8WdRaG6zMnTM' # apply msg to del's Kevery parsing.Parser().parse(ims=bytearray(msg), kvy=delKvy) # delKvy.process(ims=bytearray(msg)) # process remote copy of msg assert bob 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 delSrdr = eventing.delcept( keys=[verfer.qb64 for verfer in verfers], delpre=bobK.prefixer.qb64, nxt=coring.Nexter(digs=[diger.qb64 for diger in digers]).qb64) delPre = delSrdr.ked["i"] assert delPre == 'E-9tsnVcfUyXVQyBPGfntoL-xexf4Cldt_EPzHis2W4U' delMgr.move(old=verfers[0].qb64, new=delPre) # move key pair label to prefix assert delSrdr.dig == 'E1x1JOub6oEQkxAxTNFu1Pma6y-lrbprNsaILHJHoPmY' # 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()]) assert bobSrdr.dig == 'E3fUycq1G-P1K1pL2OhvY6ZU-9otSa3hXiCcrxuhjyII' 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 == ( b'{"v":"KERI10JSON000107_","i":"Eta8KLf1zrE5n-HZpgRAnDmxLASZdXEiU9' b'u6aahqR8TI","s":"1","t":"ixn","p":"E1-QL0TCdsBTRaKoakLjFhjSlELK6' b'0Vv8WdRaG6zMnTM","a":[{"i":"E-9tsnVcfUyXVQyBPGfntoL-xexf4Cldt_EP' b'zHis2W4U","s":"0","d":"E1x1JOub6oEQkxAxTNFu1Pma6y-lrbprNsaILHJHo' b'PmY"}]}-AABAAROVSK0qK2gqlr_OUsnHNW_ksCyLVmRaysRne2dI5dweECGIy3_Z' b'uFHyOofiDRt5tRE09PlS0uZdot6byFNr-AA') # apply msg to bob's Kevery parsing.Parser().parse(ims=bytearray(msg), kvy=bobKvy) # 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 parsing.Parser().parse(ims=bytearray(msg), kvy=delKvy) # delKvy.process(ims=bytearray(msg)) # process remote copy of msg assert delKvy.kevers[bob].serder.diger.qb64 == bobSrdr.dig # now create msg with Del's delegated inception event sigers = delMgr.sign(ser=delSrdr.raw, verfers=verfers) #seal = eventing.SealSource(s="{:x}".format(bobK.sn+1), #d=bobSrdr.diger.qb64) 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) counter = coring.Counter(code=coring.CtrDex.SealSourceCouples, count=1) msg.extend(counter.qb64b) seqner = coring.Seqner(sn=bobK.sn) msg.extend(seqner.qb64b) msg.extend(bobSrdr.diger.qb64b) assert msg == ( b'{"v":"KERI10JSON000121_","i":"E-9tsnVcfUyXVQyBPGfntoL-xexf4Cldt_' b'EPzHis2W4U","s":"0","t":"dip","kt":"1","k":["DuK1x8ydpucu3480Jpd' b'1XBfjnCwb3dZ3x5b1CJmuUphA"],"n":"EWWkjZkZDXF74O2bOQ4H5hu4nXDlKg2' b'm4CBEBkUxibiU","bt":"0","b":[],"c":[],"a":[],"di":"Eta8KLf1zrE5n' b'-HZpgRAnDmxLASZdXEiU9u6aahqR8TI"}-AABAA2_8Guj0Gf2JoNTq7hOs4u6eOO' b'WhENALJWDfLxkVcS2uLh753FjtyE80lpeS3to1C9yvENyMnyN4q96ehA4exDA-GA' b'B0AAAAAAAAAAAAAAAAAAAAAAQE3fUycq1G-P1K1pL2OhvY6ZU-9otSa3hXiCcrxu' b'hjyII') # apply Del's delegated inception event message to Del's own Kevery parsing.Parser().parse(ims=bytearray(msg), kvy=delKvy) # delKvy.process(ims=bytearray(msg)) # process remote copy of msg assert delPre in delKvy.kevers delK = delKvy.kevers[delPre] assert delK.delegated assert delK.serder.diger.qb64 == delSrdr.dig couple = delKvy.db.getAes(dbing.dgKey(delPre, delSrdr.dig)) assert couple == seqner.qb64b + bobSrdr.diger.qb64b # apply Del's delegated inception event message to bob's Kevery parsing.Parser().parse(ims=bytearray(msg), kvy=bobKvy) # bobKvy.process(ims=bytearray(msg)) # process local copy of msg assert delPre in bobKvy.kevers # successfully validated bobDelK = bobKvy.kevers[delPre] assert bobDelK.delegated assert bobDelK.serder.diger.qb64 == delSrdr.dig # key state updated so event was validated couple = bobKvy.db.getAes(dbing.dgKey(delPre, delSrdr.dig)) assert couple == seqner.qb64b + bobSrdr.diger.qb64b # 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) delSrdr = eventing.deltate( pre=bobDelK.prefixer.qb64, keys=[verfer.qb64 for verfer in verfers], dig=bobDelK.serder.diger.qb64, sn=bobDelK.sn + 1, nxt=coring.Nexter(digs=[diger.qb64 for diger in digers]).qb64) assert delSrdr.dig == 'EPjLBcb4pp-3PGvSi_fTvLvsqUqFoJ0CVCHvIFfu93Xc' # Now create delegating interaction event seal = eventing.SealEvent(i=bobDelK.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":"Eta8KLf1zrE5n-HZpgRAnDmxLASZdXEiU9' b'u6aahqR8TI","s":"2","t":"ixn","p":"E3fUycq1G-P1K1pL2OhvY6ZU-9otS' b'a3hXiCcrxuhjyII","a":[{"i":"E-9tsnVcfUyXVQyBPGfntoL-xexf4Cldt_EP' b'zHis2W4U","s":"1","d":"EPjLBcb4pp-3PGvSi_fTvLvsqUqFoJ0CVCHvIFfu9' b'3Xc"}]}-AABAAclMVE-bkIn-wPiAqfgR384nWmslQHQvmo2o3xQvd_4Bt6bflc4B' b'AmfBa03KgrDVqmB7qG2VXQbOHevkzOgRdDA') # apply msg to bob's Kevery parsing.Parser().parse(ims=bytearray(msg), kvy=bobKvy) # 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 parsing.Parser().parse(ims=bytearray(msg), kvy=delKvy) # delKvy.process(ims=bytearray(msg)) # process remote copy of msg assert delKvy.kevers[bob].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) counter = coring.Counter(code=coring.CtrDex.SealSourceCouples, count=1) msg.extend(counter.qb64b) seqner = coring.Seqner(sn=bobK.sn) msg.extend(seqner.qb64b) msg.extend(bobSrdr.diger.qb64b) assert msg == ( b'{"v":"KERI10JSON000122_","i":"E-9tsnVcfUyXVQyBPGfntoL-xexf4Cldt_' b'EPzHis2W4U","s":"1","t":"drt","p":"E1x1JOub6oEQkxAxTNFu1Pma6y-lr' b'bprNsaILHJHoPmY","kt":"1","k":["DTf6QZWoet154o9wvzeMuNhLQRr8JaAU' b'eiC6wjB_4_08"],"n":"E8kyiXDfkE7idwWnAZQjHbUZMz-kd_yIMH0miptIFFPo' b'","bt":"0","br":[],"ba":[],"a":[]}-AABAAAVUMNfOl9Fcqx-C3fAYnaxvs' b'iJJO3zG6rP0FQ2WVp__hMEaprrQbJL6-Esnny3U5zvMOqbso17rvecTwmVIwDw-G' b'AB0AAAAAAAAAAAAAAAAAAAAAAgEbOI0OIIFv2VV5bmeSq1pwCn-6b2k6TdWcCbJH' b'E6Ly7o') # apply msg to del's Kevery parsing.Parser().parse(ims=bytearray(msg), kvy=delKvy) # delKvy.process(ims=bytearray(msg)) # process remote copy of msg assert bobDelK.delegated assert delK.serder.diger.qb64 == delSrdr.dig couple = delKvy.db.getAes(dbing.dgKey(delPre, delSrdr.dig)) assert couple == seqner.qb64b + bobSrdr.diger.qb64b # apply Del's delegated inception event message to bob's Kevery parsing.Parser().parse(ims=bytearray(msg), kvy=bobKvy) # bobKvy.process(ims=bytearray(msg)) # process local copy of msg assert bobDelK.delegated assert bobDelK.serder.diger.qb64 == delSrdr.dig # key state updated so event was validated couple = delKvy.db.getAes(dbing.dgKey(delPre, delSrdr.dig)) assert couple == seqner.qb64b + bobSrdr.diger.qb64b # test replay msgs = bytearray() for msg in delKvy.db.clonePreIter(pre=delPre, fn=0): msgs.extend(msg) assert len(msgs) == 1043 assert couple in msgs 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_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_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_indirect_mode_sam_cam_wit_demo(): """ Test indirect mode, bob and eve with witness """ help.ogler.resetLevel(level=logging.DEBUG) # set of secrets (seeds for private keys) camSecrets = [ 'AgjD4nRlycmM5cPcAkfOATAp8wVldRsnc9f1tiwctXlw', 'AKUotEE0eAheKdDJh9QvNmSEmO_bjIav8V_GmctGpuCQ', 'AK-nVhMMJciMPvmF5VZE_9H-nhrgng9aJWf7_UHPtRNM', 'AT2cx-P5YUjIw_SLCHQ0pqoBWGk9s4N1brD-4pD_ANbs', 'Ap5waegfnuP6ezC18w7jQiPyQwYYsp9Yv9rYMlKAYL8k', 'Aqlc_FWWrxpxCo7R12uIz_Y2pHUH2prHx1kjghPa8jT8', 'AagumsL8FeGES7tYcnr_5oN6qcwJzZfLKxoniKUpG4qc', 'ADW3o9m3udwEf0aoOdZLLJdf1aylokP0lwwI_M2J9h0s' ] camSecrecies = [] for secret in camSecrets: # convert secrets to secrecies camSecrecies.append([secret]) # create cam signers camSigners = [coring.Signer(qb64=secret) for secret in camSecrets] assert [signer.qb64 for signer in camSigners] == camSecrets # set of secrets (seeds for private keys) samSecrets = [ 'ArwXoACJgOleVZ2PY7kXn7rA0II0mHYDhc6WrBH8fDAc', 'A6zz7M08-HQSFq92sJ8KJOT2cZ47x7pXFQLPB0pckB3Q', 'AcwFTk-wgk3ZT2buPRIbK-zxgPx-TKbaegQvPEivN90Y', 'Alntkt3u6dDgiQxTATr01dy8M72uuaZEf9eTdM-70Gk8', 'A1-QxDkso9-MR1A8rZz_Naw6fgaAtayda8hrbkRVVu1E', 'AKuYMe09COczwf2nIoD5AE119n7GLFOVFlNLxZcKuswc', 'AxFfJTcSuEE11FINfXMqWttkZGnUZ8KaREhrnyAXTsjw', 'ALq-w1UKkdrppwZzGTtz4PWYEeWm0-sDHzOv5sq96xJY' ] samSecrecies = [] for secret in samSecrets: # convert secrets to secrecies samSecrecies.append([secret]) # create sam signers samSigners = [coring.Signer(qb64=secret) for secret in samSecrets] assert [signer.qb64 for signer in samSigners] == samSecrets with basing.openDB(name="cam") as camDB, keeping.openKS(name="cam") as camKS, \ basing.openDB(name="sam") as samDB, keeping.openKS(name="sam") as samKS, \ basing.openDB(name="wit") as witDB, keeping.openKS(name="wit") as witKS: samPort = 5620 # sam's TCP listening port for server witPort = 5621 # wit' TCP listneing port for server # setup the witness witHab = habbing.Habitat(name='Wit', ks=witKS, db=witDB, isith=1, icount=1, temp=True, transferable=False) wit = witHab.pre assert witHab.ks == witKS assert witHab.db == witDB witServer = serving.Server(host="", port=witPort) witServerDoer = serving.ServerDoer(server=witServer) witDirectant = directing.Directant(hab=witHab, server=witServer) witDoers = [witServerDoer, witDirectant] # setup cam # cam inception transferable (nxt digest not empty) camSerder = eventing.incept( keys=[camSigners[0].verfer.qb64], nxt=coring.Nexter(keys=[camSigners[1].verfer.qb64]).qb64, code=coring.MtrDex.Blake3_256) cam = camSerder.ked["i"] assert cam == 'ED9EB3sA5u2vCPOEmX3d7bEyHiSh7Xi8fjew2KMl3FQM' # sam inception transferable (nxt digest not empty) samSerder = eventing.incept( keys=[samSigners[0].verfer.qb64], wits=[wit], nxt=coring.Nexter(keys=[samSigners[1].verfer.qb64]).qb64, code=coring.MtrDex.Blake3_256) sam = samSerder.ked["i"] assert sam == 'EhnaYUqhHoo8kZaXJuTDCZ-h5ZDx3st4NemgqSITWp48' samHab = habbing.Habitat(name='Sam', ks=samKS, db=samDB, wits=[wit], secrecies=samSecrecies, temp=True) assert samHab.ks == samKS assert samHab.db == samDB assert samHab.iserder.dig == samSerder.dig assert samHab.pre == sam samClient = clienting.Client(host='127.0.0.1', port=witPort) samClientDoer = clienting.ClientDoer(client=samClient) samDirector = demoing.SamDirector(hab=samHab, client=samClient, tock=0.125) assert samDirector.hab == samHab assert samDirector.client == samClient assert id(samDirector.hab.kvy.kevers) == id(samHab.kevers) assert samDirector.hab.kvy.db == samDB assert samDirector.tock == 0.125 samReactor = directing.Reactor(hab=samHab, client=samClient) assert samReactor.hab == samHab assert samReactor.client == samClient assert id(samReactor.hab.kvy.kevers) == id(samHab.kevers) assert samReactor.hab.kvy.db == samDB assert samReactor.hab.psr.ims == samReactor.client.rxbs samServer = serving.Server(host="", port=samPort) samServerDoer = serving.ServerDoer(server=samServer) samDirectant = directing.Directant(hab=samHab, server=samServer) assert samDirectant.hab == samHab assert samDirectant.server == samServer # Sam's Reactants created on demand samDoers = [ samClientDoer, samDirector, samReactor, samServerDoer, samDirectant ] # setup cam camHab = habbing.Habitat(name='Cam', ks=camKS, db=camDB, secrecies=camSecrecies, temp=True) assert camHab.ks == camKS assert camHab.db == camDB assert camHab.iserder.dig == camSerder.dig assert camHab.pre == cam camClient = clienting.Client(host='127.0.0.1', port=witPort) camClientDoer = clienting.ClientDoer(client=camClient) camDirector = demoing.CamDirector(hab=camHab, remotePre=sam, client=camClient, tock=0.125) assert camDirector.hab == camHab assert camDirector.client == camClient assert id(camDirector.hab.kvy.kevers) == id(camHab.kevers) assert camDirector.hab.kvy.db == camDB assert camDirector.tock == 0.125 camReactor = directing.Reactor(hab=camHab, client=camClient, indirect=True) assert camReactor.hab == camHab assert camReactor.client == camClient assert id(camReactor.hab.kvy.kevers) == id(camHab.kevers) assert camReactor.hab.kvy.db == camDB assert camReactor.hab.psr.ims == camReactor.client.rxbs camDoers = [camClientDoer, camDirector, camReactor] # Manually stage SamDoers and wit doers and then camDoers tock = 0.03125 doist = doing.Doist(doers=samDoers + witDoers, tock=tock) # manually prep doers doist.done = False doist.enter() # injects doist.tymth() dependency to all doers assert len(doist.deeds) == len(samDoers + witDoers) while doist.tyme < doist.tock * 16: doist.recur() # iterate 16 times time.sleep(doist.tock) assert len(doist.deeds) == len(samDoers + witDoers) assert not doist.done assert samHab.pre in samHab.kevers # now start up cam doers doist.extend(camDoers) assert len(doist.deeds) == len(samDoers + witDoers + camDoers) while doist.tyme < doist.tock * 32: doist.recur() # iterate 16 times time.sleep(doist.tock) assert len(doist.deeds) == len(samDoers + witDoers + camDoers) - 1 # camDirector completes assert camDirector.done assert not doist.done assert camHab.pre in camHab.kevers assert samHab.pre in camHab.kevers # verify final event states doist.exit() assert samClient.opened is False assert samServer.opened is False assert camClient.opened is False assert not os.path.exists(camDB.path) assert not os.path.exists(samDB.path) help.ogler.resetLevel(level=help.ogler.level) """End Test"""
def test_parser(): """ Test the support functionality for Parser stream processor """ logger.setLevel("ERROR") # Test sequence of events given set of secrets secrets = [ 'ArwXoACJgOleVZ2PY7kXn7rA0II0mHYDhc6WrBH8fDAc', 'A6zz7M08-HQSFq92sJ8KJOT2cZ47x7pXFQLPB0pckB3Q', 'AcwFTk-wgk3ZT2buPRIbK-zxgPx-TKbaegQvPEivN90Y', 'Alntkt3u6dDgiQxTATr01dy8M72uuaZEf9eTdM-70Gk8', 'A1-QxDkso9-MR1A8rZz_Naw6fgaAtayda8hrbkRVVu1E', 'AKuYMe09COczwf2nIoD5AE119n7GLFOVFlNLxZcKuswc', 'AxFfJTcSuEE11FINfXMqWttkZGnUZ8KaREhrnyAXTsjw', 'ALq-w1UKkdrppwZzGTtz4PWYEeWm0-sDHzOv5sq96xJY' ] with openDB("controller") as conDB, openDB("validator") as valDB: event_digs = [] # list of event digs in sequence # create event stream msgs = bytearray() # create signers signers = [Signer(qb64=secret) for secret in secrets] # faster assert [signer.qb64 for signer in signers] == secrets # Event 0 Inception Transferable (nxt digest not empty) serder = incept(keys=[signers[0].verfer.qb64], nxt=Nexter(keys=[signers[1].verfer.qb64]).qb64) event_digs.append(serder.dig) # create sig counter counter = Counter(CtrDex.ControllerIdxSigs) # default is count = 1 # sign serialization siger = signers[0].sign(serder.raw, index=0) # return siger # create key event verifier state kever = Kever(serder=serder, sigers=[siger], db=conDB) #extend key event stream msgs.extend(serder.raw) msgs.extend(counter.qb64b) msgs.extend(siger.qb64b) assert msgs == bytearray( b'{"v":"KERI10JSON0000ed_","i":"DSuhyBcPZEZLK-fcw5tzHn2N46wRCG_ZOo' b'eKtWTOunRA","s":"0","t":"icp","kt":"1","k":["DSuhyBcPZEZLK-fcw5t' b'zHn2N46wRCG_ZOoeKtWTOunRA"],"n":"EPYuj8mq_PYYsoBKkzX1kxSPGYBWaIy' b'a3slgCOyOtlqU","bt":"0","b":[],"c":[],"a":[]}-AABAAmagesCSY8QhYY' b'HCJXEWpsGD62qoLt2uyT0_Mq5lZPR88JyS5UrwFKFdcjPqyKc_SKaKDJhkGWCk07' b'k_kVkjyCA') # Event 1 Rotation Transferable serder = rotate(pre=kever.prefixer.qb64, keys=[signers[1].verfer.qb64], dig=kever.serder.diger.qb64, nxt=Nexter(keys=[signers[2].verfer.qb64]).qb64, sn=1) event_digs.append(serder.dig) # create sig counter counter = Counter(CtrDex.ControllerIdxSigs) # default is count = 1 # sign serialization siger = signers[1].sign(serder.raw, index=0) # returns siger # update key event verifier state kever.update(serder=serder, sigers=[siger]) #extend key event stream msgs.extend(serder.raw) msgs.extend(counter.qb64b) msgs.extend(siger.qb64b) # Event 2 Rotation Transferable serder = rotate(pre=kever.prefixer.qb64, keys=[signers[2].verfer.qb64], dig=kever.serder.diger.qb64, nxt=Nexter(keys=[signers[3].verfer.qb64]).qb64, sn=2) event_digs.append(serder.dig) # create sig counter counter = Counter(CtrDex.ControllerIdxSigs) # default is count = 1 # sign serialization siger = signers[2].sign(serder.raw, index=0) # update key event verifier state kever.update(serder=serder, sigers=[siger]) #extend key event stream msgs.extend(serder.raw) msgs.extend(counter.qb64b) msgs.extend(siger.qb64b) # Event 3 Interaction serder = interact(pre=kever.prefixer.qb64, dig=kever.serder.diger.qb64, sn=3) event_digs.append(serder.dig) # create sig counter counter = Counter(CtrDex.ControllerIdxSigs) # default is count = 1 # sign serialization siger = signers[2].sign(serder.raw, index=0) # update key event verifier state kever.update(serder=serder, sigers=[siger]) #extend key event stream msgs.extend(serder.raw) msgs.extend(counter.qb64b) msgs.extend(siger.qb64b) # Event 4 Interaction serder = interact(pre=kever.prefixer.qb64, dig=kever.serder.diger.qb64, sn=4) event_digs.append(serder.dig) # create sig counter counter = Counter(CtrDex.ControllerIdxSigs) # default is count = 1 # sign serialization siger = signers[2].sign(serder.raw, index=0) # update key event verifier state kever.update(serder=serder, sigers=[siger]) #extend key event stream msgs.extend(serder.raw) msgs.extend(counter.qb64b) msgs.extend(siger.qb64b) # Event 5 Rotation Transferable serder = rotate(pre=kever.prefixer.qb64, keys=[signers[3].verfer.qb64], dig=kever.serder.diger.qb64, nxt=Nexter(keys=[signers[4].verfer.qb64]).qb64, sn=5) event_digs.append(serder.dig) # create sig counter counter = Counter(CtrDex.ControllerIdxSigs) # default is count = 1 # sign serialization siger = signers[3].sign(serder.raw, index=0) # update key event verifier state kever.update(serder=serder, sigers=[siger]) #extend key event stream msgs.extend(serder.raw) msgs.extend(counter.qb64b) msgs.extend(siger.qb64b) # Event 6 Interaction serder = interact(pre=kever.prefixer.qb64, dig=kever.serder.diger.qb64, sn=6) event_digs.append(serder.dig) # create sig counter counter = Counter(CtrDex.ControllerIdxSigs) # default is count = 1 # sign serialization siger = signers[3].sign(serder.raw, index=0) # update key event verifier state kever.update(serder=serder, sigers=[siger]) #extend key event stream msgs.extend(serder.raw) msgs.extend(counter.qb64b) msgs.extend(siger.qb64b) # Event 7 Rotation to null NonTransferable Abandon # nxt digest is empty serder = rotate(pre=kever.prefixer.qb64, keys=[signers[4].verfer.qb64], dig=kever.serder.diger.qb64, nxt="", sn=7) event_digs.append(serder.dig) # create sig counter counter = Counter(CtrDex.ControllerIdxSigs) # default is count = 1 # sign serialization siger = signers[4].sign(serder.raw, index=0) # update key event verifier state kever.update(serder=serder, sigers=[siger]) #extend key event stream msgs.extend(serder.raw) msgs.extend(counter.qb64b) msgs.extend(siger.qb64b) # Event 8 Interaction serder = interact(pre=kever.prefixer.qb64, dig=kever.serder.diger.qb64, sn=8) # create sig counter counter = Counter(CtrDex.ControllerIdxSigs) # default is count = 1 # sign serialization siger = signers[4].sign(serder.raw, index=0) # update key event verifier state with pytest.raises( ValidationError): # nulled so reject any more events kever.update(serder=serder, sigers=[siger]) #extend key event stream msgs.extend(serder.raw) msgs.extend(counter.qb64b) msgs.extend(siger.qb64b) # Event 8 Rotation serder = rotate(pre=kever.prefixer.qb64, keys=[signers[4].verfer.qb64], dig=kever.serder.diger.qb64, nxt=Nexter(keys=[signers[5].verfer.qb64]).qb64, sn=8) # create sig counter counter = Counter(CtrDex.ControllerIdxSigs) # default is count = 1 # sign serialization siger = signers[4].sign(serder.raw, index=0) # update key event verifier state with pytest.raises( ValidationError): # nontransferable so reject update kever.update(serder=serder, sigers=[siger]) #extend key event stream msgs.extend(serder.raw) msgs.extend(counter.qb64b) msgs.extend(siger.qb64b) assert len(msgs) == 3171 pre = kever.prefixer.qb64 db_digs = [ bytes(val).decode("utf-8") for val in kever.db.getKelIter(pre) ] assert db_digs == event_digs kevery = Kevery(db=valDB) parser = parsing.Parser(kvy=kevery) parser.parse(ims=bytearray(msgs)) # make copy assert parser.ims == bytearray(b'') # emptied assert pre in kevery.kevers vkever = kevery.kevers[pre] assert vkever.sn == kever.sn assert vkever.verfers[0].qb64 == kever.verfers[0].qb64 assert vkever.verfers[0].qb64 == signers[4].verfer.qb64 db_digs = [ bytes(val).decode("utf-8") for val in kevery.db.getKelIter(pre) ] assert db_digs == event_digs parser = parsing.Parser() # no kevery parser.parse(ims=msgs) assert parser.ims == bytearray(b'') assert not os.path.exists(kevery.db.path) assert not os.path.exists(kever.db.path) """ Done Test """
def test_exchanger(): sidSalt = coring.Salter(raw=b'0123456789abcdef').qb64 redSalt = coring.Salter(raw=b'abcdef0123456789').qb64 with basing.openDB(name="sid") as sidDB, \ keeping.openKS(name="sid") as sidKS, \ basing.openDB(name="red") as redDB, \ keeping.openKS(name="red") as redKS: limit = 1.0 tock = 0.03125 doist = doing.Doist(limit=limit, tock=tock) # Init key pair managers sidMgr = keeping.Manager(ks=sidKS, salt=sidSalt) # Init Keverys sidKvy = eventing.Kevery(db=sidDB) redHab = habbing.Habitat(ks=redKS, db=redDB, temp=True) redKvy = eventing.Kevery(db=redDB) # Setup sid by creating inception event verfers, digers, cst, nst = sidMgr.incept( stem='sid', temp=True) # algo default salty and rooted sidSrdr = eventing.incept( keys=[verfer.qb64 for verfer in verfers], nxt=coring.Nexter(digs=[diger.qb64 for diger in digers]).qb64, code=coring.MtrDex.Blake3_256) sidPre = sidSrdr.ked["i"] sidMgr.move(old=verfers[0].qb64, new=sidPre) # move key pair label to prefix sigers = sidMgr.sign(ser=sidSrdr.raw, verfers=verfers) excMsg = bytearray(sidSrdr.raw) counter = coring.Counter(code=coring.CtrDex.ControllerIdxSigs, count=len(sigers)) excMsg.extend(counter.qb64b) for siger in sigers: excMsg.extend(siger.qb64b) sidIcpMsg = excMsg # save for later parsing.Parser().parse(ims=bytearray(sidIcpMsg), kvy=redKvy) assert redKvy.kevers[sidPre].sn == 0 # accepted event echo = EchoDoer(tymth=doist.tymen()) redExc = exchanging.Exchanger(hab=redHab, tymth=doist.tymen(), handlers=[echo]) pl = dict(x="y") sidExcSrdr = exchanging.exchange(route="/test/message", payload=pl) # Create exn message, sign it and attack Signer Seal sigers = sidMgr.sign(ser=sidExcSrdr.raw, verfers=verfers) excMsg = bytearray(sidExcSrdr.raw) excMsg.extend( coring.Counter(coring.CtrDex.SignerSealCouples, count=1).qb64b) excMsg.extend(sidPre.encode("utf-8")) counter = coring.Counter(code=coring.CtrDex.ControllerIdxSigs, count=len(sigers)) excMsg.extend(counter.qb64b) for siger in sigers: excMsg.extend(siger.qb64b) parsing.Parser().parse(ims=bytearray(excMsg), kvy=redKvy, exc=redExc) doist.do(doers=[redExc]) assert doist.tyme == limit resp = echo.cues.popleft() respSer = coring.Serder(raw=resp.raw) assert respSer.ked['t'] == coring.Ilks.exn assert respSer.ked['r'] == "/test/messageResp" assert respSer.ked['q'] == dict(req=pl)
def test_direct_mode_sam(): """ Test direct mode demo """ # 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' ] # 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.CryOneDex.Blake3_256) bob = bobSerder.ked['pre'] assert bob == 'ETT9n-TCGn8XfkGkcNeNmZgdZSwHPLyDsojFXotBXdSo' # 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' ] # 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.CryOneDex.Blake3_256) eve = eveSerder.ked['pre'] assert eve == 'EwBwUb2eZcA5GDcN7g-87wpreM0nNkLqzkwviBHTcV1A' with dbing.openLogger(name="eve") as eveDB, \ dbing.openLogger(name="bob") as bobDB: 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(secrets=bobSecrets, kevers=bobKevers, db=bobDB) assert bobHab.db == bobDB assert ([signer.verfer.qb64 for signer in bobHab.signers ] == [signer.verfer.qb64 for signer in bobSigners]) assert bobHab.inception.dig == bobSerder.dig assert bobHab.pre == bob bobClient = clienting.Client(host='127.0.0.1', port=evePort) bobClientDoer = doing.ClientDoer(client=bobClient) bobDirector = directing.SamDirector(hab=bobHab, client=bobClient, tock=0.125) assert bobDirector.hab == bobHab assert bobDirector.client == bobClient assert bobDirector.kevery.kevers == bobKevers assert bobDirector.kevery.logger == bobDB assert bobDirector.tock == 0.125 bobReactor = directing.Reactor(hab=bobHab, client=bobClient) assert bobReactor.hab == bobHab assert bobReactor.client == bobClient assert bobReactor.kevery.kevers == bobKevers assert bobReactor.kevery.logger == bobDB assert bobReactor.kevery.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(secrets=eveSecrets, kevers=eveKevers, db=eveDB) assert eveHab.db == eveDB assert ([signer.verfer.qb64 for signer in eveHab.signers ] == [signer.verfer.qb64 for signer in eveSigners]) assert eveHab.inception.dig == eveSerder.dig assert eveHab.pre == eve eveClient = clienting.Client(host='127.0.0.1', port=bobPort) eveClientDoer = doing.ClientDoer(client=eveClient) eveDirector = directing.EveDirector(hab=eveHab, client=eveClient, tock=0.125) assert eveDirector.hab == eveHab assert eveDirector.client == eveClient assert eveDirector.kevery.kevers == eveKevers assert eveDirector.kevery.logger == eveDB eveReactor = directing.Reactor(hab=eveHab, client=eveClient) assert eveReactor.hab == eveHab assert eveReactor.client == eveClient assert eveReactor.kevery.kevers == eveKevers assert eveReactor.kevery.logger == eveDB assert eveReactor.kevery.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 limit = 1.0 tock = 0.03125 doist = doing.Doist(limit=limit, tock=tock) #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 bobHab.pre in bobHab.kevers assert eveHab.pre in eveHab.kevers assert not bobClient.txes assert bobHab.pre in eveHab.kevers # verify final bob event state # verify final val event state assert not os.path.exists(eveDB.path) assert not os.path.exists(bobDB.path) """End Test"""