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"""
