def inceptDo(self, tymth, tock=0.0, **opts):
# enter context
self.wind(tymth)
self.tock = tock
_ = (yield self.tock)
ser = self.hab.kever.serder
wits = self.hab.kever.wits
while True:
dgkey = dbing.dgKey(ser.preb, ser.digb)
rcts = self.hab.db.getWigs(dgkey)
if len(rcts) == len(wits):
break
_ = yield self.tock
print(f'Prefix\t\t{self.hab.pre}')
for idx, verfer in enumerate(self.hab.kever.verfers):
print(f'Public key {idx+1}:\t{verfer.qb64}')
print()
toRemove = [self.ksDoer, self.dbDoer, self.habDoer, self.witDoer]
self.remove(toRemove)
return
def test_witness():
"""
Test event validation logic with witnesses
cam is controller
van is validator
wes is a witness
wok is a witness
wam is a witness
"""
salt = coring.Salter(raw=b'abcdef0123456789').qb64
with dbing.openDB(name="cam") as camDB, keeping.openKS(name="cam") as camKS, \
dbing.openDB(name="van") as vanDB, keeping.openKS(name="van") as vanKS, \
dbing.openDB(name="wes") as wesDB, keeping.openKS(name="wes") as wesKS, \
dbing.openDB(name="wok") as wokDB, keeping.openKS(name="wok") as wokKS, \
dbing.openDB(name="wam") as wamDB, keeping.openKS(name="wam") as wamKS, \
dbing.openDB(name="wil") as wilDB, keeping.openKS(name="wil") as wilKS:
# witnesses first so can setup inception event for cam
wsith = 1
# setup Wes's habitat nontrans
# Wes's receipts will be rcts with a receipt couple attached
wesHab = directing.Habitat(name='wes',
ks=wesKS,
db=wesDB,
isith=wsith,
icount=1,
salt=salt,
transferable=False,
temp=True) # stem is .name
assert wesHab.ks == wesKS
assert wesHab.db == wesDB
assert not wesHab.kever.prefixer.transferable
# create non-local kevery for Wes to process nonlocal msgs
wesKvy = eventing.Kevery(kevers=wesHab.kevers,
db=wesHab.db,
framed=True,
opre=wesHab.pre,
local=False)
# setup Wok's habitat nontrans
# Wok's receipts will be rcts with a receipt couple attached
wokHab = directing.Habitat(name='wok',
ks=wokKS,
db=wokDB,
isith=wsith,
icount=1,
salt=salt,
transferable=False,
temp=True) # stem is .name
assert wokHab.ks == wokKS
assert wokHab.db == wokDB
assert not wokHab.kever.prefixer.transferable
# create non-local kevery for Wok to process nonlocal msgs
wokKvy = eventing.Kevery(kevers=wokHab.kevers,
db=wokHab.db,
framed=True,
opre=wokHab.pre,
local=False)
# setup Wam's habitat nontrans
# Wams's receipts will be rcts with a receipt couple attached
wamHab = directing.Habitat(name='wam',
ks=wamKS,
db=wamDB,
isith=wsith,
icount=1,
salt=salt,
transferable=False,
temp=True) # stem is .name
assert wamHab.ks == wamKS
assert wamHab.db == wamDB
assert not wamHab.kever.prefixer.transferable
# create non-local kevery for Wam to process nonlocal msgs
wamKvy = eventing.Kevery(kevers=wamHab.kevers,
db=wamHab.db,
framed=True,
opre=wamHab.pre,
local=False)
# setup Wil's habitat nontrans
# Wil's receipts will be rcts with a receipt couple attached
wilHab = directing.Habitat(name='wil',
ks=wilKS,
db=wilDB,
isith=wsith,
icount=1,
salt=salt,
transferable=False,
temp=True) # stem is .name
assert wilHab.ks == wilKS
assert wilHab.db == wilDB
assert not wilHab.kever.prefixer.transferable
# create non-local kevery for Wam to process nonlocal msgs
wilKvy = eventing.Kevery(kevers=wilHab.kevers,
db=wilHab.db,
framed=True,
opre=wilHab.pre,
local=False)
# setup Cam's habitat trans multisig
wits = [wesHab.pre, wokHab.pre, wamHab.pre]
csith = 2 # hex str of threshold int
camHab = directing.Habitat(name='cam',
ks=camKS,
db=camDB,
isith=csith,
icount=3,
toad=2,
wits=wits,
salt=salt,
temp=True) # stem is .name
assert camHab.ks == camKS
assert camHab.db == camDB
assert camHab.kever.prefixer.transferable
for werfer in camHab.iserder.werfers:
assert werfer.qb64 in wits
assert camHab.kever.wits == wits
assert camHab.kever.toad == 2
assert camHab.kever.sn == 0
# create non-local kevery for Cam to process onlocal msgs
camKvy = eventing.Kevery(kevers=camHab.kevers,
db=camHab.db,
framed=True,
opre=camHab.pre,
local=False)
# setup Van's habitat trans multisig
vsith = 2 # two of three signing threshold
vanHab = directing.Habitat(name='van',
ks=vanKS,
db=vanDB,
isith=vsith,
icount=3,
salt=salt,
temp=True) # stem is .name
assert vanHab.ks == vanKS
assert vanHab.db == vanDB
assert vanHab.kever.prefixer.transferable
# create non-local kevery for Van to process nonlocal msgs
vanKvy = eventing.Kevery(kevers=vanHab.kevers,
db=vanHab.db,
framed=True,
opre=vanHab.pre,
local=False)
# make list so easier to batch
camWitKvys = [wesKvy, wokKvy, wamKvy]
camWitHabs = [wesHab, wokHab, wamHab]
# Create Cam inception and send to each of Cam's witnesses
camIcpMsg = camHab.makeOwnInception()
rctMsgs = [] # list of receipts from each witness
for i in range(len(camWitKvys)):
kvy = camWitKvys[i]
kvy.process(ims=bytearray(
camIcpMsg)) # send copy of cam icp msg to witness
assert kvy.kevers[camHab.pre].sn == 0 # accepted event
assert len(kvy.cues) == 1 # queued receipt cue
hab = camWitHabs[i]
rctMsg = hab.processCues(kvy.cues) # process cue returns rct msg
assert len(rctMsg) == 559
rctMsgs.append(rctMsg)
for msg in rctMsgs: # process rct msgs from all witnesses
camKvy.process(ims=bytearray(msg)) # make copy
for hab in camWitHabs:
assert hab.pre in camKvy.kevers
# get from Cam database copies of witness receipts received by Cam
# and send to witnesses so all witnesses have full set of receipts
# from all other witnesses
# reply one event or receipt one event with all witness attachments
dgkey = dbing.dgKey(pre=camHab.pre, dig=camHab.kever.serder.dig)
wigs = camHab.db.getWigs(dgkey)
assert len(wigs) == 3
wigers = [coring.Siger(qb64b=bytes(wig)) for wig in wigs]
rserder = eventing.receipt(pre=camHab.pre,
sn=camHab.kever.sn,
dig=camHab.kever.serder.dig)
camIcpWitRctMsg = eventing.messagize(serder=rserder, wigers=wigers)
assert len(camIcpWitRctMsg) == 413
for i in range(len(camWitKvys)):
kvy = camWitKvys[i]
kvy.process(
ims=bytearray(camIcpWitRctMsg)) # send copy of witness rcts
assert len(kvy.db.getWigs(dgkey)) == 3 # fully witnessed
assert len(kvy.cues) == 0 # no cues
# send Cam icp and witness rcts to Van
vanKvy.process(
ims=bytearray(camIcpMsg)) # should escrow since not witnesses
assert camHab.pre not in vanKvy.kevers
vanKvy.process(ims=bytearray(camIcpWitRctMsg))
vanKvy.processEscrows()
assert camHab.pre in vanKvy.kevers
vcKvr = vanKvy.kevers[camHab.pre]
assert vcKvr.sn == 0
assert vcKvr.wits == wits
# Create Cam ixn and send to each of Cam's witnesses
camIxnMsg = camHab.interact()
rctMsgs = [] # list of receipts from each witness
for i in range(len(camWitKvys)):
kvy = camWitKvys[i]
kvy.process(ims=bytearray(
camIxnMsg)) # send copy of cam icp msg to witness
assert kvy.kevers[camHab.pre].sn == 1 # accepted event
assert len(kvy.cues) == 1 # queued receipt cue
hab = camWitHabs[i]
rctMsg = hab.processCues(kvy.cues) # process cue returns rct msg
assert len(rctMsg) == 281
rctMsgs.append(rctMsg)
for msg in rctMsgs: # process rct msgs from all witnesses
camKvy.process(ims=bytearray(msg)) # make copy
for hab in camWitHabs:
assert hab.pre in camKvy.kevers
# get from Cam database copies of witness receipts received by Cam
# and send to witnesses so all witnesses have full set of receipts
# from all other witnesses
# reply one event or receipt one event with all witness attachments
dgkey = dbing.dgKey(pre=camHab.pre, dig=camHab.kever.serder.dig)
wigs = camHab.db.getWigs(dgkey)
assert len(wigs) == 3
wigers = [coring.Siger(qb64b=bytes(wig)) for wig in wigs]
rserder = eventing.receipt(pre=camHab.pre,
sn=camHab.kever.sn,
dig=camHab.kever.serder.dig)
camIxnWitRctMsg = eventing.messagize(serder=rserder, wigers=wigers)
assert len(camIxnWitRctMsg) == 413
for i in range(len(camWitKvys)):
kvy = camWitKvys[i]
kvy.process(
ims=bytearray(camIxnWitRctMsg)) # send copy of witness rcts
assert len(kvy.db.getWigs(dgkey)) == 3 # fully witnessed
assert len(kvy.cues) == 0 # no cues
# send Cam ixn's witness rcts to Van first then send Cam ixn
vanKvy.process(ims=bytearray(camIxnWitRctMsg))
vanKvy.processEscrows()
assert vcKvr.sn == 0
vanKvy.process(
ims=bytearray(camIxnMsg)) # should escrow since not witnesses
assert vcKvr.sn == 0
vanKvy.processEscrows()
assert vcKvr.sn == 1
# Cam replace Wok with Wil as a witness.
# Cam update Wil all event witnessed events for Cam by replay
# Cam update itself with Wil receipts including Wils inception
camReplayMsg = camHab.replay()
assert len(camReplayMsg) == 1824
wilKvy.process(ims=bytearray(camReplayMsg))
assert camHab.pre in wilKvy.kevers
assert wilKvy.kevers[camHab.pre].sn == 1 # asscepted both events
assert len(wilKvy.cues) == 2
wilRctMsg = wilHab.processCues(
wilKvy.cues) # process cue returns rct msg
assert len(wilKvy.cues) == 0
camKvy.process(ims=bytearray(wilRctMsg)) # make copy
assert wilHab.pre in camKvy.kevers
# Cam rotation with witness rotation
camRotMsg = camHab.rotate(toad=2, cuts=[wokHab.pre], adds=[wilHab.pre])
assert camHab.kever.wits == [wesHab.pre, wamHab.pre, wilHab.pre]
assert camHab.kever.toad == 2
assert camHab.kever.sn == 2
# update lists of witness kvys and habs
camWitKvys = [wesKvy, wamKvy, wilKvy]
camWitHabs = [wesHab, wamHab, wilHab]
rctMsgs = [] # list of receipt msgs from each witness
for i in range(len(camWitKvys)):
kvy = camWitKvys[i]
kvy.process(
ims=bytearray(camRotMsg)) # send copy of cam msg to witness
assert kvy.kevers[camHab.pre].sn == 2 # accepted event
assert len(kvy.cues) == 1 # queued receipt cue
hab = camWitHabs[i]
rctMsg = hab.processCues(kvy.cues) # process cue returns rct msg
assert len(rctMsg) == 281
rctMsgs.append(rctMsg)
for msg in rctMsgs: # process rct msgs from all witnesses
camKvy.process(ims=bytearray(msg)) # make copy
for hab in camWitHabs:
assert hab.pre in camKvy.kevers
# get from Cam database copies of witness receipts received by Cam
# and send to witnesses so all witnesses have full set of receipts
# from all other witnesses
# reply one event or receipt one event with all witness attachments
dgkey = dbing.dgKey(pre=camHab.pre, dig=camHab.kever.serder.dig)
wigs = camHab.db.getWigs(dgkey)
assert len(wigs) == 3
wigers = [coring.Siger(qb64b=bytes(wig)) for wig in wigs]
rserder = eventing.receipt(pre=camHab.pre,
sn=camHab.kever.sn,
dig=camHab.kever.serder.dig)
camRotWitRctMsg = eventing.messagize(serder=rserder, wigers=wigers)
assert len(camRotWitRctMsg) == 413
for i in range(len(camWitKvys)):
kvy = camWitKvys[i]
kvy.process(
ims=bytearray(camRotWitRctMsg)) # send copy of witness rcts
assert len(kvy.db.getWigs(dgkey)) == 3 # fully witnessed
assert len(kvy.cues) == 0 # no cues
# send Cam's rot and wit receipts to Van
#vanKvy.process(ims=bytearray(camRotMsg)) # should escrow since not witnesses
#vanKvy.process(ims=bytearray(camRotWitRctMsg))
#vanKvy.processEscrows()
#assert vcKvr.sn == 2
#assert vcKvr.wits == camHab.kever.wits
# send Cam rot's witness rcts to Van first then send Cam rot
vanKvy.process(ims=bytearray(camRotWitRctMsg))
vanKvy.processEscrows()
assert vcKvr.sn == 1
vanKvy.process(
ims=bytearray(camRotMsg)) # should escrow since not witnesses
assert vcKvr.sn == 1
vanKvy.processEscrows()
assert vcKvr.sn == 2
assert vcKvr.wits == camHab.kever.wits
assert not os.path.exists(wokKS.path)
assert not os.path.exists(wokDB.path)
assert not os.path.exists(wesKS.path)
assert not os.path.exists(wesDB.path)
assert not os.path.exists(vanKS.path)
assert not os.path.exists(vanDB.path)
assert not os.path.exists(camKS.path)
assert not os.path.exists(camDB.path)
"""End Test"""
def test_key_funcs():
"""
Test key utility functions
"""
# Bytes
pre = b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
dig = b'EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4'
sn = 3
dts = b'2021-02-13T19:16:50.750302+00:00'
assert snKey(pre, sn) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
b'.00000000000000000000000000000003')
assert splitKey(snKey(pre, sn)) == (pre, b'%032x' % sn)
assert splitKeySN(snKey(pre, sn)) == (pre, sn)
assert dgKey(pre,
dig) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
b'.EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4')
assert splitKey(dgKey(pre, dig)) == (pre, dig)
assert dtKey(pre, dts) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
b'|2021-02-13T19:16:50.750302+00:00')
assert splitKey(dtKey(pre, dts), sep=b'|') == (pre, dts)
assert splitKeyDT(dtKey(pre,
dts)) == (pre,
helping.fromIso8601(dts.decode("utf-8")))
# Str
pre = 'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
dig = 'EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4'
dts = '2021-02-13T19:16:50.750302+00:00'
assert snKey(pre, sn) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
b'.00000000000000000000000000000003')
assert splitKey(snKey(pre, sn).decode("utf-8")) == (pre, '%032x' % sn)
assert splitKeySN(snKey(pre, sn).decode("utf-8")) == (pre, sn)
assert dgKey(pre,
dig) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
b'.EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4')
assert splitKey(dgKey(pre, dig).decode("utf-8")) == (pre, dig)
assert dtKey(pre, dts) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
b'|2021-02-13T19:16:50.750302+00:00')
assert splitKey(dtKey(pre, dts).decode("utf-8"), sep=b'|') == (pre, dts)
assert splitKeyDT(dtKey(pre,
dts).decode("utf-8")) == (pre,
helping.fromIso8601(dts))
with pytest.raises(TypeError):
snKey(pre, sn='3')
with pytest.raises(ValueError):
splitKey(pre)
with pytest.raises(ValueError):
splitKey(dgKey(pre, dgKey(pre, dig)))
# memoryview
# Bytes
pre = b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
dig = b'EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4'
sn = 3
dts = b'2021-02-13T19:16:50.750302+00:00'
key = memoryview(snKey(pre, sn))
assert splitKey(key) == (pre, b'%032x' % sn)
assert splitKeySN(key) == (pre, sn)
key = memoryview(dgKey(pre, dig))
assert splitKey(key) == (pre, dig)
key = memoryview(dtKey(pre, dts))
assert splitKey(key, sep=b'|') == (pre, dts)
assert splitKeyDT(key) == (pre, helping.fromIso8601(dts.decode("utf-8")))
"""Done Test"""
def test_lmdber():
"""
Test LMDBer creation
"""
databaser = LMDBer()
assert isinstance(databaser, LMDBer)
assert databaser.name == "main"
assert databaser.temp == False
assert isinstance(databaser.env, lmdb.Environment)
assert databaser.path.endswith("keri/db/main")
assert databaser.env.path() == databaser.path
assert os.path.exists(databaser.path)
assert databaser.opened
pre = b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
dig = b'EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4'
sn = 3
assert snKey(pre, sn) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
b'.00000000000000000000000000000003')
assert dgKey(pre,
dig) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
b'.EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4')
databaser.close(clear=True)
assert not os.path.exists(databaser.path)
assert not databaser.opened
# test not opened on init
databaser = LMDBer(reopen=False)
assert isinstance(databaser, LMDBer)
assert databaser.name == "main"
assert databaser.temp == False
assert databaser.opened == False
assert databaser.path == None
assert databaser.env == None
databaser.reopen()
assert databaser.opened
assert isinstance(databaser.env, lmdb.Environment)
assert databaser.path.endswith("keri/db/main")
assert databaser.env.path() == databaser.path
assert os.path.exists(databaser.path)
pre = b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
dig = b'EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4'
sn = 3
assert snKey(pre, sn) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
b'.00000000000000000000000000000003')
assert dgKey(pre,
dig) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
b'.EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4')
databaser.close(clear=True)
assert not os.path.exists(databaser.path)
assert not databaser.opened
with openLMDB() as dber:
assert dber.temp == True
#test Val methods
key = b'A'
val = b'whatever'
db = dber.env.open_db(key=b'beep.')
assert dber.getVal(db, key) == None
assert dber.delVal(db, key) == False
assert dber.putVal(db, key, val) == True
assert dber.putVal(db, key, val) == False
assert dber.setVal(db, key, val) == True
assert dber.getVal(db, key) == val
assert dber.delVal(db, key) == True
assert dber.getVal(db, key) == None
# Test getAllItemIter(self, db, key=b'', split=True, sep=b'.')
key = b"a.1"
val = b"wow"
assert dber.putVal(db, key, val) == True
key = b"a.2"
val = b"wee"
assert dber.putVal(db, key, val) == True
key = b"b.1"
val = b"woo"
assert dber.putVal(db, key, val) == True
assert [(bytes(pre), bytes(num), bytes(val))
for pre, num, val in dber.getAllItemIter(db=db)
] == [(b'a', b'1', b'wow'), (b'a', b'2', b'wee'),
(b'b', b'1', b'woo')]
# test OrdVal OrdItem ordinal numbered event sub db
db = dber.env.open_db(key=b'seen.')
preA = b'B8KY1sKmgyjAiUDdUBPNPyrSz_ad_Qf9yzhDNZlEKiMc'
preB = b'EH7Oq9oxCgYa-nnNLvwhp9sFZpALILlRYyB-6n4WDi7w'
preC = b'EpDA1n-WiBA0A8YOqnKrB-wWQYYC49i5zY_qrIZIicQg'
keyA0 = onKey(preA, 0)
keyB0 = onKey(preB, 0)
keyB1 = onKey(preB, 1)
keyB2 = onKey(preB, 2)
keyB3 = onKey(preB, 3)
keyB4 = onKey(preB, 4)
keyC0 = onKey(preC, 0)
digA = b'ER73b7reENuBahMJsMTLbeyyNPsfTRzKRWtJ3ytmInvw'
digU = b'ER73b7reENuBahMJsMTLbeyyNPsfTRzKRWtJ3ytmInvw'
digV = b'EA4vCeJswIBJlO3RqE-wsE72Vt3wAceJ_LzqKvbDtBSY'
digW = b'EyAyl33W9ja_wLX85UrzRnL4KNzlsIKIA7CrD04nVX1w'
digX = b'EEnwxEm5Bg5s5aTLsgQCNpubIYzwlvMwZIzdOM0Z3u7o'
digY = b'Enrq74_Q11S2vHx1gpK_46Ik5Q7Yy9K1zZ5BavqGDKnk'
digC = b'E-5RimdY_OWoreR-Z-Q5G81-I4tjASJCaP_MqkBbtM2w'
assert dber.getVal(db, keyA0) == None
assert dber.delVal(db, keyA0) == False
assert dber.putVal(db, keyA0, val=digA) == True
assert dber.getVal(db, keyA0) == digA
assert dber.putVal(db, keyA0, val=digA) == False
assert dber.setVal(db, keyA0, val=digA) == True
assert dber.getVal(db, keyA0) == digA
assert dber.delVal(db, keyA0) == True
assert dber.getVal(db, keyA0) == None
# test appendOrdValPre
# empty database
assert dber.getVal(db, keyB0) == None
on = dber.appendOrdValPre(db, preB, digU)
assert on == 0
assert dber.getVal(db, keyB0) == digU
assert dber.delVal(db, keyB0) == True
assert dber.getVal(db, keyB0) == None
# earlier pre in database only
assert dber.putVal(db, keyA0, val=digA) == True
on = dber.appendOrdValPre(db, preB, digU)
assert on == 0
assert dber.getVal(db, keyB0) == digU
assert dber.delVal(db, keyB0) == True
assert dber.getVal(db, keyB0) == None
# earlier and later pre in db but not same pre
assert dber.getVal(db, keyA0) == digA
assert dber.putVal(db, keyC0, val=digC) == True
on = dber.appendOrdValPre(db, preB, digU)
assert on == 0
assert dber.getVal(db, keyB0) == digU
assert dber.delVal(db, keyB0) == True
assert dber.getVal(db, keyB0) == None
# later pre only
assert dber.delVal(db, keyA0) == True
assert dber.getVal(db, keyA0) == None
assert dber.getVal(db, keyC0) == digC
on = dber.appendOrdValPre(db, preB, digU)
assert on == 0
assert dber.getVal(db, keyB0) == digU
# earlier pre and later pre and earlier entry for same pre
assert dber.putVal(db, keyA0, val=digA) == True
on = dber.appendOrdValPre(db, preB, digV)
assert on == 1
assert dber.getVal(db, keyB1) == digV
# earlier entry for same pre but only same pre
assert dber.delVal(db, keyA0) == True
assert dber.getVal(db, keyA0) == None
assert dber.delVal(db, keyC0) == True
assert dber.getVal(db, keyC0) == None
# another value for preB
on = dber.appendOrdValPre(db, preB, digW)
assert on == 2
assert dber.getVal(db, keyB2) == digW
# yet another value for preB
on = dber.appendOrdValPre(db, preB, digX)
assert on == 3
assert dber.getVal(db, keyB3) == digX
# yet another value for preB
on = dber.appendOrdValPre(db, preB, digY)
assert on == 4
assert dber.getVal(db, keyB4) == digY
assert dber.cntValsAllPre(db, preB) == 5
# replay preB events in database
items = [item for item in dber.getAllOrdItemPreIter(db, preB)]
assert items == [(0, digU), (1, digV), (2, digW), (3, digX), (4, digY)]
# resume replay preB events at on = 3
items = [item for item in dber.getAllOrdItemPreIter(db, preB, on=3)]
assert items == [(3, digX), (4, digY)]
# resume replay preB events at on = 5
items = [item for item in dber.getAllOrdItemPreIter(db, preB, on=5)]
assert items == []
# replay all events in database with pre events before and after
assert dber.putVal(db, keyA0, val=digA) == True
assert dber.putVal(db, keyC0, val=digC) == True
items = [item for item in dber.getAllOrdItemAllPreIter(db)]
assert items == [(preA, 0, digA), (preB, 0, digU), (preB, 1, digV),
(preB, 2, digW), (preB, 3, digX), (preB, 4, digY),
(preC, 0, digC)]
# resume replay all starting at preB on=2
items = [item for item in dber.getAllOrdItemAllPreIter(db, key=keyB2)]
assert items == [(preB, 2, digW), (preB, 3, digX), (preB, 4, digY),
(preC, 0, digC)]
# resume replay all starting at preC on=1
items = [
item
for item in dber.getAllOrdItemAllPreIter(db, key=onKey(preC, 1))
]
assert items == []
# test Vals dup methods. dup vals are lexocographic
key = b'A'
vals = [b"z", b"m", b"x", b"a"]
db = dber.env.open_db(key=b'boop.', dupsort=True)
assert dber.getVals(db, key) == []
assert dber.delVals(db, key) == False
assert dber.cntVals(db, key) == 0
assert dber.putVals(db, key, vals) == True
assert dber.getVals(db, key) == [b'a', b'm', b'x',
b'z'] # lexocographic order
assert dber.cntVals(db, key) == len(vals) == 4
assert dber.putVals(db, key, vals=[b'a']) == True # duplicate
assert dber.getVals(db, key) == [b'a', b'm', b'x', b'z'] # no change
assert dber.addVal(db, key, val=b'a') == False # duplicate
assert dber.addVal(db, key, val=b'b') == True
assert dber.getVals(db, key) == [b'a', b'b', b'm', b'x', b'z']
assert [val for val in dber.getValsIter(db, key)
] == [b'a', b'b', b'm', b'x', b'z']
assert dber.delVals(db, key) == True
assert dber.getVals(db, key) == []
assert dber.putVals(db, key, vals) == True
for val in vals:
assert dber.delVals(db, key, val)
assert dber.getVals(db, key) == []
assert dber.putVals(db, key, vals) == True
for val in dber.getValsIter(db, key):
assert dber.delVals(
db, key, val) # allows delete fo dup while iter over dups
assert dber.getVals(db, key) == []
# test IoVals insertion order dup methods. dup vals are insertion order
key = b'A'
vals = [b"z", b"m", b"x", b"a"]
db = dber.env.open_db(key=b'peep.', dupsort=True)
assert dber.getIoVals(db, key) == []
assert dber.getIoValLast(db, key) == None
assert dber.cntIoVals(db, key) == 0
assert dber.delIoVals(db, key) == False
assert dber.putIoVals(db, key, vals) == True
assert dber.getIoVals(db, key) == vals # preserved insertion order
assert dber.cntIoVals(db, key) == len(vals) == 4
assert dber.getIoValLast(db, key) == vals[-1]
assert dber.putIoVals(db, key, vals=[b'a']) == False # duplicate
assert dber.getIoVals(db, key) == vals # no change
assert dber.addIoVal(db, key, val=b'b') == True
assert dber.addIoVal(db, key, val=b'a') == False
assert dber.getIoVals(db, key) == [b"z", b"m", b"x", b"a", b"b"]
assert [val for val in dber.getIoValsIter(db, key)
] == [b"z", b"m", b"x", b"a", b'b']
assert dber.delIoVals(db, key) == True
assert dber.getIoVals(db, key) == []
assert dber.putIoVals(db, key, vals) == True
for val in vals:
assert dber.delIoVal(db, key, val)
assert dber.getIoVals(db, key) == []
assert dber.putIoVals(db, key, vals) == True
for val in sorted(vals):
assert dber.delIoVal(db, key, val)
assert dber.getIoVals(db, key) == []
#delete and add in odd order
assert dber.putIoVals(db, key, vals) == True
assert dber.delIoVal(db, key, vals[2])
assert dber.addIoVal(db, key, b'w')
assert dber.delIoVal(db, key, vals[0])
assert dber.addIoVal(db, key, b'e')
assert dber.getIoVals(db, key) == [b'm', b'a', b'w', b'e']
# Test getIoValsAllPreIter(self, db, pre)
vals0 = [b"gamma", b"beta"]
sn = 0
key = snKey(pre, sn)
assert dber.addIoVal(db, key, vals0[0]) == True
assert dber.addIoVal(db, key, vals0[1]) == True
vals1 = [b"mary", b"peter", b"john", b"paul"]
sn += 1
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals1) == True
vals2 = [b"dog", b"cat", b"bird"]
sn += 1
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals2) == True
vals = [bytes(val) for val in dber.getIoValsAllPreIter(db, pre)]
allvals = vals0 + vals1 + vals2
assert vals == allvals
# Test getIoValsLastAllPreIter(self, db, pre)
pre = b'B4ejWzwQPYGGwTmuupUhPx5_yZ-Wk1xEHHzq7K0gzhcc'
vals0 = [b"gamma", b"beta"]
sn = 0
key = snKey(pre, sn)
assert dber.addIoVal(db, key, vals0[0]) == True
assert dber.addIoVal(db, key, vals0[1]) == True
vals1 = [b"mary", b"peter", b"john", b"paul"]
sn += 1
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals1) == True
vals2 = [b"dog", b"cat", b"bird"]
sn += 1
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals2) == True
vals = [bytes(val) for val in dber.getIoValLastAllPreIter(db, pre)]
lastvals = [vals0[-1], vals1[-1], vals2[-1]]
assert vals == lastvals
# Test getIoValsAnyPreIter(self, db, pre)
pre = b'BQPYGGwTmuupUhPx5_yZ-Wk1x4ejWzwEHHzq7K0gzhcc'
vals0 = [b"gamma", b"beta"]
sn = 1 # not start at zero
key = snKey(pre, sn)
assert dber.addIoVal(db, key, vals0[0]) == True
assert dber.addIoVal(db, key, vals0[1]) == True
vals1 = [b"mary", b"peter", b"john", b"paul"]
sn += 1
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals1) == True
vals2 = [b"dog", b"cat", b"bird"]
sn += 2 # gap
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals2) == True
vals = [bytes(val) for val in dber.getIoValsAnyPreIter(db, pre)]
allvals = vals0 + vals1 + vals2
assert vals == allvals
# Setup Tests for getIoItemsNext and getIoItemsNextIter
edb = dber.env.open_db(key=b'escrow.', dupsort=True)
aKey = snKey(pre=b'A', sn=1)
aVals = [b"z", b"m", b"x"]
bKey = snKey(pre=b'A', sn=2)
bVals = [b"o", b"r", b"z"]
cKey = snKey(pre=b'A', sn=4)
cVals = [b"h", b"n"]
dKey = snKey(pre=b'A', sn=7)
dVals = [b"k", b"b"]
assert dber.putIoVals(edb, key=aKey, vals=aVals)
assert dber.putIoVals(edb, key=bKey, vals=bVals)
assert dber.putIoVals(edb, key=cKey, vals=cVals)
assert dber.putIoVals(edb, key=dKey, vals=dVals)
# Test getIoItemsNext(self, db, key=b"")
# aVals
items = dber.getIoItemsNext(edb) # get first key in database
assert items # not empty
ikey = items[0][0]
assert ikey == aKey
vals = [val for key, val in items]
assert vals == aVals
items = dber.getIoItemsNext(edb, key=aKey,
skip=False) # get aKey in database
assert items # not empty
ikey = items[0][0]
assert ikey == aKey
vals = [val for key, val in items]
assert vals == aVals
items = dber.getIoItemsNext(edb, key=aKey) # get bKey in database
assert items # not empty
ikey = items[0][0]
assert ikey == bKey
vals = [val for key, val in items]
assert vals == bVals
items = dber.getIoItemsNext(edb, key=b'',
skip=False) # get first key in database
assert items # not empty
ikey = items[0][0]
assert ikey == aKey
vals = [val for key, val in items]
assert vals == aVals
# bVals
items = dber.getIoItemsNext(edb, key=ikey)
assert items # not empty
ikey = items[0][0]
assert ikey == bKey
vals = [val for key, val in items]
assert vals == bVals
# cVals
items = dber.getIoItemsNext(edb, key=ikey)
assert items # not empty
ikey = items[0][0]
assert ikey == cKey
vals = [val for key, val in items]
assert vals == cVals
# dVals
items = dber.getIoItemsNext(edb, key=ikey)
assert items # not empty
ikey = items[0][0]
assert ikey == dKey
vals = [val for key, val in items]
assert vals == dVals
# none
items = dber.getIoItemsNext(edb, key=ikey)
assert items == [] # empty
assert not items
# Test getIoItemsNextIter(self, db, key=b"")
# get dups at first key in database
# aVals
items = [item for item in dber.getIoItemsNextIter(edb)]
assert items # not empty
ikey = items[0][0]
assert ikey == aKey
vals = [val for key, val in items]
assert vals == aVals
items = [
item for item in dber.getIoItemsNextIter(edb, key=aKey, skip=False)
]
assert items # not empty
ikey = items[0][0]
assert ikey == aKey
vals = [val for key, val in items]
assert vals == aVals
items = [item for item in dber.getIoItemsNextIter(edb, key=aKey)]
assert items # not empty
ikey = items[0][0]
assert ikey == bKey
vals = [val for key, val in items]
assert vals == bVals
items = [
item for item in dber.getIoItemsNextIter(edb, key=b'', skip=False)
]
assert items # not empty
ikey = items[0][0]
assert ikey == aKey
vals = [val for key, val in items]
assert vals == aVals
for key, val in items:
assert dber.delIoVal(edb, ikey, val) == True
# bVals
items = [item for item in dber.getIoItemsNextIter(edb, key=ikey)]
assert items # not empty
ikey = items[0][0]
assert ikey == bKey
vals = [val for key, val in items]
assert vals == bVals
for key, val in items:
assert dber.delIoVal(edb, ikey, val) == True
# cVals
items = [item for item in dber.getIoItemsNextIter(edb, key=ikey)]
assert items # not empty
ikey = items[0][0]
assert ikey == cKey
vals = [val for key, val in items]
assert vals == cVals
for key, val in items:
assert dber.delIoVal(edb, ikey, val) == True
# dVals
items = [item for item in dber.getIoItemsNext(edb, key=ikey)]
assert items # not empty
ikey = items[0][0]
assert ikey == dKey
vals = [val for key, val in items]
assert vals == dVals
for key, val in items:
assert dber.delIoVal(edb, ikey, val) == True
# none
items = [item for item in dber.getIoItemsNext(edb, key=ikey)]
assert items == [] # empty
assert not items
assert not os.path.exists(dber.path)
""" End Test """
def test_issuer():
"""
Test Issuer Class
"""
issuer = Registry()
assert isinstance(issuer, Registry)
assert issuer.name == "main"
assert issuer.temp is False
assert isinstance(issuer.env, lmdb.Environment)
assert issuer.path.endswith("keri/db/main")
assert issuer.env.path() == issuer.path
assert os.path.exists(issuer.path)
assert isinstance(issuer.tvts, lmdb._Database)
issuer.close(clear=True)
assert not os.path.exists(issuer.path)
assert not issuer.opened
# test not opened on init
issuer = Registry(reopen=False)
assert isinstance(issuer, Registry)
assert issuer.name == "main"
assert issuer.temp is False
assert issuer.opened is False
assert issuer.path is None
assert issuer.env is None
issuer.reopen()
assert issuer.opened
assert issuer.path is not None
assert isinstance(issuer.env, lmdb.Environment)
assert issuer.path.endswith("keri/db/main")
assert issuer.env.path() == issuer.path
assert os.path.exists(issuer.path)
issuer.close(clear=True)
assert not os.path.exists(issuer.path)
assert not issuer.opened
assert isinstance(issuer.tvts, lmdb._Database)
with openLMDB(cls=Registry) as issuer:
assert isinstance(issuer, Registry)
assert issuer.name == "test"
assert issuer.temp is True
assert isinstance(issuer.env, lmdb.Environment)
assert issuer.path.startswith("/tmp/keri_lmdb_")
assert issuer.path.endswith("_test/keri/db/test")
assert issuer.env.path() == issuer.path
assert os.path.exists(issuer.path)
assert isinstance(issuer.tvts, lmdb._Database)
assert not os.path.exists(issuer.path)
ipreb = "DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo".encode("utf-8")
regb = "EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0".encode("utf-8")
rarb = "BijzaUuRMwh1ivT5BQrqNhbvx82lB-ofrHVHjL3WADbA".encode("utf-8")
# test with registry inception (vcp) event
regk = nsKey([ipreb, regb])
assert regk == b'DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo:EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0'
sn = 0
vs = Versify(kind=Serials.json, size=20)
vcp = dict(v=vs,
i=regk.decode("utf-8"),
s="{:x}".format(sn),
b=[rarb.decode("utf-8")],
t="vcp")
vcpb = json.dumps(vcp, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
assert vcpb == (
b'{"v":"KERI10JSON000014_",'
b'"i":"DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo:EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0",'
b'"s":"0","b":["BijzaUuRMwh1ivT5BQrqNhbvx82lB-ofrHVHjL3WADbA"],"t":"vcp"}'
)
vdig = Diger(ser=vcpb)
with openLMDB(cls=Registry) as issuer:
key = dgKey(regk, vdig.qb64b)
assert issuer.getTvt(key) is None
assert issuer.delTvt(key) is False
assert issuer.putTvt(key, val=vcpb) is True
assert issuer.getTvt(key) == vcpb
assert issuer.putTvt(key, val=vcpb) is False
assert issuer.setTvt(key, val=vcpb) is True
assert issuer.getTvt(key) == vcpb
assert issuer.delTvt(key) is True
assert issuer.getTvt(key) is None
telKey = snKey(regk, sn)
assert issuer.getTel(telKey) is None
assert issuer.delTel(telKey) is False
assert issuer.putTel(telKey, val=vdig.qb64b)
assert issuer.getTel(telKey) == vdig.qb64b
assert issuer.putTel(telKey, val=vdig.qb64b) is False
assert issuer.setTel(telKey, val=vdig.qb64b) is True
assert issuer.getTel(telKey) == vdig.qb64b
assert issuer.delTel(telKey) is True
assert issuer.getTel(telKey) is None
coupl01 = (
"BPVuWC4Hc0izqPKn2LIwhp72SHJSRgfaL1RhtuiavIy4AAfiKvopJ0O2afOmxb5A6JtdY7Wkl_1uNx1Z8xQkg_"
"gMzf-vTfEHDylFdgn2e_u_ppaFajIdvEvONX6dcSYzlfBQ").encode("utf-8")
coupl02 = (
"BW1gbapuOJ4TJKwLfKZs5cXEIs9k8EtBqxR1psVxnD7IABrSkjrgPGXdhBiOy6LUZpiqtsHkKHhfLGj_LhT1n6"
"EqCIdDjrihzrdM1bm0ZNJDwbDGXoeeZujd7ZYsOsBPzRCw").encode("utf-8")
coupl03 = (
"BklrMm7GlYzNrPQunLJHFn_1wWjlUslGkXfs0KyoNOEAAC_6PB5Zre_E_7YLkM9OtRo-uYmwRyFmOH3Xo4JDiP"
"jioY7Ycna6ouhSSH0QcKsEjce10HCXIW_XtmEYr9SrB5BA").encode("utf-8")
coups = [coupl01, coupl02, coupl03]
key = dgKey(regk, vdig.qb64b)
assert issuer.getTibs(key) == []
assert issuer.cntTibs(key) == 0
assert issuer.delTibs(key) is False
assert issuer.putTibs(key, vals=[coupl01]) is True
assert issuer.getTibs(key) == [coupl01]
assert issuer.cntTibs(key) == 1
assert issuer.putTibs(key, vals=[coupl01]) is True # add duplicate
assert issuer.cntTibs(key) == 1
assert issuer.addTib(key, coupl01) is False
assert issuer.addTib(key, coupl02) is True
assert issuer.cntTibs(key) == 2
assert issuer.putTibs(key, vals=[coupl02, coupl03]) is True
assert issuer.cntTibs(key) == 3
assert issuer.delTibs(key) is True
assert issuer.getTibs(key) == []
for c in coups:
assert issuer.addTib(key, c) is True
assert issuer.cntTibs(key) == 3
assert issuer.getTibs(key) == [coupl01, coupl02, coupl03]
for c in issuer.getTibsIter(key):
assert issuer.delTibs(key, c) is True
assert issuer.getTibs(key) == []
tweKey = snKey(regk, sn)
assert issuer.getTwe(tweKey) is None
assert issuer.delTwe(tweKey) is False
assert issuer.putTwe(tweKey, val=vdig.qb64b)
assert issuer.getTwe(tweKey) == vdig.qb64b
assert issuer.putTwe(tweKey, val=vdig.qb64b) is False
assert issuer.setTwe(tweKey, val=vdig.qb64b) is True
assert issuer.getTwe(tweKey) == vdig.qb64b
assert issuer.delTwe(tweKey) is True
assert issuer.getTwe(tweKey) is None
ooKey = snKey(regk, sn)
assert issuer.getOot(ooKey) is None
assert issuer.delOot(ooKey) is False
assert issuer.putOot(ooKey, val=vdig.qb64b)
assert issuer.getOot(ooKey) == vdig.qb64b
assert issuer.putOot(ooKey, val=vdig.qb64b) is False
assert issuer.setOot(ooKey, val=vdig.qb64b) is True
assert issuer.getOot(ooKey) == vdig.qb64b
assert issuer.delOot(ooKey) is True
assert issuer.getOot(ooKey) is None
anc01 = (
"DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo"
"0AAAAAAAAAAAAAAAAAAAAABA"
"Ezpq06UecHwzy-K9FpNoRxCJp2wIGM9u2Edk-PLMZ1H4").encode("utf-8")
key = dgKey(regk, vdig.qb64b)
assert issuer.getAnc(key) is None
assert issuer.delAnc(key) is False
assert issuer.putAnc(key, val=anc01)
assert issuer.getAnc(key) == anc01
assert issuer.putAnc(key, val=anc01) is False
assert issuer.setAnc(key, val=anc01) is True
assert issuer.getAnc(key) == anc01
assert issuer.delAnc(key) is True
assert issuer.getAnc(key) is None
# test with verifiable credential issuance (iss) event
vcdig = b'EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc'
vck = nsKey([ipreb, regb, vcdig])
assert vck == (
b'DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo:EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0'
b':EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc')
sn = 0
vs = Versify(kind=Serials.json, size=20)
vcp = dict(v=vs, i=vck.decode("utf-8"), s="{:x}".format(sn), t="iss")
issb = json.dumps(vcp, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
assert issb == (
b'{"v":"KERI10JSON000014_",'
b'"i":"DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo:'
b'EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0:EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc",'
b''
b'"s":"0","t":"iss"}')
idig = Diger(ser=issb)
key = dgKey(vck, idig.qb64b)
assert issuer.getTvt(key) is None
assert issuer.delTvt(key) is False
assert issuer.putTvt(key, val=issb) is True
assert issuer.getTvt(key) == issb
assert issuer.putTvt(key, val=issb) is False
assert issuer.setTvt(key, val=issb) is True
assert issuer.getTvt(key) == issb
assert issuer.delTvt(key) is True
assert issuer.getTvt(key) is None
telKey = snKey(vck, sn)
assert issuer.getTel(telKey) is None
assert issuer.delTel(telKey) is False
assert issuer.putTel(telKey, val=idig.qb64b)
assert issuer.getTel(telKey) == idig.qb64b
assert issuer.putTel(telKey, val=idig.qb64b) is False
assert issuer.setTel(telKey, val=idig.qb64b) is True
assert issuer.getTel(telKey) == idig.qb64b
assert issuer.delTel(telKey) is True
assert issuer.getTel(telKey) is None
"""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_databaser():
"""
Test Databaser creation
"""
databaser = Databaser()
assert isinstance(databaser, Databaser)
assert databaser.name == "main"
assert isinstance(databaser.env, lmdb.Environment)
assert databaser.path.endswith("keri/db/main")
assert databaser.env.path() == databaser.path
assert os.path.exists(databaser.path)
pre = b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
dig = b'EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4'
sn = 3
assert snKey(pre, sn) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
b'.00000000000000000000000000000003')
assert dgKey(pre,
dig) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
b'.EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4')
databaser.clearDirPath()
assert not os.path.exists(databaser.path)
with openDatabaser() as dber:
#test Val methods
key = b'A'
val = b'whatever'
db = dber.env.open_db(key=b'beep.')
assert dber.getVal(db, key) == None
assert dber.delVal(db, key) == False
assert dber.putVal(db, key, val) == True
assert dber.putVal(db, key, val) == False
assert dber.setVal(db, key, val) == True
assert dber.getVal(db, key) == val
assert dber.delVal(db, key) == True
assert dber.getVal(db, key) == None
# test Vals dup methods. dup vals are lexocographic
key = b'A'
vals = [b"z", b"m", b"x", b"a"]
db = dber.env.open_db(key=b'boop.', dupsort=True)
assert dber.getVals(db, key) == []
assert dber.delVals(db, key) == False
assert dber.cntVals(db, key) == 0
assert dber.putVals(db, key, vals) == True
assert dber.getVals(db, key) == [b'a', b'm', b'x',
b'z'] # lexocographic order
assert dber.cntVals(db, key) == len(vals) == 4
assert dber.putVals(db, key, vals=[b'a']) == True # duplicate
assert dber.getVals(db, key) == [b'a', b'm', b'x', b'z'] # no change
assert dber.addVal(db, key, val=b'a') == False # duplicate
assert dber.addVal(db, key, val=b'b') == True
assert dber.getVals(db, key) == [b'a', b'b', b'm', b'x', b'z']
assert [val for val in dber.getValsIter(db, key)
] == [b'a', b'b', b'm', b'x', b'z']
assert dber.delVals(db, key) == True
assert dber.getVals(db, key) == []
# test IoVals insertion order dup methods. dup vals are insertion order
key = b'A'
vals = [b"z", b"m", b"x", b"a"]
db = dber.env.open_db(key=b'peep.', dupsort=True)
assert dber.getIoVals(db, key) == []
assert dber.getIoValsLast(db, key) == None
assert dber.cntIoVals(db, key) == 0
assert dber.delIoVals(db, key) == False
assert dber.putIoVals(db, key, vals) == True
assert dber.getIoVals(db, key) == vals # preserved insertion order
assert dber.cntIoVals(db, key) == len(vals) == 4
assert dber.getIoValsLast(db, key) == vals[-1]
assert dber.putIoVals(db, key, vals=[b'a']) == False # duplicate
assert dber.getIoVals(db, key) == vals # no change
assert dber.addIoVal(db, key, val=b'b') == True
assert dber.addIoVal(db, key, val=b'a') == False
assert dber.getIoVals(db, key) == [b"z", b"m", b"x", b"a", b'b']
assert dber.delIoVals(db, key) == True
assert dber.getIoVals(db, key) == []
# Test getIoValsAllPreIter(self, db, pre)
vals0 = [b"gamma", b"beta"]
sn = 0
key = snKey(pre, sn)
assert dber.addIoVal(db, key, vals0[0]) == True
assert dber.addIoVal(db, key, vals0[1]) == True
vals1 = [b"mary", b"peter", b"john", b"paul"]
sn += 1
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals1) == True
vals2 = [b"dog", b"cat", b"bird"]
sn += 1
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals2) == True
vals = [bytes(val) for val in dber.getIoValsAllPreIter(db, pre)]
allvals = vals0 + vals1 + vals2
assert vals == allvals
# Test getIoValsLastAllPreIter(self, db, pre)
pre = b'B4ejWzwQPYGGwTmuupUhPx5_yZ-Wk1xEHHzq7K0gzhcc'
vals0 = [b"gamma", b"beta"]
sn = 0
key = snKey(pre, sn)
assert dber.addIoVal(db, key, vals0[0]) == True
assert dber.addIoVal(db, key, vals0[1]) == True
vals1 = [b"mary", b"peter", b"john", b"paul"]
sn += 1
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals1) == True
vals2 = [b"dog", b"cat", b"bird"]
sn += 1
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals2) == True
vals = [bytes(val) for val in dber.getIoValsLastAllPreIter(db, pre)]
lastvals = [vals0[-1], vals1[-1], vals2[-1]]
assert vals == lastvals
# Test getIoValsAnyPreIter(self, db, pre)
pre = b'BQPYGGwTmuupUhPx5_yZ-Wk1x4ejWzwEHHzq7K0gzhcc'
vals0 = [b"gamma", b"beta"]
sn = 1 # not start at zero
key = snKey(pre, sn)
assert dber.addIoVal(db, key, vals0[0]) == True
assert dber.addIoVal(db, key, vals0[1]) == True
vals1 = [b"mary", b"peter", b"john", b"paul"]
sn += 1
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals1) == True
vals2 = [b"dog", b"cat", b"bird"]
sn += 2 # gap
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals2) == True
vals = [bytes(val) for val in dber.getIoValsAnyPreIter(db, pre)]
allvals = vals0 + vals1 + vals2
assert vals == allvals
assert not os.path.exists(dber.path)
""" End Test """
def test_logger():
"""
Test Logger class
"""
logger = Logger()
assert isinstance(logger, Logger)
assert logger.name == "main"
assert isinstance(logger.env, lmdb.Environment)
assert logger.path.endswith("keri/db/main")
assert logger.env.path() == logger.path
assert os.path.exists(logger.path)
assert isinstance(logger.evts, lmdb._Database)
assert isinstance(logger.sigs, lmdb._Database)
assert isinstance(logger.dtss, lmdb._Database)
assert isinstance(logger.rcts, lmdb._Database)
assert isinstance(logger.ures, lmdb._Database)
assert isinstance(logger.kels, lmdb._Database)
assert isinstance(logger.ooes, lmdb._Database)
assert isinstance(logger.pses, lmdb._Database)
assert isinstance(logger.dels, lmdb._Database)
assert isinstance(logger.ldes, lmdb._Database)
logger.clearDirPath()
assert not os.path.exists(logger.path)
# Test using context manager
with openDatabaser(cls=Logger) as logger:
assert isinstance(logger, Logger)
assert logger.name == "test"
assert isinstance(logger.env, lmdb.Environment)
assert logger.path.startswith("/tmp/keri_lmdb_")
assert logger.path.endswith("_test/keri/db/test")
assert logger.env.path() == logger.path
assert os.path.exists(logger.path)
assert isinstance(logger.evts, lmdb._Database)
assert isinstance(logger.sigs, lmdb._Database)
assert isinstance(logger.dtss, lmdb._Database)
assert isinstance(logger.rcts, lmdb._Database)
assert isinstance(logger.ures, lmdb._Database)
assert isinstance(logger.kels, lmdb._Database)
assert isinstance(logger.ooes, lmdb._Database)
assert isinstance(logger.pses, lmdb._Database)
assert isinstance(logger.dels, lmdb._Database)
assert isinstance(logger.ldes, lmdb._Database)
assert not os.path.exists(logger.path)
preb = 'DWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'.encode("utf-8")
digb = 'EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4'.encode("utf-8")
sn = 3
vs = Versify(kind=Serials.json, size=20)
assert vs == 'KERI10JSON000014_'
ked = dict(vs=vs,
pre=preb.decode("utf-8"),
sn="{:x}".format(sn),
ilk="rot",
dig=digb.decode("utf-8"))
skedb = json.dumps(ked, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
assert skedb == (
b'{"vs":"KERI10JSON000014_","pre":"DWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhc'
b'c","sn":"3","ilk":"rot","dig":"EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4"'
b'}')
sig0b = 'AAz1KAV2z5IRqcFe4gPs9l3wsFKi1NsSZvBe8yQJmiu5AzJ91Timrykocna6Z_pQBl2gt59I_F6BsSwFbIOG1TDQ'.encode(
"utf-8")
sig1b = 'AB_pQBl2gt59I_F6BsSwFbIOG1TDQz1KAV2z5IRqcFe4gPs9l3wsFKi1NsSZvBe8yQJmiu5AzJ91Timrykocna6Z'.encode(
"utf-8")
wit0b = 'BmuupUhPx5_yZ-Wk1x4ejhccWzwEHHzq7K0gzQPYGGwT'.encode("utf-8")
wit1b = 'BjhccWzwEHHzq7K0gzmuupUhPx5_yZ-Wk1x4eQPYGGwT'.encode("utf-8")
wsig0b = '0B1Timrykocna6Z_pQBl2gt59I_F6BsSwFbIOG1TDQz1KAV2z5IRqcFe4gPs9l3wsFKi1NsSZvBe8yQJmiu5AzJ9'.encode(
"utf-8")
wsig1b = '0B5IRqcFe4gPs9l3wsFKi1NsSZvBe8yQJmiu5Az_pQBl2gt59I_F6BsSwFbIOG1TDQz1KAV2zJ91Timrykocna6Z'.encode(
"utf-8")
valb = 'EHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhccWzwEH'.encode("utf-8")
vdigb = 'EQiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4GAPkzNZMtX-'.encode("utf-8")
vsig0b = 'AAKAV2z5IRqcFe4gPs9l3wsFKi1NsSZvBe81Timrykocna6Z_pQBl2gt59I_F6BsSwFbIOG1TDQz1yQJmiu5AzJ9'.encode(
"utf-8")
vsig1b = 'AB1KAV2zJ91Timrykocna6Z5IRqcFe4gPs9l3wsFKi1NsSZvBe8yQJmiu5Az_pQBl2gt59I_F6BsSwFbIOG1TDQz'.encode(
"utf-8")
with openLogger() as lgr:
key = dgKey(preb, digb)
assert key == (b'DWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc.'
b'EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4')
# test .evts sub db methods
assert lgr.getEvt(key) == None
assert lgr.delEvt(key) == False
assert lgr.putEvt(key, val=skedb) == True
assert lgr.getEvt(key) == skedb
assert lgr.putEvt(key, val=skedb) == False
assert lgr.setEvt(key, val=skedb) == True
assert lgr.getEvt(key) == skedb
assert lgr.delEvt(key) == True
assert lgr.getEvt(key) == None
# test .dtss sub db methods
val1 = b'2020-08-22T17:50:09.988921+00:00'
val2 = b'2020-08-22T17:50:09.988921+00:00'
assert lgr.getDts(key) == None
assert lgr.delDts(key) == False
assert lgr.putDts(key, val1) == True
assert lgr.getDts(key) == val1
assert lgr.putDts(key, val2) == False
assert lgr.getDts(key) == val1
assert lgr.setDts(key, val2) == True
assert lgr.getDts(key) == val2
assert lgr.delDts(key) == True
assert lgr.getDts(key) == None
# test .sigs sub db methods
assert lgr.getSigs(key) == []
assert lgr.cntSigs(key) == 0
assert lgr.delSigs(key) == False
# dup vals are lexocographic
assert lgr.putSigs(key, vals=[b"z", b"m", b"x", b"a"]) == True
assert lgr.getSigs(key) == [b'a', b'm', b'x', b'z']
assert lgr.cntSigs(key) == 4
assert lgr.putSigs(key, vals=[b'a']) == True # duplicate but True
assert lgr.getSigs(key) == [b'a', b'm', b'x', b'z']
assert lgr.addSig(key, b'a') == False # duplicate
assert lgr.addSig(key, b'b') == True
assert lgr.getSigs(key) == [b'a', b'b', b'm', b'x', b'z']
assert [val for val in lgr.getSigsIter(key)
] == [b'a', b'b', b'm', b'x', b'z']
assert lgr.delSigs(key) == True
assert lgr.getSigs(key) == []
assert lgr.putSigs(key, vals=[sig0b]) == True
assert lgr.getSigs(key) == [sig0b]
assert lgr.putSigs(key, vals=[sig1b]) == True
assert lgr.getSigs(key) == [sig0b, sig1b]
assert lgr.delSigs(key) == True
assert lgr.putSigs(key, vals=[sig1b, sig0b]) == True
assert lgr.getSigs(key) == [sig0b, sig1b]
assert lgr.delSigs(key) == True
assert lgr.getSigs(key) == []
# test .rcts sub db methods dgkey
assert lgr.getRcts(key) == []
assert lgr.cntRcts(key) == 0
assert lgr.delRcts(key) == False
# dup vals are lexocographic
assert lgr.putRcts(key, vals=[b"z", b"m", b"x", b"a"]) == True
assert lgr.getRcts(key) == [b'a', b'm', b'x', b'z']
assert lgr.cntRcts(key) == 4
assert lgr.putRcts(key, vals=[b'a']) == True # duplicate
assert lgr.getRcts(key) == [b'a', b'm', b'x', b'z']
assert lgr.addRct(key, b'a') == False # duplicate
assert lgr.addRct(key, b'b') == True
assert lgr.getRcts(key) == [b'a', b'b', b'm', b'x', b'z']
assert [val for val in lgr.getRctsIter(key)
] == [b'a', b'b', b'm', b'x', b'z']
assert lgr.delRcts(key) == True
assert lgr.getRcts(key) == []
assert lgr.putRcts(key, vals=[wit0b + wsig0b, wit1b + wsig1b]) == True
assert lgr.getRcts(key) == [wit1b + wsig1b,
wit0b + wsig0b] # lex order
assert lgr.putRcts(key, vals=[wit1b + wsig1b]) == True
assert lgr.getRcts(key) == [wit1b + wsig1b,
wit0b + wsig0b] # lex order
assert lgr.delRcts(key) == True
assert lgr.putRcts(key, vals=[wit1b + wsig1b, wit0b + wsig0b]) == True
assert lgr.getRcts(key) == [wit1b + wsig1b,
wit0b + wsig0b] # lex order
assert lgr.delRcts(key) == True
assert lgr.getRcts(key) == []
# test .ures sub db methods dgKey
assert lgr.getUres(key) == []
assert lgr.cntUres(key) == 0
assert lgr.delUres(key) == False
# dup vals are lexocographic
assert lgr.putUres(key, vals=[b"z", b"m", b"x", b"a"]) == True
assert lgr.getUres(key) == [b'a', b'm', b'x', b'z']
assert lgr.cntUres(key) == 4
assert lgr.putUres(key, vals=[b'a']) == True # duplicate
assert lgr.getUres(key) == [b'a', b'm', b'x', b'z']
assert lgr.addUre(key, b'a') == False # duplicate
assert lgr.addUre(key, b'b') == True
assert lgr.getUres(key) == [b'a', b'b', b'm', b'x', b'z']
assert [val for val in lgr.getUresIter(key)
] == [b'a', b'b', b'm', b'x', b'z']
assert lgr.delUres(key) == True
assert lgr.getUres(key) == []
assert lgr.putUres(key, vals=[wit0b + wsig0b, wit1b + wsig1b]) == True
assert lgr.getUres(key) == [wit1b + wsig1b,
wit0b + wsig0b] # lex order
assert lgr.putUres(key, vals=[wit1b + wsig1b]) == True
assert lgr.getUres(key) == [wit1b + wsig1b,
wit0b + wsig0b] # lex order
assert lgr.delUres(key) == True
assert lgr.putUres(key, vals=[wit1b + wsig1b, wit0b + wsig0b]) == True
assert lgr.getUres(key) == [wit1b + wsig1b,
wit0b + wsig0b] # lex order
assert lgr.delUres(key) == True
assert lgr.getUres(key) == []
# test .vrcs sub db methods dgkey
assert lgr.getVrcs(key) == []
assert lgr.cntVrcs(key) == 0
assert lgr.delVrcs(key) == False
# dup vals are lexocographic
assert lgr.putVrcs(key, vals=[b"z", b"m", b"x", b"a"]) == True
assert lgr.getVrcs(key) == [b'a', b'm', b'x', b'z']
assert lgr.cntVrcs(key) == 4
assert lgr.putVrcs(key, vals=[b'a']) == True # duplicate
assert lgr.getVrcs(key) == [b'a', b'm', b'x', b'z']
assert lgr.addVrc(key, b'a') == False # duplicate
assert lgr.addVrc(key, b'b') == True
assert lgr.getVrcs(key) == [b'a', b'b', b'm', b'x', b'z']
assert [val for val in lgr.getVrcsIter(key)
] == [b'a', b'b', b'm', b'x', b'z']
assert lgr.delVrcs(key) == True
assert lgr.getVrcs(key) == []
assert lgr.putVrcs(key,
vals=[valb + vdigb + vsig0b,
valb + vdigb + vsig1b]) == True
assert lgr.getVrcs(key) == [
valb + vdigb + vsig0b, valb + vdigb + vsig1b
] # lex order
assert lgr.putVrcs(key, vals=[valb + vdigb + vsig1b]) == True
assert lgr.getVrcs(key) == [
valb + vdigb + vsig0b, valb + vdigb + vsig1b
] # lex order
assert lgr.delVrcs(key) == True
assert lgr.putVrcs(key,
vals=[valb + vdigb + vsig1b,
valb + vdigb + vsig0b]) == True
assert lgr.getVrcs(key) == [
valb + vdigb + vsig0b, valb + vdigb + vsig1b
] # lex order
assert lgr.delVrcs(key) == True
assert lgr.getVrcs(key) == []
# test .vres sub db methods dgKey
assert lgr.getVres(key) == []
assert lgr.cntVres(key) == 0
assert lgr.delVres(key) == False
# dup vals are lexocographic
assert lgr.putVres(key, vals=[b"z", b"m", b"x", b"a"]) == True
assert lgr.getVres(key) == [b'a', b'm', b'x', b'z']
assert lgr.cntVres(key) == 4
assert lgr.putVres(key, vals=[b'a']) == True # duplicate
assert lgr.getVres(key) == [b'a', b'm', b'x', b'z']
assert lgr.addVre(key, b'a') == False # duplicate
assert lgr.addVre(key, b'b') == True
assert lgr.getVres(key) == [b'a', b'b', b'm', b'x', b'z']
assert [val for val in lgr.getVresIter(key)
] == [b'a', b'b', b'm', b'x', b'z']
assert lgr.delVres(key) == True
assert lgr.getVres(key) == []
assert lgr.putVres(key,
vals=[valb + vdigb + vsig0b,
valb + vdigb + vsig1b]) == True
assert lgr.getVres(key) == [
valb + vdigb + vsig0b, valb + vdigb + vsig1b
] # lex order
assert lgr.putVres(key, vals=[valb + vdigb + vsig1b]) == True
assert lgr.getVres(key) == [
valb + vdigb + vsig0b, valb + vdigb + vsig1b
] # lex order
assert lgr.delVres(key) == True
assert lgr.putVres(key,
vals=[valb + vdigb + vsig1b,
valb + vdigb + vsig0b]) == True
assert lgr.getVres(key) == [
valb + vdigb + vsig0b, valb + vdigb + vsig1b
] # lex order
assert lgr.delVres(key) == True
assert lgr.getVres(key) == []
# test .kels insertion order dup methods. dup vals are insertion order
key = snKey(preb, 0)
vals = [b"z", b"m", b"x", b"a"]
assert lgr.getKes(key) == []
assert lgr.getKeLast(key) == None
assert lgr.cntKes(key) == 0
assert lgr.delKes(key) == False
assert lgr.putKes(key, vals) == True
assert lgr.getKes(key) == vals # preserved insertion order
assert lgr.cntKes(key) == len(vals) == 4
assert lgr.getKeLast(key) == vals[-1]
assert lgr.putKes(key, vals=[b'a']) == False # duplicate
assert lgr.getKes(key) == vals # no change
assert lgr.addKe(key, b'a') == False # duplicate
assert lgr.addKe(key, b'b') == True
assert lgr.getKes(key) == [b"z", b"m", b"x", b"a", b"b"]
assert lgr.delKes(key) == True
assert lgr.getKes(key) == []
# test .pses insertion order dup methods. dup vals are insertion order
key = b'A'
vals = [b"z", b"m", b"x", b"a"]
assert lgr.getPses(key) == []
assert lgr.getPsesLast(key) == None
assert lgr.cntPses(key) == 0
assert lgr.delPses(key) == False
assert lgr.putPses(key, vals) == True
assert lgr.getPses(key) == vals # preserved insertion order
assert lgr.cntPses(key) == len(vals) == 4
assert lgr.getPsesLast(key) == vals[-1]
assert lgr.putPses(key, vals=[b'a']) == False # duplicate
assert lgr.getPses(key) == vals # no change
assert lgr.addPse(key, b'a') == False # duplicate
assert lgr.addPse(key, b'b') == True
assert lgr.getPses(key) == [b"z", b"m", b"x", b"a", b"b"]
assert lgr.delPses(key) == True
assert lgr.getPses(key) == []
# test .ooes insertion order dup methods. dup vals are insertion order
key = b'A'
vals = [b"z", b"m", b"x", b"a"]
assert lgr.getOoes(key) == []
assert lgr.getOoesLast(key) == None
assert lgr.cntOoes(key) == 0
assert lgr.delOoes(key) == False
assert lgr.putOoes(key, vals) == True
assert lgr.getOoes(key) == vals # preserved insertion order
assert lgr.cntOoes(key) == len(vals) == 4
assert lgr.getOoesLast(key) == vals[-1]
assert lgr.putOoes(key, vals=[b'a']) == False # duplicate
assert lgr.getOoes(key) == vals # no change
assert lgr.addOoe(key, b'a') == False # duplicate
assert lgr.addOoe(key, b'b') == True
assert lgr.getOoes(key) == [b"z", b"m", b"x", b"a", b"b"]
assert lgr.delOoes(key) == True
assert lgr.getOoes(key) == []
# test .dels insertion order dup methods. dup vals are insertion order
key = b'A'
vals = [b"z", b"m", b"x", b"a"]
assert lgr.getDes(key) == []
assert lgr.getDesLast(key) == None
assert lgr.cntDes(key) == 0
assert lgr.delDes(key) == False
assert lgr.putDes(key, vals) == True
assert lgr.getDes(key) == vals # preserved insertion order
assert lgr.cntDes(key) == len(vals) == 4
assert lgr.getDesLast(key) == vals[-1]
assert lgr.putDes(key, vals=[b'a']) == False # duplicate
assert lgr.getDes(key) == vals # no change
assert lgr.addDe(key, b'a') == False # duplicate
assert lgr.addDe(key, b'b') == True
assert lgr.getDes(key) == [b"z", b"m", b"x", b"a", b"b"]
assert lgr.delDes(key) == True
assert lgr.getDes(key) == []
# test .ldes insertion order dup methods. dup vals are insertion order
key = b'A'
vals = [b"z", b"m", b"x", b"a"]
assert lgr.getLdes(key) == []
assert lgr.getLdesLast(key) == None
assert lgr.cntLdes(key) == 0
assert lgr.delLdes(key) == False
assert lgr.putLdes(key, vals) == True
assert lgr.getLdes(key) == vals # preserved insertion order
assert lgr.cntLdes(key) == len(vals) == 4
assert lgr.getLdesLast(key) == vals[-1]
assert lgr.putLdes(key, vals=[b'a']) == False # duplicate
assert lgr.getLdes(key) == vals # no change
assert lgr.delLdes(key) == True
assert lgr.getLdes(key) == []
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_clone():
ipreb = "DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo".encode("utf-8")
regk = "EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0".encode("utf-8")
rarb = "BijzaUuRMwh1ivT5BQrqNhbvx82lB-ofrHVHjL3WADbA".encode("utf-8")
rarb2 = "BPVuWC4Hc0izqPKn2LIwhp72SHJSRgfaL1RhtuiavIy4".encode("utf-8")
# test with registry inception (vcp) event
sn = 0
vs = Versify(kind=Serials.json, size=20)
vcp = dict(v=vs,
i=regk.decode("utf-8"),
s="{:x}".format(sn),
b=[rarb.decode("utf-8")],
t="vcp")
vcpb = json.dumps(vcp, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
vdig = Diger(ser=vcpb)
anc01 = "0AAAAAAAAAAAAAAAAAAAAABAEzpq06UecHwzy-K9FpNoRxCJp2wIGM9u2Edk-PLMZ1H4".encode(
"utf-8")
tib01 = (
"BPVuWC4Hc0izqPKn2LIwhp72SHJSRgfaL1RhtuiavIy4AAfiKvopJ0O2afOmxb5A6JtdY7Wkl_1uNx1Z8xQkg_"
"gMzf-vTfEHDylFdgn2e_u_ppaFajIdvEvONX6dcSYzlfBQ").encode("utf-8")
rot1 = dict(v=vs,
i=regk.decode("utf-8"),
s="{:x}".format(sn + 1),
ba=[rarb2.decode("utf-8")],
t="rot")
rot1b = json.dumps(rot1, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
r1dig = Diger(ser=rot1b)
anc02 = "0AAAAAAAAAAAAAAAAAAAAABBEzpq06UecHwzy-K9FpNoRxCJp2wIGM9u2Edk-PLMZ1H4".encode(
"utf-8")
tib02 = (
"BW1gbapuOJ4TJKwLfKZs5cXEIs9k8EtBqxR1psVxnD7IABrSkjrgPGXdhBiOy6LUZpiqtsHkKHhfLGj_LhT1n6"
"EqCIdDjrihzrdM1bm0ZNJDwbDGXoeeZujd7ZYsOsBPzRCw").encode("utf-8")
rot2 = dict(v=vs,
i=regk.decode("utf-8"),
s="{:x}".format(sn + 2),
br=[rarb.decode("utf-8")],
t="rot")
rot2b = json.dumps(rot2, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
r2dig = Diger(ser=rot2b)
anc03 = "0AAAAAAAAAAAAAAAAAAAAABCEzpq06UecHwzy-K9FpNoRxCJp2wIGM9u2Edk-PLMZ1H4".encode(
"utf-8")
tib03 = (
"BklrMm7GlYzNrPQunLJHFn_1wWjlUslGkXfs0KyoNOEAAC_6PB5Zre_E_7YLkM9OtRo-uYmwRyFmOH3Xo4JDiP"
"jioY7Ycna6ouhSSH0QcKsEjce10HCXIW_XtmEYr9SrB5BA").encode("utf-8")
with openLMDB(cls=Registry) as issuer:
dgkey = dgKey(regk, vdig.qb64b)
snkey = snKey(regk, sn)
assert issuer.putTvt(dgkey, val=vcpb) is True
assert issuer.putTel(snkey, val=vdig.qb64b)
assert issuer.putAnc(dgkey, val=anc01) is True
assert issuer.putTibs(dgkey, vals=[tib01]) is True
dgkey = dgKey(regk, r1dig.qb64b)
snkey = snKey(regk, sn + 1)
assert issuer.putTvt(dgkey, val=rot1b) is True
assert issuer.putTel(snkey, val=r1dig.qb64b)
assert issuer.putAnc(dgkey, val=anc02) is True
assert issuer.putTibs(dgkey, vals=[tib02]) is True
dgkey = dgKey(regk, r2dig.qb64b)
snkey = snKey(regk, sn + 2)
assert issuer.putTvt(dgkey, val=rot2b) is True
assert issuer.putTel(snkey, val=r2dig.qb64b)
assert issuer.putAnc(dgkey, val=anc03) is True
assert issuer.putTibs(dgkey, vals=[tib03]) is True
msgs = bytearray() # outgoing messages
for msg in issuer.clonePreIter(regk):
msgs.extend(msg)
assert msgs == (
b'{"v":"KERI10JSON000014_","i":"EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0","s":"0",'
b'"b":["BijzaUuRMwh1ivT5BQrqNhbvx82lB-ofrHVHjL3WADbA"],'
b'"t":"vcp"}-VA0-BABBPVuWC4Hc0izqPKn2LIwhp72SHJSRgfaL1RhtuiavIy4AAfiKvopJ0O2afOmxb5A6JtdY7Wkl_1uNx1Z8xQk'
b'g_gMzf-vTfEHDylFdgn2e_u_ppaFajIdvEvONX6dcSYzlfBQ-GAB0AAAAAAAAAAAAAAAAAAAAABAEzpq06UecHwzy-K9FpNoRxCJp2'
b'wIGM9u2Edk-PLMZ1H4{"v":"KERI10JSON000014_","i":"EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0","s":"1",'
b'"ba":["BPVuWC4Hc0izqPKn2LIwhp72SHJSRgfaL1RhtuiavIy4"],"t":"rot"}-VA0-BABBW1gbapuOJ4TJKwLfKZs5cXEIs9k8Et'
b'BqxR1psVxnD7IABrSkjrgPGXdhBiOy6LUZpiqtsHkKHhfLGj_LhT1n6EqCIdDjrihzrdM1bm0ZNJDwbDGXoeeZujd7ZYsOsBPzRCw-G'
b'AB0AAAAAAAAAAAAAAAAAAAAABBEzpq06UecHwzy-K9FpNoRxCJp2wIGM9u2Edk-PLMZ1H4{"v":"KERI10JSON000014_","i":"EOWd'
b'T7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0","s":"2","br":["BijzaUuRMwh1ivT5BQrqNhbvx82lB-ofrHVHjL3WADbA"]'
b',"t":"rot"}-VA0-BABBklrMm7GlYzNrPQunLJHFn_1wWjlUslGkXfs0KyoNOEAAC_6PB5Zre_E_7YLkM9OtRo-uYmwRyFmOH3Xo4JDi'
b'PjioY7Ycna6ouhSSH0QcKsEjce10HCXIW_XtmEYr9SrB5BA-GAB0AAAAAAAAAAAAAAAAAAAAABCEzpq06UecHwzy-K9FpNoRxCJp2wIG'
b'M9u2Edk-PLMZ1H4')
def test_issuer():
"""
Test Issuer Class
"""
issuer = Registry()
assert isinstance(issuer, Registry)
assert issuer.name == "main"
assert issuer.temp is False
assert isinstance(issuer.env, lmdb.Environment)
assert issuer.path.endswith("keri/reg/main")
assert issuer.env.path() == issuer.path
assert os.path.exists(issuer.path)
assert isinstance(issuer.tvts, lmdb._Database)
issuer.close(clear=True)
assert not os.path.exists(issuer.path)
assert not issuer.opened
# test not opened on init
issuer = Registry(reopen=False)
assert isinstance(issuer, Registry)
assert issuer.name == "main"
assert issuer.temp is False
assert issuer.opened is False
assert issuer.path is None
assert issuer.env is None
issuer.reopen()
assert issuer.opened
assert issuer.path is not None
assert isinstance(issuer.env, lmdb.Environment)
assert issuer.path.endswith("keri/reg/main")
assert issuer.env.path() == issuer.path
assert os.path.exists(issuer.path)
issuer.close(clear=True)
assert not os.path.exists(issuer.path)
assert not issuer.opened
assert isinstance(issuer.tvts, lmdb._Database)
with openLMDB(cls=Registry) as issuer:
assert isinstance(issuer, Registry)
assert issuer.name == "test"
assert issuer.temp is True
assert isinstance(issuer.env, lmdb.Environment)
assert issuer.path.startswith("/tmp/keri_reg_")
assert issuer.path.endswith("_test/keri/reg/test")
assert issuer.env.path() == issuer.path
assert os.path.exists(issuer.path)
assert isinstance(issuer.tvts, lmdb._Database)
assert not os.path.exists(issuer.path)
ipreb = "DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo".encode("utf-8")
regb = "EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0".encode("utf-8")
rarb = "BijzaUuRMwh1ivT5BQrqNhbvx82lB-ofrHVHjL3WADbA".encode("utf-8")
# test with registry inception (vcp) event
regk = nsKey([ipreb, regb])
assert regk == b'DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo:EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0'
sn = 0
vs = Versify(kind=Serials.json, size=20)
vcp = dict(v=vs,
i=regk.decode("utf-8"),
s="{:x}".format(sn),
b=[rarb.decode("utf-8")],
t="vcp")
vcpb = json.dumps(vcp, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
assert vcpb == (
b'{"v":"KERI10JSON000014_",'
b'"i":"DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo:EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0",'
b'"s":"0","b":["BijzaUuRMwh1ivT5BQrqNhbvx82lB-ofrHVHjL3WADbA"],"t":"vcp"}'
)
vdig = Diger(ser=vcpb)
with openLMDB(cls=Registry) as issuer:
key = dgKey(regk, vdig.qb64b)
assert issuer.getTvt(key) is None
assert issuer.delTvt(key) is False
assert issuer.putTvt(key, val=vcpb) is True
assert issuer.getTvt(key) == vcpb
assert issuer.putTvt(key, val=vcpb) is False
assert issuer.setTvt(key, val=vcpb) is True
assert issuer.getTvt(key) == vcpb
assert issuer.delTvt(key) is True
assert issuer.getTvt(key) is None
telKey = snKey(regk, sn)
assert issuer.getTel(telKey) is None
assert issuer.delTel(telKey) is False
assert issuer.putTel(telKey, val=vdig.qb64b)
assert issuer.getTel(telKey) == vdig.qb64b
assert issuer.putTel(telKey, val=vdig.qb64b) is False
assert issuer.setTel(telKey, val=vdig.qb64b) is True
assert issuer.getTel(telKey) == vdig.qb64b
assert issuer.delTel(telKey) is True
assert issuer.getTel(telKey) is None
coupl01 = (
"BPVuWC4Hc0izqPKn2LIwhp72SHJSRgfaL1RhtuiavIy4AAfiKvopJ0O2afOmxb5A6JtdY7Wkl_1uNx1Z8xQkg_"
"gMzf-vTfEHDylFdgn2e_u_ppaFajIdvEvONX6dcSYzlfBQ").encode("utf-8")
coupl02 = (
"BW1gbapuOJ4TJKwLfKZs5cXEIs9k8EtBqxR1psVxnD7IABrSkjrgPGXdhBiOy6LUZpiqtsHkKHhfLGj_LhT1n6"
"EqCIdDjrihzrdM1bm0ZNJDwbDGXoeeZujd7ZYsOsBPzRCw").encode("utf-8")
coupl03 = (
"BklrMm7GlYzNrPQunLJHFn_1wWjlUslGkXfs0KyoNOEAAC_6PB5Zre_E_7YLkM9OtRo-uYmwRyFmOH3Xo4JDiP"
"jioY7Ycna6ouhSSH0QcKsEjce10HCXIW_XtmEYr9SrB5BA").encode("utf-8")
coups = [coupl01, coupl02, coupl03]
key = dgKey(regk, vdig.qb64b)
assert issuer.getTibs(key) == []
assert issuer.cntTibs(key) == 0
assert issuer.delTibs(key) is False
assert issuer.putTibs(key, vals=[coupl01]) is True
assert issuer.getTibs(key) == [coupl01]
assert issuer.cntTibs(key) == 1
assert issuer.putTibs(key, vals=[coupl01]) is True # add duplicate
assert issuer.cntTibs(key) == 1
assert issuer.addTib(key, coupl01) is False
assert issuer.addTib(key, coupl02) is True
assert issuer.cntTibs(key) == 2
assert issuer.putTibs(key, vals=[coupl02, coupl03]) is True
assert issuer.cntTibs(key) == 3
assert issuer.delTibs(key) is True
assert issuer.getTibs(key) == []
for c in coups:
assert issuer.addTib(key, c) is True
assert issuer.cntTibs(key) == 3
assert issuer.getTibs(key) == [coupl01, coupl02, coupl03]
for c in issuer.getTibsIter(key):
assert issuer.delTibs(key, c) is True
assert issuer.getTibs(key) == []
tweKey = snKey(regk, sn)
assert issuer.getTwe(tweKey) is None
assert issuer.delTwe(tweKey) is False
assert issuer.putTwe(tweKey, val=vdig.qb64b)
assert issuer.getTwe(tweKey) == vdig.qb64b
assert issuer.putTwe(tweKey, val=vdig.qb64b) is False
assert issuer.setTwe(tweKey, val=vdig.qb64b) is True
assert issuer.getTwe(tweKey) == vdig.qb64b
assert issuer.delTwe(tweKey) is True
assert issuer.getTwe(tweKey) is None
ooKey = snKey(regk, sn)
assert issuer.getOot(ooKey) is None
assert issuer.delOot(ooKey) is False
assert issuer.putOot(ooKey, val=vdig.qb64b)
assert issuer.getOot(ooKey) == vdig.qb64b
assert issuer.putOot(ooKey, val=vdig.qb64b) is False
assert issuer.setOot(ooKey, val=vdig.qb64b) is True
assert issuer.getOot(ooKey) == vdig.qb64b
assert issuer.delOot(ooKey) is True
assert issuer.getOot(ooKey) is None
anc01 = (
"0AAAAAAAAAAAAAAAAAAAAABA"
"Ezpq06UecHwzy-K9FpNoRxCJp2wIGM9u2Edk-PLMZ1H4").encode("utf-8")
key = dgKey(regk, vdig.qb64b)
assert issuer.getAnc(key) is None
assert issuer.delAnc(key) is False
assert issuer.putAnc(key, val=anc01)
assert issuer.getAnc(key) == anc01
assert issuer.putAnc(key, val=anc01) is False
assert issuer.setAnc(key, val=anc01) is True
assert issuer.getAnc(key) == anc01
assert issuer.delAnc(key) is True
assert issuer.getAnc(key) is None
# test with verifiable credential issuance (iss) event
vcdig = b'EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc'
sn = 0
vs = Versify(kind=Serials.json, size=20)
vcp = dict(v=vs, i=vcdig.decode("utf-8"), s="{:x}".format(sn), t="iss")
issb = json.dumps(vcp, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
assert issb == (b'{"v":"KERI10JSON000014_",'
b'"i":"EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc",'
b''
b'"s":"0","t":"iss"}')
idig = Diger(ser=issb)
key = dgKey(vcdig, idig.qb64b)
assert issuer.getTvt(key) is None
assert issuer.delTvt(key) is False
assert issuer.putTvt(key, val=issb) is True
assert issuer.getTvt(key) == issb
assert issuer.putTvt(key, val=issb) is False
assert issuer.setTvt(key, val=issb) is True
assert issuer.getTvt(key) == issb
assert issuer.delTvt(key) is True
assert issuer.getTvt(key) is None
telKey = snKey(vcdig, sn)
assert issuer.getTel(telKey) is None
assert issuer.delTel(telKey) is False
assert issuer.putTel(telKey, val=idig.qb64b)
assert issuer.getTel(telKey) == idig.qb64b
assert issuer.putTel(telKey, val=idig.qb64b) is False
assert issuer.setTel(telKey, val=idig.qb64b) is True
assert issuer.getTel(telKey) == idig.qb64b
assert issuer.delTel(telKey) is True
assert issuer.getTel(telKey) is None
rev = dict(v=vs,
i=vcdig.decode("utf-8"),
s="{:x}".format(sn + 1),
t="rev")
revb = json.dumps(rev, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
assert revb == b'{"v":"KERI10JSON000014_","i":"EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc","s":"1","t":"rev"}'
rdig = Diger(raw=revb)
assert issuer.putTel(snKey(vcdig, sn), val=idig.qb64b) is True
assert issuer.putTel(snKey(vcdig, sn + 1), val=rdig.qb64b) is True
assert issuer.putTel(snKey(vcdig, sn + 2), val=idig.qb64b) is True
assert issuer.putTel(snKey(vcdig, sn + 3), val=rdig.qb64b) is True
result = [(sn, dig) for sn, dig in issuer.getTelItemPreIter(vcdig)]
assert result == [(0, idig.qb64b), (1, rdig.qb64b), (2, idig.qb64b),
(3, rdig.qb64b)]
bak1 = b'Bm1Q98kT0HRn9R62lY-LufjjKdbCeL1mqu9arTgOmbqI'
bak2 = b'DSEpNJeSJjxo6oAxkNE8eCOJg2HRPstqkeHWBAvN9XNU'
bak3 = b'Dvxo-P4W_Z0xXTfoA3_4DMPn7oi0mLCElOWJDpC0nQXw'
bak4 = b'BleAn9JkFuEOOwDhfkhnxtGsRQkMh2AH1oGB9QHAvl1U'
bak5 = b'Behy5f2BIJbAYdgoy00OcOEZwEyxCGCUDlzbGkbz1RAI'
baks = [bak1, bak2, bak3, bak4]
# test .baks insertion order dup methods. dup vals are insertion order
assert issuer.getBaks(key) == []
assert issuer.cntBaks(key) == 0
assert issuer.delBaks(key) is False
assert issuer.putBaks(key, baks) is True
assert issuer.getBaks(key) == baks
assert issuer.cntBaks(key) == len(baks) == 4
assert issuer.putBaks(key, vals=[bak1]) is False
assert issuer.getBaks(key) == baks
assert issuer.addBak(key, bak1) is False
assert issuer.addBak(key, bak5) is True
assert issuer.getBaks(key) == [bak1, bak2, bak3, bak4, bak5]
assert [val for val in issuer.getBaksIter(key)
] == [bak1, bak2, bak3, bak4, bak5]
assert issuer.delBaks(key) is True
assert issuer.getBaks(key) == []
"""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_tever_backers(mockHelpingNowUTC):
# registry with backer and receipt
with basing.openDB() as db, keeping.openKS() as kpr, viring.openReg(
) as reg:
valSecret = 'AgjD4nRlycmM5cPcAkfOATAp8wVldRsnc9f1tiwctXlw'
# create receipt signer prefixer default code is non-transferable
valSigner = Signer(qb64=valSecret, transferable=False)
valPrefixer = Prefixer(qb64=valSigner.verfer.qb64)
valpre = valPrefixer.qb64
assert valpre == 'B8KY1sKmgyjAiUDdUBPNPyrSz_ad_Qf9yzhDNZlEKiMc'
hab = buildHab(db, kpr)
vcp = eventing.incept(hab.pre,
baks=[valpre],
toad=1,
cnfg=[],
code=MtrDex.Blake3_256)
regk = vcp.pre
valCigar = valSigner.sign(ser=vcp.raw, index=0)
# successfully anchor to a rotation event
rseal = SealEvent(i=regk, s=vcp.ked["s"], d=vcp.diger.qb64)
rot = hab.rotate(data=[rseal._asdict()])
rotser = Serder(raw=rot)
seqner = Seqner(sn=int(rotser.ked["s"], 16))
diger = rotser.diger
tev = Tever(serder=vcp,
seqner=seqner,
diger=diger,
bigers=[valCigar],
db=db,
reger=reg)
dgkey = dgKey(pre=regk, dig=vcp.dig)
assert reg.getTvt(dgkey) == (
b'{"v":"KERI10JSON0000d7_","i":"EBZR8LxEozgFa6UXwtSAmiXsmdChrT7Hr-jcxc9NFfrU",'
b'"ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY","s":"0","t":"vcp","c":[],'
b'"bt":"1",'
b'"b":["B8KY1sKmgyjAiUDdUBPNPyrSz_ad_Qf9yzhDNZlEKiMc"]}')
assert reg.getAnc(
dgkey
) == b'0AAAAAAAAAAAAAAAAAAAAAAQEpWPsFsCcsu5SpVH0416qHx3gvG0CWlrP_i7BVdbmRBg'
assert reg.getTel(snKey(
pre=regk, sn=0)) == b'EJTWiS0ebp8VSyLr38x73dAHdUqivisUtAaGpEHt5HDc'
assert [bytes(tib) for tib in reg.getTibs(dgkey)] == [
b'AAGhpPxAoltsRAnqxf7NsBzWSxWYLZ_ALImVVBiTlzJSdlATxRp_hBK4AbOzu-a900hwRxa0RX-yVWbVJA6oxoBw'
]
assert reg.getTwe(snKey(pre=regk, sn=0)) is None
debSecret = 'AKUotEE0eAheKdDJh9QvNmSEmO_bjIav8V_GmctGpuCQ'
# create receipt signer prefixer default code is non-transferable
debSigner = Signer(qb64=debSecret, transferable=False)
debPrefixer = Prefixer(qb64=debSigner.verfer.qb64)
debpre = debPrefixer.qb64
assert debpre == 'BbWeWTNGXPMQrVuJmScNQn81YF7T2fhh2kXwT8E_NbeI'
vrt = eventing.rotate(regk, dig=vcp.dig, baks=[valpre], adds=[debpre])
valCigar = valSigner.sign(ser=vrt.raw, index=0)
debCigar = debSigner.sign(ser=vrt.raw, index=1)
# successfully anchor to a rotation event
rseal = SealEvent(regk, vrt.ked["s"], vrt.diger.qb64)
rot = hab.rotate(data=[rseal._asdict()])
rotser = Serder(raw=rot)
seqner = Seqner(sn=int(rotser.ked["s"], 16))
diger = rotser.diger
tev.update(serder=vrt,
seqner=seqner,
diger=diger,
bigers=[valCigar, debCigar])
assert tev.baks == [
'B8KY1sKmgyjAiUDdUBPNPyrSz_ad_Qf9yzhDNZlEKiMc',
'BbWeWTNGXPMQrVuJmScNQn81YF7T2fhh2kXwT8E_NbeI'
]
vcdig = b'EEBp64Aw2rsjdJpAR0e2qCq3jX7q7gLld3LjAwZgaLXU'
bis = eventing.backerIssue(vcdig=vcdig.decode("utf-8"),
regk=regk,
regsn=tev.sn,
regd=tev.serder.dig)
valCigar = valSigner.sign(ser=bis.raw, index=0)
debCigar = debSigner.sign(ser=bis.raw, index=1)
# successfully anchor to a rotation event
rseal = SealEvent(bis.ked["i"], bis.ked["s"], bis.diger.qb64)
rot = hab.rotate(data=[rseal._asdict()])
rotser = Serder(raw=rot)
seqner = Seqner(sn=int(rotser.ked["s"], 16))
diger = rotser.diger
tev.update(bis,
seqner=seqner,
diger=diger,
bigers=[valCigar, debCigar])
vci = nsKey([regk, vcdig])
dgkey = dgKey(pre=vci, dig=bis.dig)
assert bytes(reg.getTvt(dgkey)) == (
b'{"v":"KERI10JSON00012d_","i":"EEBp64Aw2rsjdJpAR0e2qCq3jX7q7gLld3LjAwZgaLXU",'
b'"ii":"EBZR8LxEozgFa6UXwtSAmiXsmdChrT7Hr-jcxc9NFfrU","s":"0","t":"bis","ra":{'
b'"i":"EBZR8LxEozgFa6UXwtSAmiXsmdChrT7Hr-jcxc9NFfrU","s":1,"d":"EZH2Cfw3nvcMRg'
b'Y31Jyc2zHVh4a0LO_bVZ4EmL4V8Ol8"},"dt":"2021-01-01T00:00:00.000000+00:00"}'
)
def test_tever_no_backers(mockHelpingNowUTC):
# registry with no backers
# registry with backer and receipt
with basing.openDB() as db, keeping.openKS() as kpr, viring.openReg(
) as reg:
hab = buildHab(db, kpr)
vcp = eventing.incept(hab.pre,
baks=[],
toad=0,
cnfg=["NB"],
code=MtrDex.Blake3_256)
regk = vcp.pre
# successfully anchor to a rotation event
rseal = SealEvent(i=regk, s=vcp.ked["s"], d=vcp.diger.qb64)
rot = hab.rotate(data=[rseal._asdict()])
rotser = Serder(raw=rot)
seqner = Seqner(sn=int(rotser.ked["s"], 16))
diger = rotser.diger
tev = Tever(serder=vcp, seqner=seqner, diger=diger, db=db, reger=reg)
assert tev.prefixer.qb64 == vcp.pre
assert tev.sn == 0
dgkey = dgKey(pre=regk, dig=vcp.dig)
assert reg.getTvt(dgkey) == (
b'{"v":"KERI10JSON0000ad_","i":"Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyLehw",'
b'"ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY","s":"0","t":"vcp","c":["NB"],"bt":"0","b":[]}'
)
assert reg.getAnc(dgkey) == (
b'0AAAAAAAAAAAAAAAAAAAAAAQE-yQ6BjCaJg-u2mNuE-ycVWVTq7IZ8TuN-Ew8soLijSA'
)
assert reg.getTel(snKey(
pre=regk, sn=0)) == b'ElYstqTocyQixLLz4zYCAs2unaFco_p6LqH0W01loIg4'
assert reg.getTibs(dgkey) == []
assert reg.getTwe(snKey(pre=regk, sn=0)) is None
# try to rotate a backerless registry
vrt = eventing.rotate(regk, dig=vcp.dig)
rseal = SealEvent(regk, vrt.ked["s"], vrt.diger.qb64)
rot = hab.rotate(data=[rseal._asdict()])
rotser = Serder(raw=rot)
seqner = Seqner(sn=int(rotser.ked["s"], 16))
diger = rotser.diger
# should raise validation err because rotation is not supported
with pytest.raises(ValidationError):
tev.update(serder=vrt, seqner=seqner, diger=diger)
vcdig = b'EEBp64Aw2rsjdJpAR0e2qCq3jX7q7gLld3LjAwZgaLXU'
iss = eventing.issue(vcdig=vcdig.decode("utf-8"), regk=regk)
# successfully anchor to a rotation event
rseal = SealEvent(iss.ked["i"], iss.ked["s"], iss.diger.qb64)
rot = hab.rotate(data=[rseal._asdict()])
rotser = Serder(raw=rot)
seqner = Seqner(sn=int(rotser.ked["s"], 16))
diger = rotser.diger
tev.update(iss, seqner=seqner, diger=diger)
vci = nsKey([regk, vcdig])
dgkey = dgKey(pre=vci, dig=iss.dig)
assert bytes(reg.getTvt(dgkey)) == (
b'{"v":"KERI10JSON0000ba_","i":"EEBp64Aw2rsjdJpAR0e2qCq3jX7q7gLld3LjAwZgaLXU",'
b'"s":"0","t":"iss","ri":"Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyLehw","dt":"'
b'2021-01-01T00:00:00.000000+00:00"}')
assert bytes(
reg.getAnc(dgkey)
) == b'0AAAAAAAAAAAAAAAAAAAAAAwEJLLpuUKPSDIcoOAOArQBzceWc8MoShm-cDL-w81liIw'
# revoke vc with no backers
rev = eventing.revoke(vcdig=vcdig.decode("utf-8"),
regk=regk,
dig=iss.dig)
# successfully anchor to a rotation event
rseal = SealEvent(rev.ked["i"], rev.ked["s"], rev.diger.qb64)
rot = hab.rotate(data=[rseal._asdict()])
rotser = Serder(raw=rot)
seqner = Seqner(sn=int(rotser.ked["s"], 16))
diger = rotser.diger
tev.update(rev, seqner=seqner, diger=diger)
dgkey = dgKey(pre=vci, dig=rev.dig)
assert bytes(reg.getTvt(dgkey)) == (
b'{"v":"KERI10JSON0000ed_","i":"EEBp64Aw2rsjdJpAR0e2qCq3jX7q7gLld3LjAwZgaLXU",'
b'"s":"1","t":"rev","ri":"Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyLehw","p":"E'
b'C9PffPrvyaKzsn72SWTvgyvWCJ1FbDThvJhsQ9LWo9M","dt":"2021-01-01T00:00:00.00000'
b'0+00:00"}')
def test_tever_escrow():
with pytest.raises(TypeError):
Tever()
# registry with no backers, invalid anchor
with basing.openDB() as db, keeping.openKS() as kpr, viring.openReg(
) as reg:
hab = buildHab(db, kpr)
vcp = eventing.incept(hab.pre,
baks=[],
toad=0,
cnfg=[],
code=MtrDex.Blake3_256)
regk = vcp.pre
assert regk == "EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9vSY"
assert vcp.dig == "EvpB-_BWD7tOhLI0cDyEQbziBt6IMyQnkrh0booR4vhg"
assert vcp.ked["ii"] == hab.pre
# anchor to nothing, exception expected
seqner = Seqner(sn=4)
# invalid seal sn
with pytest.raises(ValidationError):
Tever(serder=vcp, seqner=seqner, diger=None, db=db, reger=reg)
# registry with no backers
with basing.openDB() as db, keeping.openKS() as kpr, viring.openReg(
) as reg:
hab = buildHab(db, kpr)
vcp = eventing.incept(hab.pre,
baks=[],
toad=0,
cnfg=[],
code=MtrDex.Blake3_256)
regk = vcp.pre
# anchoring event not in db, exception and escrow
seqner = Seqner(sn=1)
with pytest.raises(MissingAnchorError):
Tever(serder=vcp, seqner=seqner, db=db, reger=reg)
dgkey = dgKey(pre=regk, dig=vcp.dig)
assert reg.getTvt(dgkey) == (
b'{"v":"KERI10JSON0000a9_","i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9vSY",'
b'"ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY","s":"0","t":"vcp","c":[],"bt":"0","b":[]}'
)
assert reg.getTae(snKey(
pre=regk, sn=0)) == b'EvpB-_BWD7tOhLI0cDyEQbziBt6IMyQnkrh0booR4vhg'
# registry with backers, no signatures. should escrow
with basing.openDB() as db, keeping.openKS() as kpr, viring.openReg(
) as reg:
hab = buildHab(db, kpr)
vcp = eventing.incept(
hab.pre,
baks=["BoOcciw30IVQsaenKXpiyMVrjtPDW3KeD_6KFnSfoaqI"],
toad=1,
cnfg=[],
code=MtrDex.Blake3_256)
regk = vcp.pre
# successfully anchor to a rotation event
rseal = SealEvent(regk, vcp.ked["s"], vcp.diger.qb64)
rot = hab.rotate(data=[rseal._asdict()])
rotser = Serder(raw=rot)
seqner = Seqner(sn=int(rotser.ked["s"], 16))
diger = rotser.diger
with pytest.raises(MissingWitnessSignatureError):
Tever(serder=vcp, seqner=seqner, diger=diger, db=db, reger=reg)
dgkey = dgKey(pre=regk, dig=vcp.dig)
assert reg.getTvt(dgkey) == (
b'{"v":"KERI10JSON0000d7_","i":"E1cv04kvHvWPrfncYsq-lQ-QvyKmKz6-hlGj02B2QWbk",'
b'"ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY","s":"0","t":"vcp","c":[],"bt":"1",'
b'"b":["BoOcciw30IVQsaenKXpiyMVrjtPDW3KeD_6KFnSfoaqI"]}')
assert reg.getAnc(dgkey) == (
b'0AAAAAAAAAAAAAAAAAAAAAAQE1NdOqtN0HlhBPc7-MHvsA4vajMwFYp2eIturQQo0stM'
)
assert reg.getTel(snKey(pre=regk, sn=0)) is None
assert reg.getTwe(snKey(
pre=regk, sn=0)) == b'EjhsbizNCwN_EFuOxbUt8CN0xOctGRIVOW8X-XqA3fSk'
