def test_issuer(mockHelpingNowUTC):
# help.ogler.resetLevel(level=logging.DEBUG)
with basing.openDB(name="bob") as db, keeping.openKS(
name="bob") as kpr, viring.openReg() as reg:
hab = buildHab(db, kpr)
# setup issuer with defaults for allowBackers, backers and estOnly
issuer = Issuer(hab=hab, name="bob", reger=reg)
assert issuer.incept == (
b'{"v":"KERI10JSON0000a9_","i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9vSY",'
b'"ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY","s":"0","t":"vcp","c":[],"bt":"0",'
b'"b":[]}-GAB0AAAAAAAAAAAAAAAAAAAAAAQElQxdAkGEMsdDn_GFiYPU1eVgQ3z1MvVPEoAGP3THI3A'
)
assert issuer.ianchor == (
b'{"v":"KERI10JSON000107_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY","s":"1","t":"ixn",'
b'"p":"Eg3wsIOW3RdCqhcG4xZ4uZhTA_qTE24DoLeyjFBB8rks",'
b'"a":[{"i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9vSY","s":"0",'
b'"d":"EvpB-_BWD7tOhLI0cDyEQbziBt6IMyQnkrh0booR4vhg'
b'"}]}-AABAAVDMZ3Zfu5Vhw4vIBBbh4oh7l6XACLfOFpS7VN_Tn0vrBlZuHxktv1D9S0Q_e-YbP-PXBjiAnkupzaQ50saSfAA'
)
# ensure the digest in the seal from the key event matches the transacript event digest
ser = Serder(raw=issuer.incept)
assert ser.diger.qb64 == 'EvpB-_BWD7tOhLI0cDyEQbziBt6IMyQnkrh0booR4vhg'
tevt, kevt = issuer.rotate(
adds=["BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU"])
assert tevt == (
b'{"v":"KERI10JSON0000d8_","i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9vSY",'
b'"p":"EvpB-_BWD7tOhLI0cDyEQbziBt6IMyQnkrh0booR4vhg","s":"1","t":"vrt","bt":"1","br":[],'
b'"ba":["BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU'
b'"]}-GAB0AAAAAAAAAAAAAAAAAAAAAAgEf12IRHtb_gVo5ClaHHNV90b43adA0f8vRs3jeU-AstY'
)
assert kevt == (
b'{"v":"KERI10JSON000107_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY","s":"2","t":"ixn",'
b'"p":"ElQxdAkGEMsdDn_GFiYPU1eVgQ3z1MvVPEoAGP3THI3A",'
b'"a":[{"i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9vSY","s":"1",'
b'"d":"EpltHxeKueSR1a7e0_oSAhgO6U7VDnX7x4KqNCwBqbI0"}]}-AABAAb-kk2ijQRZkVmmvWpRcyDLRZad3YOKOvev0yZq'
b'-ay5QyW9J574kIUxOwgFbC-DUkRIKdPPHkBWZdPSjw6IT-Cg')
ser = Serder(raw=tevt)
assert ser.diger.qb64 == 'EpltHxeKueSR1a7e0_oSAhgO6U7VDnX7x4KqNCwBqbI0'
tevt, kevt = issuer.issue(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
assert tevt == (
b'{"v":"KERI10JSON00012d_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL'
b'vaU6Z-i0d8","ii":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9vSY",'
b'"s":"0","t":"bis","ra":{"i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDG'
b'eLWHb9vSY","s":1,"d":"EpltHxeKueSR1a7e0_oSAhgO6U7VDnX7x4KqNCwBqb'
b'I0"},"dt":"2021-01-01T00:00:00.000000+00:00"}-GAB0AAAAAAAAAAAAAA'
b'AAAAAAAAwEke0QhYPogZ-pKBMDhQj6fImswFB3HSZLVdYPvvQeBCE')
assert kevt == (
b'{"v":"KERI10JSON000107_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu'
b'k5aMtSrMtY","s":"3","t":"ixn","p":"Ef12IRHtb_gVo5ClaHHNV90b43adA'
b'0f8vRs3jeU-AstY","a":[{"i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULva'
b'U6Z-i0d8","s":"0","d":"EyRQ8Yz7vkua8qIqp89_cuYt71gdc9rpE4A6aj_qc'
b'71Q"}]}-AABAA7i4dJM3hMs9yZpUL01mzNbnai6Q6obbvChybnVNodoRiEZfrz9n'
b'rmMFtyJcYCUbg8rnfcJfDK9O8sZOeY5yuBg')
ser = Serder(raw=tevt)
assert ser.diger.qb64 == 'EyRQ8Yz7vkua8qIqp89_cuYt71gdc9rpE4A6aj_qc71Q'
tevt, kevt = issuer.revoke(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
assert tevt == (
b'{"v":"KERI10JSON00012c_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8","s":"1","t":"brv",'
b'"p":"EyRQ8Yz7vkua8qIqp89_cuYt71gdc9rpE4A6aj_qc71Q",'
b'"ra":{"i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9vSY","s":1,'
b'"d":"EpltHxeKueSR1a7e0_oSAhgO6U7VDnX7x4KqNCwBqbI0"},'
b'"dt":"2021-01-01T00:00:00.000000+00:00"}-GAB0AAAAAAAAAAAAAAAAAAAAABAE3b-DChDs_elyF8J'
b'-2NF5E9LugwzV_zJ_QqlUg46aWS0')
assert kevt == (
b'{"v":"KERI10JSON000107_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY","s":"4","t":"ixn",'
b'"p":"Eke0QhYPogZ-pKBMDhQj6fImswFB3HSZLVdYPvvQeBCE",'
b'"a":[{"i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8","s":"1",'
b'"d":"EoZbbgb3JrlQFAyTwXwt_yJj-pE2M7kGTCgZ1nMA1j30'
b'"}]}-AABAA2uvL7t5qPsWmwyGtcOktw6nXLKXMLBIsgd_XikYulv0UNfNZ-Ef-4af1WkAOlv226p9pZIjBFGy427TaOi5bAg'
)
ser = Serder(raw=tevt)
assert ser.diger.qb64 == 'EoZbbgb3JrlQFAyTwXwt_yJj-pE2M7kGTCgZ1nMA1j30'
with basing.openDB(name="bob") as db, keeping.openKS(
name="bob") as kpr, viring.openReg() as reg:
hab = buildHab(db, kpr)
# issuer, not allowed to issue backers
issuer = Issuer(hab=hab, name="bob", noBackers=True, reger=reg)
ser = Serder(raw=issuer.incept)
assert ser.pre == "Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyLehw"
assert ser.ked["t"] == "vcp"
assert ser.ked["c"] == ["NB"]
assert ser.ked["b"] == []
assert ser.ked["bt"] == "0"
ser = Serder(raw=issuer.ianchor)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "ixn"
seal = ser.ked["a"][0]
assert seal["i"] == "Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyLehw"
assert seal["s"] == "0"
assert seal["d"] == "ElYstqTocyQixLLz4zYCAs2unaFco_p6LqH0W01loIg4"
with pytest.raises(ValueError):
issuer.rotate(
adds=["EqoNZAX5Lu8RuHzwwyn5tCZTe-mDBq5zusCrRo5TDugs"])
with basing.openDB(name="bob") as db, keeping.openKS(
name="bob") as kpr, viring.openReg() as reg:
hab = buildHab(db, kpr)
issuer = Issuer(hab=hab, name="bob", noBackers=True, reger=reg)
tevt, kevt = issuer.issue(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
ser = Serder(raw=tevt)
assert ser.pre == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert ser.ked[
"ri"] == "Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyLehw"
assert ser.ked["t"] == "iss"
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "ixn"
seal = ser.ked["a"][0]
assert seal["i"] == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert seal["s"] == "0"
assert seal["d"] == 'Ewia5uvi4RAgr3rG_YlHSNPT3DxCa-2UDZ-TldDJPDWs'
tevt, kevt = issuer.revoke(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
ser = Serder(raw=tevt)
assert ser.pre == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert ser.ked["t"] == "rev"
assert ser.ked[
"ri"] == "Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyLehw"
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "ixn"
seal = ser.ked["a"][0]
assert seal["i"] == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert seal["s"] == "1"
assert seal["d"] == 'EZGxxhShIC6KT_iKRHMtONyKpckqGa-waTbpPo7gn21A'
with basing.openDB(name="bob") as db, keeping.openKS(
name="bob") as kpr, viring.openReg() as reg:
hab = buildHab(db, kpr)
# issuer, allowed backers, initial set of backers
issuer = Issuer(hab=hab,
reger=reg,
baks=["BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU"])
ser = Serder(raw=issuer.incept)
assert ser.pre == "EaU321874i434f59ab7cMH6YlN52PJ395nrLS_6tLq6c"
assert ser.ked["t"] == "vcp"
assert ser.ked["b"] == ["BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU"]
assert ser.ked["bt"] == "1"
ser = Serder(raw=issuer.ianchor)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "ixn"
seal = ser.ked["a"][0]
assert seal["i"] == "EaU321874i434f59ab7cMH6YlN52PJ395nrLS_6tLq6c"
tevt, kevt = issuer.issue(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
ser = Serder(raw=tevt)
assert ser.pre == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert ser.ked["t"] == "bis"
seal = ser.ked["ra"]
assert seal["i"] == "EaU321874i434f59ab7cMH6YlN52PJ395nrLS_6tLq6c"
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "ixn"
seal = ser.ked["a"][0]
assert seal["i"] == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert seal["s"] == "0"
tevt, kevt = issuer.rotate(adds=[
"B9DfgIp33muOuCI0L8db_TldMJXv892UmW8yfpUuKzkw",
"BBC_BBLMeVwKFbfYSWU7aATS9itLSrGtIFQzCkfoKnjk"
])
vrtser = Serder(raw=tevt)
ser = Serder(raw=tevt)
assert ser.pre == "EaU321874i434f59ab7cMH6YlN52PJ395nrLS_6tLq6c"
assert ser.ked["t"] == "vrt"
assert ser.ked["ba"] == [
"B9DfgIp33muOuCI0L8db_TldMJXv892UmW8yfpUuKzkw",
"BBC_BBLMeVwKFbfYSWU7aATS9itLSrGtIFQzCkfoKnjk"
]
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "ixn"
seal = ser.ked["a"][0]
assert seal["i"] == "EaU321874i434f59ab7cMH6YlN52PJ395nrLS_6tLq6c"
assert seal["s"] == "1"
tevt, kevt = issuer.revoke(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
ser = Serder(raw=tevt)
assert ser.pre == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert ser.ked["t"] == "brv"
seal = ser.ked["ra"]
# ensure the ra seal digest matches the vrt event digest
assert seal["d"] == vrtser.diger.qb64
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "ixn"
seal = ser.ked["a"][0]
assert seal["i"] == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert seal["s"] == "1"
with basing.openDB(name="bob") as db, keeping.openKS(
name="bob") as kpr, viring.openReg() as reg:
hab = buildHab(db, kpr)
# issuer, no backers allowed, establishment events only
issuer = Issuer(hab=hab, reger=reg, noBackers=True, estOnly=True)
ser = Serder(raw=issuer.incept)
assert ser.pre == "Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyLehw"
assert ser.ked["t"] == "vcp"
assert ser.ked["c"] == ["NB"]
assert ser.ked["bt"] == "0"
ser = Serder(raw=issuer.ianchor)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "rot"
assert ser.ked["k"] == ["DKPE5eeJRzkRTMOoRGVd2m18o8fLqM2j9kaxLhV3x8AQ"]
assert ser.ked["n"] == "ELqHYQwWR0h2vP1_cxTsutU0wKJ_NrwBVKJCgPgWGgwc"
tevt, kevt = issuer.issue(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
ser = Serder(raw=tevt)
assert ser.pre == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert ser.ked["t"] == "iss"
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "rot"
tevt, kevt = issuer.revoke(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
ser = Serder(raw=tevt)
assert ser.pre == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert ser.ked["t"] == "rev"
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "rot"
with pytest.raises(ValueError):
issuer.rotate(
adds=["BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU"])
with basing.openDB(name="bob") as db, keeping.openKS(
name="bob") as kpr, viring.openReg() as reg:
hab = buildHab(db, kpr)
# issuer, backers allowed, initial backer, establishment events only
issuer = Issuer(hab=hab,
reger=reg,
baks=["BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU"],
estOnly=True)
ser = Serder(raw=issuer.incept)
assert ser.pre == "EaU321874i434f59ab7cMH6YlN52PJ395nrLS_6tLq6c"
assert ser.ked["b"] == ["BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU"]
assert ser.diger.qb64 == 'EevCI-l5dfYW63xg1bQ52ldLQa3li8FBo-znWxNEzv7E'
ser = Serder(raw=issuer.ianchor)
assert ser.ked["t"] == "rot"
tevt, kevt = issuer.rotate(
toad=3,
adds=[
"B9DfgIp33muOuCI0L8db_TldMJXv892UmW8yfpUuKzkw",
"BBC_BBLMeVwKFbfYSWU7aATS9itLSrGtIFQzCkfoKnjk"
])
vrtser = Serder(raw=tevt)
ser = Serder(raw=tevt)
assert ser.pre == "EaU321874i434f59ab7cMH6YlN52PJ395nrLS_6tLq6c"
assert ser.ked["t"] == "vrt"
assert issuer.backers == [
"BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU",
"B9DfgIp33muOuCI0L8db_TldMJXv892UmW8yfpUuKzkw",
"BBC_BBLMeVwKFbfYSWU7aATS9itLSrGtIFQzCkfoKnjk"
]
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "rot"
tevt, kevt = issuer.issue(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
ser = Serder(raw=tevt)
assert ser.pre == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert ser.ked["t"] == "bis"
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "rot"
assert vrtser.diger.qb64 == 'ECQbOOZdBxpw5RTH4VvPXDSH_o2uYdPWSoWolW5tobgA'
# rotate to no backers
tevt, kevt = issuer.rotate(
toad=2, cuts=["BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU"])
ser = Serder(raw=tevt)
assert ser.pre == "EaU321874i434f59ab7cMH6YlN52PJ395nrLS_6tLq6c"
assert ser.ked["t"] == "vrt"
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "rot"
vrtser = Serder(raw=tevt)
tevt, kevt = issuer.revoke(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
ser = Serder(raw=tevt)
assert ser.pre == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert ser.ked["t"] == "brv"
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "rot"
assert vrtser.diger.qb64 == 'EnUD_KZu-dGpFSEWZOlFdQSydioYY78qIDPfzA7Fhr-Q'
""" End Test """
def test_issuer(mockHelpingNowUTC):
# help.ogler.resetLevel(level=logging.DEBUG)
with basing.openDB(name="bob") as db, keeping.openKS(
name="bob") as kpr, viring.openReg() as reg:
hab = buildHab(db, kpr)
# setup issuer with defaults for allowBackers, backers and estOnly
issuer = Issuer(hab=hab, name="bob", reger=reg)
assert issuer.incept == (
b'{"v":"KERI10JSON0000a9_","i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9vSY",'
b'"ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY","s":"0","t":"vcp","c":[],"bt":"0",'
b'"b":[]}-GAB0AAAAAAAAAAAAAAAAAAAAAAQElQxdAkGEMsdDn_GFiYPU1eVgQ3z1MvVPEoAGP3THI3A'
)
assert issuer.ianchor == (
b'{"v":"KERI10JSON000107_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY","s":"1","t":"ixn",'
b'"p":"Eg3wsIOW3RdCqhcG4xZ4uZhTA_qTE24DoLeyjFBB8rks",'
b'"a":[{"i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9vSY","s":"0",'
b'"d":"EvpB-_BWD7tOhLI0cDyEQbziBt6IMyQnkrh0booR4vhg'
b'"}]}-AABAAVDMZ3Zfu5Vhw4vIBBbh4oh7l6XACLfOFpS7VN_Tn0vrBlZuHxktv1D9S0Q_e-YbP-PXBjiAnkupzaQ50saSfAA'
)
# ensure the digest in the seal from the key event matches the transacript event digest
ser = Serder(raw=issuer.incept)
assert ser.diger.qb64 == 'EvpB-_BWD7tOhLI0cDyEQbziBt6IMyQnkrh0booR4vhg'
tevt, kevt = issuer.rotate(
adds=["BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU"])
assert tevt == (
b'{"v":"KERI10JSON0000d8_","i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9vSY",'
b'"p":"EvpB-_BWD7tOhLI0cDyEQbziBt6IMyQnkrh0booR4vhg","s":"1","t":"vrt","bt":"1","br":[],'
b'"ba":["BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU'
b'"]}-GAB0AAAAAAAAAAAAAAAAAAAAAAgEf12IRHtb_gVo5ClaHHNV90b43adA0f8vRs3jeU-AstY'
)
assert kevt == (
b'{"v":"KERI10JSON000107_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY","s":"2","t":"ixn",'
b'"p":"ElQxdAkGEMsdDn_GFiYPU1eVgQ3z1MvVPEoAGP3THI3A",'
b'"a":[{"i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9vSY","s":"1",'
b'"d":"EpltHxeKueSR1a7e0_oSAhgO6U7VDnX7x4KqNCwBqbI0"}]}-AABAAb-kk2ijQRZkVmmvWpRcyDLRZad3YOKOvev0yZq'
b'-ay5QyW9J574kIUxOwgFbC-DUkRIKdPPHkBWZdPSjw6IT-Cg')
ser = Serder(raw=tevt)
assert ser.diger.qb64 == 'EpltHxeKueSR1a7e0_oSAhgO6U7VDnX7x4KqNCwBqbI0'
tevt, kevt = issuer.issue(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
assert tevt == (
b'{"v":"KERI10JSON00012d_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL'
b'vaU6Z-i0d8","ii":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9vSY",'
b'"s":"0","t":"bis","ra":{"i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDG'
b'eLWHb9vSY","s":1,"d":"EpltHxeKueSR1a7e0_oSAhgO6U7VDnX7x4KqNCwBqb'
b'I0"},"dt":"2021-01-01T00:00:00.000000+00:00"}-GAB0AAAAAAAAAAAAAA'
b'AAAAAAAAwEke0QhYPogZ-pKBMDhQj6fImswFB3HSZLVdYPvvQeBCE')
assert kevt == (
b'{"v":"KERI10JSON000107_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu'
b'k5aMtSrMtY","s":"3","t":"ixn","p":"Ef12IRHtb_gVo5ClaHHNV90b43adA'
b'0f8vRs3jeU-AstY","a":[{"i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULva'
b'U6Z-i0d8","s":"0","d":"EyRQ8Yz7vkua8qIqp89_cuYt71gdc9rpE4A6aj_qc'
b'71Q"}]}-AABAA7i4dJM3hMs9yZpUL01mzNbnai6Q6obbvChybnVNodoRiEZfrz9n'
b'rmMFtyJcYCUbg8rnfcJfDK9O8sZOeY5yuBg')
ser = Serder(raw=tevt)
assert ser.diger.qb64 == 'EyRQ8Yz7vkua8qIqp89_cuYt71gdc9rpE4A6aj_qc71Q'
tevt, kevt = issuer.revoke(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
assert tevt == (
b'{"v":"KERI10JSON00012c_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL'
b'vaU6Z-i0d8","s":"1","t":"brv","p":"ERXlSUThZejd2a3VhOHFJcXA4OV9j'
b'dVl0NzFnZGM5cnA","ra":{"i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGe'
b'LWHb9vSY","s":1,"d":"EpltHxeKueSR1a7e0_oSAhgO6U7VDnX7x4KqNCwBqbI'
b'0"},"dt":"2021-01-01T00:00:00.000000+00:00"}-GAB0AAAAAAAAAAAAAAA'
b'AAAAAABAESxOEc18GkapqfM70hpcLouPFYW4WY-h7LwNQKVsNMtE')
assert kevt == (
b'{"v":"KERI10JSON000107_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu'
b'k5aMtSrMtY","s":"4","t":"ixn","p":"Eke0QhYPogZ-pKBMDhQj6fImswFB3'
b'HSZLVdYPvvQeBCE","a":[{"i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULva'
b'U6Z-i0d8","s":"1","d":"Ew5r1LvoqsDUb16zlCnCgmmdOn3rpYLw1HpHtr6GM'
b'ZW8"}]}-AABAAfqZErFN0nEdL-FnQv75UMW_8XZH60qaXsIbTY2wzIf1FB5r9OjO'
b'M5rC0ULuGl4MK1kR3LDaP9maso9GUn-lGDQ')
ser = Serder(raw=tevt)
assert ser.diger.qb64 == 'Ew5r1LvoqsDUb16zlCnCgmmdOn3rpYLw1HpHtr6GMZW8'
with basing.openDB(name="bob") as db, keeping.openKS(
name="bob") as kpr, viring.openReg() as reg:
hab = buildHab(db, kpr)
# issuer, not allowed to issue backers
issuer = Issuer(hab=hab, name="bob", noBackers=True, reger=reg)
ser = Serder(raw=issuer.incept)
assert ser.pre == "Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyLehw"
assert ser.ked["t"] == "vcp"
assert ser.ked["c"] == ["NB"]
assert ser.ked["b"] == []
assert ser.ked["bt"] == "0"
ser = Serder(raw=issuer.ianchor)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "ixn"
seal = ser.ked["a"][0]
assert seal["i"] == "Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyLehw"
assert seal["s"] == "0"
assert seal["d"] == "ElYstqTocyQixLLz4zYCAs2unaFco_p6LqH0W01loIg4"
with pytest.raises(ValueError):
issuer.rotate(
adds=["EqoNZAX5Lu8RuHzwwyn5tCZTe-mDBq5zusCrRo5TDugs"])
with basing.openDB(name="bob") as db, keeping.openKS(
name="bob") as kpr, viring.openReg() as reg:
hab = buildHab(db, kpr)
issuer = Issuer(hab=hab, name="bob", noBackers=True, reger=reg)
tevt, kevt = issuer.issue(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
ser = Serder(raw=tevt)
assert ser.pre == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert ser.ked[
"ri"] == "Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyLehw"
assert ser.ked["t"] == "iss"
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "ixn"
seal = ser.ked["a"][0]
assert seal["i"] == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert seal["s"] == "0"
assert seal["d"] == 'Ewia5uvi4RAgr3rG_YlHSNPT3DxCa-2UDZ-TldDJPDWs'
tevt, kevt = issuer.revoke(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
ser = Serder(raw=tevt)
assert ser.pre == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert ser.ked["t"] == "rev"
assert ser.ked[
"ri"] == "Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyLehw"
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "ixn"
seal = ser.ked["a"][0]
assert seal["i"] == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert seal["s"] == "1"
# assert seal["d"] == 'EESqpWTkUklke73mGjf6TE-ojHEJLultMlQhKddfNx6w'
assert seal["d"] == 'E8JefMOVzgcRfzBeREhrpialRR5pQnvxThuzj9Q-E47I'
with basing.openDB(name="bob") as db, keeping.openKS(
name="bob") as kpr, viring.openReg() as reg:
hab = buildHab(db, kpr)
# issuer, allowed backers, initial set of backers
issuer = Issuer(hab=hab,
reger=reg,
baks=["BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU"])
ser = Serder(raw=issuer.incept)
# print(ser.pre)
assert ser.pre == "EaU321874i434f59ab7cMH6YlN52PJ395nrLS_6tLq6c"
assert ser.ked["t"] == "vcp"
assert ser.ked["b"] == ["BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU"]
assert ser.ked["bt"] == "1"
ser = Serder(raw=issuer.ianchor)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "ixn"
seal = ser.ked["a"][0]
assert seal["i"] == "EaU321874i434f59ab7cMH6YlN52PJ395nrLS_6tLq6c"
tevt, kevt = issuer.issue(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
ser = Serder(raw=tevt)
assert ser.pre == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert ser.ked["t"] == "bis"
seal = ser.ked["ra"]
assert seal["i"] == "EaU321874i434f59ab7cMH6YlN52PJ395nrLS_6tLq6c"
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "ixn"
seal = ser.ked["a"][0]
assert seal["i"] == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert seal["s"] == "0"
tevt, kevt = issuer.rotate(adds=[
"B9DfgIp33muOuCI0L8db_TldMJXv892UmW8yfpUuKzkw",
"BBC_BBLMeVwKFbfYSWU7aATS9itLSrGtIFQzCkfoKnjk"
])
vrtser = Serder(raw=tevt)
ser = Serder(raw=tevt)
assert ser.pre == "EaU321874i434f59ab7cMH6YlN52PJ395nrLS_6tLq6c"
assert ser.ked["t"] == "vrt"
assert ser.ked["ba"] == [
"B9DfgIp33muOuCI0L8db_TldMJXv892UmW8yfpUuKzkw",
"BBC_BBLMeVwKFbfYSWU7aATS9itLSrGtIFQzCkfoKnjk"
]
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "ixn"
seal = ser.ked["a"][0]
assert seal["i"] == "EaU321874i434f59ab7cMH6YlN52PJ395nrLS_6tLq6c"
assert seal["s"] == "1"
tevt, kevt = issuer.revoke(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
ser = Serder(raw=tevt)
assert ser.pre == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert ser.ked["t"] == "brv"
seal = ser.ked["ra"]
# ensure the ra seal digest matches the vrt event digest
assert seal["d"] == vrtser.diger.qb64
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "ixn"
seal = ser.ked["a"][0]
assert seal["i"] == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert seal["s"] == "1"
with basing.openDB(name="bob") as db, keeping.openKS(
name="bob") as kpr, viring.openReg() as reg:
hab = buildHab(db, kpr)
# issuer, no backers allowed, establishment events only
issuer = Issuer(hab=hab, reger=reg, noBackers=True, estOnly=True)
ser = Serder(raw=issuer.incept)
assert ser.pre == "Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyLehw"
assert ser.ked["t"] == "vcp"
assert ser.ked["c"] == ["NB"]
assert ser.ked["bt"] == "0"
ser = Serder(raw=issuer.ianchor)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "rot"
assert ser.ked["k"] == ["DKPE5eeJRzkRTMOoRGVd2m18o8fLqM2j9kaxLhV3x8AQ"]
assert ser.ked["n"] == "ELqHYQwWR0h2vP1_cxTsutU0wKJ_NrwBVKJCgPgWGgwc"
tevt, kevt = issuer.issue(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
ser = Serder(raw=tevt)
assert ser.pre == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert ser.ked["t"] == "iss"
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "rot"
tevt, kevt = issuer.revoke(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
ser = Serder(raw=tevt)
assert ser.pre == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert ser.ked["t"] == "rev"
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "rot"
with pytest.raises(ValueError):
issuer.rotate(
adds=["BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU"])
with basing.openDB(name="bob") as db, keeping.openKS(
name="bob") as kpr, viring.openReg() as reg:
hab = buildHab(db, kpr)
# issuer, backers allowed, initial backer, establishment events only
issuer = Issuer(hab=hab,
reger=reg,
baks=["BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU"],
estOnly=True)
ser = Serder(raw=issuer.incept)
assert ser.pre == "EaU321874i434f59ab7cMH6YlN52PJ395nrLS_6tLq6c"
assert ser.ked["b"] == ["BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU"]
assert ser.diger.qb64 == 'EevCI-l5dfYW63xg1bQ52ldLQa3li8FBo-znWxNEzv7E'
ser = Serder(raw=issuer.ianchor)
assert ser.ked["t"] == "rot"
tevt, kevt = issuer.rotate(
toad=3,
adds=[
"B9DfgIp33muOuCI0L8db_TldMJXv892UmW8yfpUuKzkw",
"BBC_BBLMeVwKFbfYSWU7aATS9itLSrGtIFQzCkfoKnjk"
])
vrtser = Serder(raw=tevt)
ser = Serder(raw=tevt)
assert ser.pre == "EaU321874i434f59ab7cMH6YlN52PJ395nrLS_6tLq6c"
assert ser.ked["t"] == "vrt"
assert issuer.backers == [
"BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU",
"B9DfgIp33muOuCI0L8db_TldMJXv892UmW8yfpUuKzkw",
"BBC_BBLMeVwKFbfYSWU7aATS9itLSrGtIFQzCkfoKnjk"
]
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "rot"
tevt, kevt = issuer.issue(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
ser = Serder(raw=tevt)
assert ser.pre == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert ser.ked["t"] == "bis"
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "rot"
assert vrtser.diger.qb64 == 'ECQbOOZdBxpw5RTH4VvPXDSH_o2uYdPWSoWolW5tobgA'
# rotate to no backers
tevt, kevt = issuer.rotate(
toad=2, cuts=["BwFbQvUaS4EirvZVPUav7R_KDHB8AKmSfXNpWnZU_YEU"])
ser = Serder(raw=tevt)
assert ser.pre == "EaU321874i434f59ab7cMH6YlN52PJ395nrLS_6tLq6c"
assert ser.ked["t"] == "vrt"
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "rot"
vrtser = Serder(raw=tevt)
tevt, kevt = issuer.revoke(
vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8")
ser = Serder(raw=tevt)
assert ser.pre == "EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8"
assert ser.ked["t"] == "brv"
ser = Serder(raw=kevt)
assert ser.pre == "EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY"
assert ser.ked["t"] == "rot"
assert vrtser.diger.qb64 == 'EnUD_KZu-dGpFSEWZOlFdQSydioYY78qIDPfzA7Fhr-Q'
""" 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'