def backer_revoke(
vcdig,
regk,
regsn,
regd,
version=Version,
kind=Serials.json,
):
"""
Returns serder of brv message event
Utility function to create a VC revocation event
Parameters:
vcdig is hash digest of vc content qb64
regk is regsitry identifier prefix qb64
regsn is int sequence number of anchoring registry TEL event
regd is digest qb64 of anchoring registry TEL event
"""
vs = Versify(version=version, kind=kind, size=0)
isn = 1
ilk = Ilks.rev
seal = SealEvent(regk, regsn, regd)
ked = dict(
v=vs,
i=vcdig,
s="{:x}".format(isn), # hex string no leading zeros lowercase
t=ilk,
ra=seal._asdict())
return Serder(ked=ked) # return serialized ked
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_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_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_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'