def __init__(self, hab, name="test", reg=None, allowBackers=True, baks=None, toad=None,
estOnly=False):
"""
Initialize Instance
Parameters:
name is the alias for this issuer
hab is Habitat instance of local controller's context
reg is Registry instance for controller's credentials
allowBackers is boolean True to allow specification of TEL specific backers
backers is the initial list of backer prefixes qb64 for VCs in the Registry
toad is int or str hex of witness threshold
estOnly is boolean True for forcing rotation events for every TEL event.
"""
self.estOnly = estOnly
self.allowBackers = allowBackers
self.hab = hab
self.name = name
self.regi = 0
self.vcser = None
self.reg = reg if reg is not None else Registry(name=name)
# save backers locally for now. will be managed by tever when implemented
self.backers = baks if baks is not None else []
self.cnfg = [] if self.allowBackers else [TraitDex.NoBackers]
self.regser = eventing.incept(self.hab.pre,
baks=self.backers,
toad=toad,
cnfg=self.cnfg,
code=MtrDex.Blake3_256)
self.regk = self.regser.pre
rseal = SealEvent(self.regk, self.regser.ked["s"], self.regser.diger.qb64)
if self.estOnly:
self.ianchor = self.hab.rotate(data=rseal)
else:
self.ianchor = self.hab.interact(data=rseal)
seal = SealEvent(i=self.hab.pre, s=self.hab.kever.sn, d=self.hab.kever.serder.dig)
msg = self.messagize(serder=self.regser, seal=seal)
# Process message in local Tevery when ready for now assign to self for testing
self.incept = msg
def test_incept():
"""
Test incept utility function
"""
pre = "DntNTPnDFBnmlO6J44LXCrzZTAmpe-82b7BmQGtL4QhM"
bak1 = "EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc"
bak2 = "DSEpNJeSJjxo6oAxkNE8eCOJg2HRPstqkeHWBAvN9XNU"
bak3 = "Dvxo-P4W_Z0xXTfoA3_4DMPn7oi0mLCElOWJDpC0nQXw"
# no backers, allowed to add later
serder = eventing.incept(pre, baks=[])
assert serder.raw == (
b'{"v":"KERI10JSON0000a0_","i":"E_TB9WKVB4Zx-Wu3-u1_RQWy2ZrDccaOj2xUpHQcg0MA",'
b'"ii":"DntNTPnDFBnmlO6J44LXCrzZTAmpe-82b7BmQGtL4QhM","s":"0","t":"vcp","c":[],"b":[]}'
)
# no backers allowed
serder = eventing.incept(pre, baks=[], cnfg=[TraitDex.NoBackers])
assert serder.raw == (
b'{"v":"KERI10JSON0000a4_","i":"EEDVlhKzGXA6C7n1igQF8m4WfTAEuwuvitgoM4DI3iCs",'
b'"ii":"DntNTPnDFBnmlO6J44LXCrzZTAmpe-82b7BmQGtL4QhM","s":"0","t":"vcp","c":["NB"],"b":[]}'
)
# no backers allows, one attempted
with pytest.raises(ValueError):
eventing.incept(pre, cnfg=[TraitDex.NoBackers], baks=[bak1])
# one backer
serder = eventing.incept(pre, baks=[bak1])
assert serder.raw == (
b'{"v":"KERI10JSON0000ce_","i":"E_e9zbZI8WCMNoaY1b-3aEVB59M6dc2Br8EDJ1_ozK-8",'
b'"ii":"DntNTPnDFBnmlO6J44LXCrzZTAmpe-82b7BmQGtL4QhM","s":"0","t":"vcp","c":[],'
b'"b":["EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc"]}')
# 3 backers
serder = eventing.incept(pre, baks=[bak1, bak2, bak3])
assert serder.raw == (
b'{"v":"KERI10JSON00012c_","i":"EEuFeIT3_0_IAaNg8D-5AxO6UtQCmD17n77iksL048Go",'
b'"ii":"DntNTPnDFBnmlO6J44LXCrzZTAmpe-82b7BmQGtL4QhM","s":"0","t":"vcp","c":[],'
b'"b":["EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc",'
b'"DSEpNJeSJjxo6oAxkNE8eCOJg2HRPstqkeHWBAvN9XNU",'
b'"Dvxo-P4W_Z0xXTfoA3_4DMPn7oi0mLCElOWJDpC0nQXw"]}')
""" End Test """
def test_incept():
"""
Test incept utility function
"""
pre = "DntNTPnDFBnmlO6J44LXCrzZTAmpe-82b7BmQGtL4QhM"
bak1 = "EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc"
bak2 = "DSEpNJeSJjxo6oAxkNE8eCOJg2HRPstqkeHWBAvN9XNU"
bak3 = "Dvxo-P4W_Z0xXTfoA3_4DMPn7oi0mLCElOWJDpC0nQXw"
# no backers, allowed to add later
serder = eventing.incept(pre, baks=[], code=MtrDex.Blake3_256)
assert serder.raw == (
b'{"v":"KERI10JSON0000a9_","i":"EiLMklo_OJmbv8D58wPlv_fudfEzuqsIl3mFYq640Jzg",'
b'"ii":"DntNTPnDFBnmlO6J44LXCrzZTAmpe-82b7BmQGtL4QhM","s":"0","t":"vcp","c":[],"bt":"0","b":[]}'
)
# no backers allowed
serder = eventing.incept(pre,
baks=[],
cnfg=[TraitDex.NoBackers],
code=MtrDex.Blake3_256)
assert serder.raw == (
b'{"v":"KERI10JSON0000ad_","i":"EjD_sFljMHXJCC3rEFL93MwHNGguKdC11mcMuQnZitcs",'
b'"ii":"DntNTPnDFBnmlO6J44LXCrzZTAmpe-82b7BmQGtL4QhM","s":"0","t":"vcp","c":["NB"],"bt":"0","b":[]}'
)
# no backers allows, one attempted
with pytest.raises(ValueError):
eventing.incept(pre, cnfg=[TraitDex.NoBackers], baks=[bak1])
# with backer dupes
with pytest.raises(ValueError):
eventing.incept(pre, cnfg=[], baks=[bak1, bak1, bak2])
# with oob toad
with pytest.raises(ValueError):
eventing.incept(pre, cnfg=[], toad=4, baks=[bak1, bak2, bak3])
# with oob toad
with pytest.raises(ValueError):
eventing.incept(pre, cnfg=[], toad=1, baks=[])
# one backer
serder = eventing.incept(pre, baks=[bak1], code=MtrDex.Blake3_256)
assert serder.raw == (
b'{"v":"KERI10JSON0000d7_","i":"EVohdnN33-vdNOTPYxeTQIWVzRKtzZzBoiBSGYSSnD0s",'
b'"ii":"DntNTPnDFBnmlO6J44LXCrzZTAmpe-82b7BmQGtL4QhM","s":"0","t":"vcp","c":[],"bt":"1",'
b'"b":["EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc"]}')
# 3 backers
serder = eventing.incept(pre,
baks=[bak1, bak2, bak3],
code=MtrDex.Blake3_256)
assert serder.raw == (
b'{"v":"KERI10JSON000135_","i":"Ez5ncVo7zXjC9DJT8-DM-ZMqJ-WtgpEGGs8JUzXh_Tc0",'
b'"ii":"DntNTPnDFBnmlO6J44LXCrzZTAmpe-82b7BmQGtL4QhM","s":"0","t":"vcp","c":[],"bt":"3",'
b'"b":["EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc","DSEpNJeSJjxo6oAxkNE8eCOJg2HRPstqkeHWBAvN9XNU",'
b'"Dvxo-P4W_Z0xXTfoA3_4DMPn7oi0mLCElOWJDpC0nQXw"]}')
# one backer, with threshold
serder = eventing.incept(pre, toad=1, baks=[bak1], code=MtrDex.Blake3_256)
assert serder.raw == (
b'{"v":"KERI10JSON0000d7_","i":"EVohdnN33-vdNOTPYxeTQIWVzRKtzZzBoiBSGYSSnD0s",'
b'"ii":"DntNTPnDFBnmlO6J44LXCrzZTAmpe-82b7BmQGtL4QhM","s":"0","t":"vcp","c":[],"bt":"1",'
b'"b":["EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc"]}')
# 3 backers, with threshold
serder = eventing.incept(pre,
toad=2,
baks=[bak1, bak2, bak3],
code=MtrDex.Blake3_256)
assert serder.raw == (
b'{"v":"KERI10JSON000135_","i":"E39gu2hSUBannC3st40r2d8Dy7T6JsyTk0JefYYPtDgE",'
b'"ii":"DntNTPnDFBnmlO6J44LXCrzZTAmpe-82b7BmQGtL4QhM","s":"0","t":"vcp","c":[],"bt":"2",'
b'"b":["EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc","DSEpNJeSJjxo6oAxkNE8eCOJg2HRPstqkeHWBAvN9XNU",'
b'"Dvxo-P4W_Z0xXTfoA3_4DMPn7oi0mLCElOWJDpC0nQXw"]}')
""" End Test """
def test_tevery():
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
tvy = Tevery(reger=reg, db=db)
tvy.processEvent(serder=vcp, seqner=seqner, diger=diger)
assert regk in tvy.tevers
tev = tvy.tevers[regk]
assert tev.prefixer.qb64 == vcp.pre
assert tev.sn == 0
# send vcp again, get error
with pytest.raises(LikelyDuplicitousError):
tvy.processEvent(serder=vcp, seqner=seqner, diger=diger)
# process issue vc event
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
tvy.processEvent(serder=iss, seqner=seqner, diger=diger)
assert tev.vcState(vcdig) == VcStates.issued
assert tev.vcSn(vcdig) == 0
# revoke the vc
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
tvy.processEvent(serder=rev, seqner=seqner, diger=diger)
assert tev.vcState(vcdig) == VcStates.revoked
assert tev.vcSn(vcdig) == 1
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'