def revoke( vcdig, dig, version=Version, kind=Serials.json, ): """ Returns serder of rev message event Utility function to create a VC revocation vent Parameters: vcdig is hash digest of vc content qb64 regk is regsitry identifier prefix qb64 dig is digest of previous event qb64 """ vs = Versify(version=version, kind=kind, size=0) isn = 1 ilk = Ilks.rev ked = dict( v=vs, i=vcdig, s="{:x}".format(isn), # hex string no leading zeros lowercase t=ilk, p=dig) return Serder(ked=ked) # return serialized ked
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 issue( vcdig, regk, version=Version, kind=Serials.json, ): """ Returns serder of iss message event Utility function to create a VC issuance event Parameters: vcdig is hash digest of vc content qb64 regk is regsitry identifier prefix qb64 """ vs = Versify(version=version, kind=kind, size=0) ked = dict( v=vs, # version string i=vcdig, # qb64 prefix s="{:x}".format(0), # hex string no leading zeros lowercase t=Ilks.iss, ri=regk) return Serder(ked=ked) # return serialized ked
def gen_nontransferable_serialized_aid(): with openDB() as bsr: # Inception: Non-transferable (ephemeral) case signer0 = Signer( transferable=False) # original signing keypair non transferable assert signer0.code == CryOneDex.Ed25519_Seed assert signer0.verfer.code == CryOneDex.Ed25519N keys0 = [signer0.verfer.qb64] serder = incept(keys=keys0) # default nxt is empty so abandoned # Derive AID from ked aid0 = Prefixer(ked=serder.ked, code=CryOneDex.Ed25519N) # update ked with pre serder.ked["pre"] = aid0.qb64 # Serialize ked0 tser0 = Serder(ked=serder.ked) # sign serialization skp0 = Signer() # original signing keypair transferable default tsig0 = skp0.sign(tser0.raw, index=0) # verify signature assert skp0.verfer.verify(tsig0.raw, tser0.raw) # not sure why this errors out when enabled; I guess kevers can't be used with nontransferable ids # kever = Kever(serder=tser0, sigers=[tsig0], baser=bsr) # no error # return base 64 serialization of signed aid return tsig0.qb64
def _derive_blake3_256(self, ked): """ Returns tuple (raw, code) of basic Ed25519 pre (qb64) as derived from inception key event dict ked """ ked = dict(ked) # make copy so don't clobber original ked ilk = ked["t"] if ilk == Ilks.vcp: labels = [key for key in ked if key not in self.VcpExcludes] else: raise DerivationError( "Invalid ilk = {} to derive pre.".format(ilk)) # put in dummy pre to get size correct ked["i"] = "{}".format(self.Dummy * Matter.Codes[MtrDex.Blake3_256].fs) serder = Serder(ked=ked) ked = serder.ked # use updated ked with valid vs element for l in labels: if l not in ked: raise DerivationError( "Missing element = {} from ked.".format(l)) dig = blake3.blake3(serder.raw).digest() return dig, MtrDex.Blake3_256
def kever(): # Setup inception key event dict salt = b'\x05\xaa\x8f-S\x9a\xe9\xfaU\x9c\x02\x9c\x9b\x08Hu' salter = Salter(raw=salt) # create current key sith = 1 # one signer # original signing keypair transferable default skp0 = salter.signer(path="A", temp=True) keys = [skp0.verfer.qb64] # create next key # next signing keypair transferable is default skp1 = salter.signer(path="N", temp=True) nxtkeys = [skp1.verfer.qb64] # compute nxt digest nexter = Nexter(keys=nxtkeys) nxt = nexter.qb64 assert nxt == "E_d8cX6vuQwmD5P62_b663OeaVCLbiBFsirRHJsHn9co" # transferable so nxt is not empty sn = 0 # inception event so 0 toad = 0 # no witnesses nsigs = 1 # one attached signature unspecified index ked0 = dict( v=Versify(kind=Serials.json, size=0), i="", # qual base 64 prefix s="{:x}".format(sn), # hex string no leading zeros lowercase t=Ilks.icp, kt="{:x}".format(sith), # hex string no leading zeros lowercase k=keys, # list of signing keys each qual Base64 n=nxt, # hash qual Base64 wt="{:x}".format(toad), # hex string no leading zeros lowercase w=[], # list of qual Base64 may be empty c=[], # list of config ordered mappings may be empty ) # Derive AID from ked aid0 = Prefixer(ked=ked0, code=MtrDex.Ed25519) assert aid0.code == MtrDex.Ed25519 assert aid0.qb64 == skp0.verfer.qb64 == 'DBQOqSaf6GqVAoPxb4UARrklS8kLYj3JqsR6b4AASDd4' # update ked with pre ked0["i"] = aid0.qb64 # Serialize ked0 tser0 = Serder(ked=ked0) # sign serialization tsig0 = skp0.sign(tser0.raw, index=0) # verify signature assert skp0.verfer.verify(tsig0.raw, tser0.raw) return Kever(serder=tser0, sigers=[tsig0])
def incept( pre, baks=None, cnfg=None, version=Version, kind=Serials.json, ): """ Returns serder of vcp message event Utility function to create a Registry inception event Parameters: pre is issuer identifier prefix qb64 cnfg is list of strings TraitDex of configuration traits baks is the initial list of backers prefixes for VCs in the Registry version is the API version kind is the event type """ vs = Versify(version=version, kind=kind, size=0) isn = 0 ilk = Ilks.vcp cnfg = cnfg if cnfg is not None else [] if TraitDex.NoBackers in cnfg and len(baks) > 0: raise ValueError("{} backers specified for NB vcp, 0 allowed".format( len(baks))) ked = dict( v=vs, # version string i="", # qb64 prefix ii=pre, s="{:x}".format(isn), # hex string no leading zeros lowercase t=ilk, c=cnfg, b=baks # list of qb64 may be empty ) prefixer = Prefixer(ked=ked) # Derive AID from ked and code ked["i"] = prefixer.qb64 # update pre element in ked with pre qb64 return Serder(ked=ked) # return serialized ked
def rotate( pre, regk, sn=1, baks=None, version=Version, kind=Serials.json, ): """ Returns serder of vrt message event Utility function to create a Registry rotation event Parameters: pre is identifier prefix qb64 regk is regsitry identifier prefix qb64 sn is int sequence number baks is new list of backers prefixes for VCs in the Registry """ if sn < 1: raise ValueError("Invalid sn = {} for vrt.".format(sn)) vs = Versify(version=version, kind=kind, size=0) ilk = Ilks.vrt ked = dict( v=vs, # version string i=regk, # qb64 prefix ii=pre, s="{:x}".format(sn), # hex string no leading zeros lowercase t=ilk, b=baks, # list of qb64 may be empty ) return Serder(ked=ked) # return serialized ked
def incept( pre, toad=None, baks=None, cnfg=None, version=Version, kind=Serials.json, code=None, ): """ Returns serder of vcp message event Utility function to create a Registry inception event Parameters: pre is issuer identifier prefix qb64 cnfg is list of strings TraitDex of configuration traits toad is int, or str hex of backer threshold baks is the initial list of backers prefixes for VCs in the Registry version is the API version kind is the event type code is default code for Prefixer """ vs = Versify(version=version, kind=kind, size=0) isn = 0 ilk = Ilks.vcp cnfg = cnfg if cnfg is not None else [] baks = baks if baks is not None else [] if TraitDex.NoBackers in cnfg and len(baks) > 0: raise ValueError("{} backers specified for NB vcp, 0 allowed".format( len(baks))) if len(oset(baks)) != len(baks): raise ValueError("Invalid baks = {}, has duplicates.".format(baks)) if isinstance(toad, str): toad = "{:x}".format(toad) elif toad is None: if not baks: toad = 0 else: # compute default f and m for len(baks) toad = ample(len(baks)) if baks: if toad < 1 or toad > len(baks): # out of bounds toad raise ValueError("Invalid toad = {} for baks = {}".format( toad, baks)) else: if toad != 0: # invalid toad raise ValueError("Invalid toad = {} for baks = {}".format( toad, baks)) ked = dict( v=vs, # version string i="", # qb64 prefix ii=pre, s="{:x}".format(isn), # hex string no leading zeros lowercase t=ilk, c=cnfg, bt="{:x}".format(toad), # hex string no leading zeros lowercase b=baks # list of qb64 may be empty ) prefixer = Prefixer(ked=ked, code=code, allows=[MtrDex.Blake3_256 ]) # Derive AID from ked and code ked["i"] = prefixer.qb64 # update pre element in ked with pre qb64 return Serder(ked=ked) # return serialized ked
def gen_serialized_aid(witnesses): # taken from https://github.com/decentralized-identity/keripy/blob/6b85417ce1188543493efff48f95ebabd12fb0c6/tests/core/test_eventing.py with openDB() as bsr: # Transferable case # Setup inception key event dict # create current key sith = 1 # one signer skp0 = Signer() # original signing keypair transferable default assert skp0.code == CryOneDex.Ed25519_Seed assert skp0.verfer.code == CryOneDex.Ed25519 keys = [skp0.verfer.qb64] # create next key nxtsith = 1 # one signer skp1 = Signer() # next signing keypair transferable is default assert skp1.code == CryOneDex.Ed25519_Seed assert skp1.verfer.code == CryOneDex.Ed25519 nxtkeys = [skp1.verfer.qb64] # compute nxt digest nexter = Nexter(sith=nxtsith, keys=nxtkeys) nxt = nexter.qb64 # transferable so nxt is not empty sn = 0 # inception event so 0 toad = len(witnesses) nsigs = 1 # one attached signature unspecified index ked0 = dict( vs=Versify(kind=Serials.json, size=0), pre="", # qual base 64 prefix sn="{:x}".format(sn), # hex string no leading zeros lowercase ilk=Ilks.icp, sith="{:x}".format(sith), # hex string no leading zeros lowercase keys=keys, # list of signing keys each qual Base64 nxt=nxt, # hash qual Base64 toad="{:x}".format(toad), # hex string no leading zeros lowercase # I think these are always necessary for direct mode wits=witnesses or [], # list of qual Base64 may be empty cnfg=[], # list of config ordered mappings may be empty ) # Derive AID from ked aid0 = Prefixer(ked=ked0, code=CryOneDex.Ed25519) assert aid0.code == CryOneDex.Ed25519 assert aid0.qb64 == skp0.verfer.qb64 # update ked with pre ked0["pre"] = aid0.qb64 # Serialize ked0 tser0 = Serder(ked=ked0) # sign serialization tsig0 = skp0.sign(tser0.raw, index=0) # verify signature assert skp0.verfer.verify(tsig0.raw, tser0.raw) kever = Kever(serder=tser0, sigers=[tsig0], baser=bsr) # no error # return base 64 serialization of signed aid # return tsig0.qb64 return tsig0, tser0, tsig0.qb64
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_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_issuer(): with dbing.openDB(name="bob") as db, keeping.openKS(name="bob") as kpr: hab = buildHab(db, kpr) # setup issuer with defaults for allowBackers, backers and estOnly issuer = Issuer(hab=hab, name="test") assert issuer.incept == (b'{"v":"KERI10JSON0000a9_","i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkD' b'GeLWHb9vSY","ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY",' b'"s":"0","t":"vcp","c":[],"bt":"0","b":[]}-eABEaKJ0FoLxO1TYmyuprg' b'uKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAAAAAAAAAAAAAAQEoDaZfC2yqtPwKJ' b'BrhAGzP20SOslMZ-eQ7hAbl3w4JP0') assert issuer.ianchor == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"1","t":"ixn","p":"Eg3wsIOW3RdCqhcG4xZ4uZhTA_qTE' b'24DoLeyjFBB8rks","a":["EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9' b'vSY","0","EvpB-_BWD7tOhLI0cDyEQbziBt6IMyQnkrh0booR4vhg"]}-AABAAw' b'3jupSvehfh-Ow0v_E3Er49HUvwQp0Qa0P9KYNdaf9ihtzZU0bJtrbIW1z6eMoR3B' b'52SDSxw9gfMmqlZRZfaBQ') # 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=["EqoNZAX5Lu8RuHzwwyn5tCZTe-mDBq5zusCrRo5TDugs"]) assert tevt == (b'{"v":"KERI10JSON0000d8_","i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkD' b'GeLWHb9vSY","p":"EvpB-_BWD7tOhLI0cDyEQbziBt6IMyQnkrh0booR4vhg","' b's":"1","t":"vrt","bt":"1","br":[],"ba":["EqoNZAX5Lu8RuHzwwyn5tCZ' b'Te-mDBq5zusCrRo5TDugs"]}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5' b'aMtSrMtY0AAAAAAAAAAAAAAAAAAAAAAgEoDJpf8xcmVXj3chkgVpVXvFgAaHyohm' b'v-Bkgjsf5yf4') assert kevt == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"2","t":"ixn","p":"EoDaZfC2yqtPwKJBrhAGzP20SOslM' b'Z-eQ7hAbl3w4JP0","a":["EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9' b'vSY","1","Ex1ZICku_jaiYzNIjfw1Q46T_srpyz7YJwpqS1xA9xuo"]}-AABAAG' b'XF1gyvCxtP3GaL-MenYOYSAqf0_BzzyRknY6mhCohXK5cIA0CrJfkPandYmDvGxo' b'63K0BPxCR3ey6PbjabkBg') ser = Serder(raw=tevt) assert ser.diger.qb64 == 'Ex1ZICku_jaiYzNIjfw1Q46T_srpyz7YJwpqS1xA9xuo' tevt, kevt = issuer.issue(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8") assert tevt == (b'{"v":"KERI10JSON000105_","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":"Ex1ZICku_jaiYzNIjfw1Q46T_srpyz7YJwpqS1xA9x' b'uo"}}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAA' b'AAAAAAAAAAAAwEJDkcdO3kE_gFLxSZA53HsEr9DK3gI1j6qEcwsZjzcZo') assert kevt == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"3","t":"ixn","p":"EoDJpf8xcmVXj3chkgVpVXvFgAaHy' b'ohmv-Bkgjsf5yf4","a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i' b'0d8","0","E_RmCtCYGKOUj9-r2HbZlTOTzrViYvlthhlhZFElyjzw"]}-AABAAN' b'bk_fVhHJVPZpwLA2Bmj9ZvD6T885Krwd8RJn2AGgQHVux7fsr-ZW4BXtFT7DW9Cj' b'jXkxP8gBSmIQt9gHPljBA') ser = Serder(raw=tevt) assert ser.diger.qb64 == 'E_RmCtCYGKOUj9-r2HbZlTOTzrViYvlthhlhZFElyjzw' tevt, kevt = issuer.revoke(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8") assert tevt == (b'{"v":"KERI10JSON000104_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z-i0d8","s":"1","t":"brv","p":"E_RmCtCYGKOUj9-r2HbZlTOTzrViY' b'vlthhlhZFElyjzw","ra":{"i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGe' b'LWHb9vSY","s":1,"d":"Ex1ZICku_jaiYzNIjfw1Q46T_srpyz7YJwpqS1xA9xu' b'o"}}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAAA' b'AAAAAAAAAABAEUQewfkI5B3VEU1w0BPpikSBdchw52PW4MrMcgizKVpc') assert kevt == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"4","t":"ixn","p":"EJDkcdO3kE_gFLxSZA53HsEr9DK3g' b'I1j6qEcwsZjzcZo","a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i' b'0d8","1","Ei1-r5vju2kh44KY09nd1KzeB1mq5_a33CwlYFs0tH3c"]}-AABAA3' b'3POBHT4hao0mAXiOAsji3ft-NLbGRAVJ1kh1VBu9eTddSO6mUYwZpQCDgQc2SwqS' b'C7VuegB_UVHbRtQcNiLCA') ser = Serder(raw=tevt) assert ser.diger.qb64 == 'Ei1-r5vju2kh44KY09nd1KzeB1mq5_a33CwlYFs0tH3c' # issuer, not allowed to issue backers issuer = Issuer(hab=hab, name="test", allowBackers=False) assert issuer.incept == (b'{"v":"KERI10JSON0000ad_","i":"Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEG' b'I0egFyLehw","ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY",' b'"s":"0","t":"vcp","c":["NB"],"bt":"0","b":[]}-eABEaKJ0FoLxO1TYmy' b'uprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAAAAAAAAAAAAABQEAUius1E3mN' b'za_tVygjmKAd5tIz9JVAP8PTLaEHwnx7w') assert issuer.ianchor == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"5","t":"ixn","p":"EUQewfkI5B3VEU1w0BPpikSBdchw5' b'2PW4MrMcgizKVpc","a":["Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyL' b'ehw","0","ElYstqTocyQixLLz4zYCAs2unaFco_p6LqH0W01loIg4"]}-AABAAN' b'Tokkv5aZ_MPLauMFsgzASyFs5qMb4-fo7HIofmpRa-XMfDS9vccchXXZb47774Be' b'YR6Nljg9m_ehk3b8NnTCg') with pytest.raises(ValueError): issuer.rotate(adds=["EqoNZAX5Lu8RuHzwwyn5tCZTe-mDBq5zusCrRo5TDugs"]) tevt, kevt = issuer.issue(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8") assert tevt == (b'{"v":"KERI10JSON000092_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z-i0d8","s":"0","t":"iss","ri":"Ezm53Qww2LTJ1yksEL06Wtt-5D23' b'QKdJEGI0egFyLehw"}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrM' b'tY0AAAAAAAAAAAAAAAAAAAAABgErPUCiDOsokTzqSx3ktSFx6P6bhfWLps3PbvbY' b'ZIdjMw') assert kevt == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"6","t":"ixn","p":"EAUius1E3mNza_tVygjmKAd5tIz9J' b'VAP8PTLaEHwnx7w","a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i' b'0d8","0","EXTVuADWAm9XOG6XKMyKRs8FO2dYPFo12rinap96BUjU"]}-AABAAf' b'tQ5Ccj6aiZCVArCRlcBPhUKnO0m5q75dRgs316rxbsbEdXC3lB2AC4TWCMB0EVv5' b'rzGRu6Gnw6134VpkkrPCw') tevt, kevt = issuer.revoke(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8") assert tevt == (b'{"v":"KERI10JSON000091_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z-i0d8","s":"1","t":"rev","p":"EXTVuADWAm9XOG6XKMyKRs8FO2dYP' b'Fo12rinap96BUjU"}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMt' b'Y0AAAAAAAAAAAAAAAAAAAAABwEpzwTULkTXErmB12S-vR4Ysi22kFCtqaV9_uoP2' b'zBWNE') assert kevt == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"7","t":"ixn","p":"ErPUCiDOsokTzqSx3ktSFx6P6bhfW' b'Lps3PbvbYZIdjMw","a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i' b'0d8","1","EgaGSsEExjY_19HbFsfWjtrj_nmtYmDU23qaod0KSr2o"]}-AABAAM' b'w_8vSj-GBc1dMDTeNZg1sRhqOOBIROUDXAEvY5nICWhgp1RP-XYOYaVlJpLOLN6M' b'nm6JU_z3rvsq475D4WsBQ') # issuer, allowed backers, initial set of backers issuer = Issuer(hab=hab, name="test", baks=["EqoNZAX5Lu8RuHzwwyn5tCZTe-mDBq5zusCrRo5TDugs"]) assert issuer.incept == (b'{"v":"KERI10JSON0000d7_","i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78' b'p90WN3sG3I","ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY",' b'"s":"0","t":"vcp","c":[],"bt":"1","b":["EqoNZAX5Lu8RuHzwwyn5tCZT' b'e-mDBq5zusCrRo5TDugs"]}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5a' b'MtSrMtY0AAAAAAAAAAAAAAAAAAAAACAERI1IUUGtVVKDEqLw59qPJzIIwRFVU1sN' b'n__B8Z6GgXk') assert issuer.ianchor == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"8","t":"ixn","p":"EpzwTULkTXErmB12S-vR4Ysi22kFC' b'tqaV9_uoP2zBWNE","a":["EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78p90WN3s' b'G3I","0","EMMt2bfrg5ACOrCLQRuU21qWMBxDPwzIhOANvHKAGJWc"]}-AABAAZ' b'Zo51JRK2aU0zppx12N584195BP-UjAtCly9_Z1dfuoUQz5yV4m_NJSt-w86t9VsH' b'UMDtI20EbRtenypM3NyDw') tevt, kevt = issuer.issue(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8") assert tevt == (b'{"v":"KERI10JSON000105_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z-i0d8","ii":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78p90WN3sG3I",' b'"s":"0","t":"bis","ra":{"i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78p' b'90WN3sG3I","s":0,"d":"EMMt2bfrg5ACOrCLQRuU21qWMBxDPwzIhOANvHKAGJ' b'Wc"}}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAA' b'AAAAAAAAAAACQETPkpmuLwJY4SXHPw0kjrKG5CYTTkf-OMxTgDnBFx7_k') assert kevt == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"9","t":"ixn","p":"ERI1IUUGtVVKDEqLw59qPJzIIwRFV' b'U1sNn__B8Z6GgXk","a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i' b'0d8","0","Eu9JBjmUh10w5FLNORAdHuICsQ0VJ7WLoxvAA56fQr0w"]}-AABAAY' b'Dm3lQah_ZQhX9wJmgHY6eWTtFozD2HLA004TIm-w2LIdqS-tw6pHSNgYQKBvNt0T' b'4t2Y1pL0rsDBTGAEaw_Cg') tevt, kevt = issuer.rotate(adds=["EtEBUSHpJDMfzHdDt3QCtrA-iVlP-0DT03AdqeeDa7vs", "ERVZTggTUOPmLcWBESrxcI-VsB48FerF6sz2boziikcY"]) vrtser = Serder(raw=tevt) assert tevt == (b'{"v":"KERI10JSON000107_","i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78' b'p90WN3sG3I","p":"EMMt2bfrg5ACOrCLQRuU21qWMBxDPwzIhOANvHKAGJWc","' b's":"1","t":"vrt","bt":"3","br":[],"ba":["EtEBUSHpJDMfzHdDt3QCtrA' b'-iVlP-0DT03AdqeeDa7vs","ERVZTggTUOPmLcWBESrxcI-VsB48FerF6sz2bozi' b'ikcY"]}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAA' b'AAAAAAAAAAAAACgE58EtRRxJROE7qmMnHV6fnP8FeFTBkX8eMlZbMNDFY6w') assert kevt == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"a","t":"ixn","p":"ETPkpmuLwJY4SXHPw0kjrKG5CYTTk' b'f-OMxTgDnBFx7_k","a":["EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78p90WN3s' b'G3I","1","EKwtenOwTRhQCzIiBWTPWPCWB6PQ9sF0pnPrsCS_YhuA"]}-AABAAp' b'fZ6LoLMi4L_nabHRQZgW59NT3xt6IYrZ5D4lc7gUoalP-VraZ-TIThFSJSKsZER7' b'W0Ev1FD6Zn5pb1JTAgKAg') tevt, kevt = issuer.revoke(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i0d8") assert tevt == (b'{"v":"KERI10JSON000104_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z-i0d8","s":"1","t":"brv","p":"Eu9JBjmUh10w5FLNORAdHuICsQ0VJ' b'7WLoxvAA56fQr0w","ra":{"i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78p9' b'0WN3sG3I","s":1,"d":"EKwtenOwTRhQCzIiBWTPWPCWB6PQ9sF0pnPrsCS_Yhu' b'A"}}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAAA' b'AAAAAAAAAACwE71WIaYxok1t0xzC9OYyX1TYjsKG1o9LCnj_o_gsGH4M') assert kevt == (b'{"v":"KERI10JSON0000f9_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"b","t":"ixn","p":"E58EtRRxJROE7qmMnHV6fnP8FeFTB' b'kX8eMlZbMNDFY6w","a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z-i' b'0d8","1","E9lcc71zkJXoc5E7qcCKOjZrhsNqqenXhTJMShSVek04"]}-AABAAq' b'1GKbPLjSoNJLTiAbSP6EM0j2d3IOzw9LTbGGrXw3GVT6P6P-S9y8kPdmIXszP5PB' b'CDJehu8GsgvxLR2f_alCg') # ensure the ra seal digest matches the vrt event digest assert vrtser.diger.qb64 == 'EKwtenOwTRhQCzIiBWTPWPCWB6PQ9sF0pnPrsCS_YhuA' # issuer, no backers allowed, establishment events only issuer = Issuer(hab=hab, name="test", allowBackers=False, estOnly=True) assert issuer.incept == (b'{"v":"KERI10JSON0000ad_","i":"Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEG' b'I0egFyLehw","ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY",' b'"s":"0","t":"vcp","c":["NB"],"bt":"0","b":[]}-eABEaKJ0FoLxO1TYmy' b'uprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAAAAAAAAAAAAADAEE4ISn-pS8v' b'oter-KsYyHlMb8pxiG_Uazvjw-cNRlm8s') assert issuer.ianchor == (b'{"v":"KERI10JSON000183_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"c","t":"rot","p":"E71WIaYxok1t0xzC9OYyX1TYjsKG1' b'o9LCnj_o_gsGH4M","kt":"1","k":["DKPE5eeJRzkRTMOoRGVd2m18o8fLqM2j' b'9kaxLhV3x8AQ"],"n":"ELqHYQwWR0h2vP1_cxTsutU0wKJ_NrwBVKJCgPgWGgwc' b'","bt":"0","br":[],"ba":[],"a":["Ezm53Qww2LTJ1yksEL06Wtt-5D23QKd' b'JEGI0egFyLehw","0","ElYstqTocyQixLLz4zYCAs2unaFco_p6LqH0W01loIg4' b'"]}-AABAATpTzNLJAV5CLD8znuTh2w73ZwqlsrOJIXa-XK2uY7QhnFHAD16yoDma' b'BhdNFEKhFhqFLWnwUVe8myYkVnh8YCQ') tevt, kevt = issuer.issue(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z") assert tevt == (b'{"v":"KERI10JSON00008d_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z","s":"0","t":"iss","ri":"Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJE' b'GI0egFyLehw"}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AA' b'AAAAAAAAAAAAAAAAAAADQEDrLbf5h3GE06g3v-Ox2fFoolQyrvKW_sTrIxtQxuZAU') assert kevt == (b'{"v":"KERI10JSON00017e_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"d","t":"rot","p":"EE4ISn-pS8voter-KsYyHlMb8pxiG' b'_Uazvjw-cNRlm8s","kt":"1","k":["DSuhyBcPZEZLK-fcw5tzHn2N46wRCG_Z' b'OoeKtWTOunRA"],"n":"EPYuj8mq_PYYsoBKkzX1kxSPGYBWaIya3slgCOyOtlqU' b'","bt":"0","br":[],"ba":[],"a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH' b'3ULvaU6Z","0","EnZpkCQXGps7J8hO5BbFrVG7KSaEd1J3u-mAL8-E-JoY"]}-A' b'ABAANcQvSou7f1vUanuNPB0QWSsv0_NUupscqNl4sY7HijmH0eUDxiz9ryWa-UdQ' b'nzHLI-gY7ITVB5JgXJMtxKkxBw') ser = Serder(raw=tevt) assert ser.diger.qb64 == 'EnZpkCQXGps7J8hO5BbFrVG7KSaEd1J3u-mAL8-E-JoY' tevt, kevt = issuer.revoke(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z") assert tevt == (b'{"v":"KERI10JSON00008c_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z","s":"1","t":"rev","p":"EnZpkCQXGps7J8hO5BbFrVG7KSaEd1J3u-' b'mAL8-E-JoY"}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAA' b'AAAAAAAAAAAAAAAAAADgE9-23oNfUrdBvXi-x89tgF8cO6mLCW5rGdQZ-C6agszE') assert kevt == (b'{"v":"KERI10JSON00017e_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"e","t":"rot","p":"EDrLbf5h3GE06g3v-Ox2fFoolQyrv' b'KW_sTrIxtQxuZAU","kt":"1","k":["DVcuJOOJF1IE8svqEtrSuyQjGTd2HhfA' b'kt9y2QkUtFJI"],"n":"E-dapdcC6XR1KWmWDsNl4J_OxcGxNZw1Xd95JH5a34fI' b'","bt":"0","br":[],"ba":[],"a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH' b'3ULvaU6Z","1","EVFiCQMPCoXtMpK-yoLWIVfwifQkLSH1Dj4RtzyOCVuo"]}-A' b'ABAArUM8moanrzuFmxW48V4XE06zRkvnRHmtQtxt-q8ZqDoZeU0fTvJu_qQC0Qrb' b'KVfVBNQ8ajphcJDdRP82d5aWAQ') with pytest.raises(ValueError): issuer.rotate(adds=["EqoNZAX5Lu8RuHzwwyn5tCZTe-mDBq5zusCrRo5TDugs"]) # issuer, backers allowed, initial backer, establishment events only issuer = Issuer(hab=hab, name="test", baks=["EqoNZAX5Lu8RuHzwwyn5tCZTe-mDBq5zusCrRo5TDugs"], estOnly=True) assert issuer.incept == (b'{"v":"KERI10JSON0000d7_","i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78' b'p90WN3sG3I","ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY",' b'"s":"0","t":"vcp","c":[],"bt":"1","b":["EqoNZAX5Lu8RuHzwwyn5tCZT' b'e-mDBq5zusCrRo5TDugs"]}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5a' b'MtSrMtY0AAAAAAAAAAAAAAAAAAAAADwEvDmjSZQmSLqNzTJDq9rdDd7X-ffGPt6z' b'uD2n51EFRLw') assert issuer.ianchor == (b'{"v":"KERI10JSON000183_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"f","t":"rot","p":"E9-23oNfUrdBvXi-x89tgF8cO6mLC' b'W5rGdQZ-C6agszE","kt":"1","k":["DT1iAhBWCkvChxNWsby2J0pJyxBIxbAt' b'bLA0Ljx-Grh8"],"n":"EDs-qIrh79lTtoIz4K9q_vu7-avDc79YkNCfK49HpwQg' b'","bt":"0","br":[],"ba":[],"a":["EZRowynuVBviCH0ZfUx24mkMWn-jGRB' b'm78p90WN3sG3I","0","EMMt2bfrg5ACOrCLQRuU21qWMBxDPwzIhOANvHKAGJWc' b'"]}-AABAAmTxyOx_38hK74779sN9vPXxcRHV49li9vt0RvAKlfuCBKG2hwWyy0P-' b'9tFF_2VMvAfrWChEsjWPm9lsPeWIwBw') ser = Serder(raw=issuer.incept) assert ser.diger.qb64 == 'EMMt2bfrg5ACOrCLQRuU21qWMBxDPwzIhOANvHKAGJWc' tevt, kevt = issuer.rotate(adds=["EtEBUSHpJDMfzHdDt3QCtrA-iVlP-0DT03AdqeeDa7vs", "ERVZTggTUOPmLcWBESrxcI-VsB48FerF6sz2boziikcY"]) vrtser = Serder(raw=tevt) assert tevt == (b'{"v":"KERI10JSON000107_","i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78' b'p90WN3sG3I","p":"EMMt2bfrg5ACOrCLQRuU21qWMBxDPwzIhOANvHKAGJWc","' b's":"1","t":"vrt","bt":"3","br":[],"ba":["EtEBUSHpJDMfzHdDt3QCtrA' b'-iVlP-0DT03AdqeeDa7vs","ERVZTggTUOPmLcWBESrxcI-VsB48FerF6sz2bozi' b'ikcY"]}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAA' b'AAAAAAAAAAAAAEAEKKopp_VUWhCpagBvKuWMfuSwRe5gcmh4LO4kJB1rItE') assert kevt == (b'{"v":"KERI10JSON000184_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"10","t":"rot","p":"EvDmjSZQmSLqNzTJDq9rdDd7X-ff' b'GPt6zuD2n51EFRLw","kt":"1","k":["D4JDgo3WNSUpt-NG14Ni31_GCmrU0r3' b'8yo7kgDuyGkQM"],"n":"EvbWtNrsw7dfaWRiDMXcF6P90KM1gdfPhg7FWTIwD39' b'c","bt":"0","br":[],"ba":[],"a":["EZRowynuVBviCH0ZfUx24mkMWn-jGR' b'Bm78p90WN3sG3I","1","EKwtenOwTRhQCzIiBWTPWPCWB6PQ9sF0pnPrsCS_Yhu' b'A"]}-AABAAonXgmX0PD7e94oqW9yhkm9ydZjwivpNWEPPLIQkOzzvfqGlI79io4x' b'FF8-8K8UWok5dfb9j9fhrqR-e9p23bBw') tevt, kevt = issuer.issue(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z") assert tevt == (b'{"v":"KERI10JSON000100_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z","ii":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78p90WN3sG3I","s":"' b'0","t":"bis","ra":{"i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78p90WN3' b'sG3I","s":1,"d":"EKwtenOwTRhQCzIiBWTPWPCWB6PQ9sF0pnPrsCS_YhuA"}}' b'-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAAAAAAA' b'AAAAAAEQEoRSZSkIHCJjvW9KDO26tFW4VQkhZXVXuYm8OrfxUfh8') assert kevt == (b'{"v":"KERI10JSON00017f_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"11","t":"rot","p":"EKKopp_VUWhCpagBvKuWMfuSwRe5' b'gcmh4LO4kJB1rItE","kt":"1","k":["DVjWcaNX2gCkHOjk6rkmqPBCxkRCqwI' b'J-3OjdYmMwxf4"],"n":"EpusdZwamtwTwqtwOenXWKQ0FpX9yWnq0XHlOEgQmss' b'0","bt":"0","br":[],"ba":[],"a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZ' b'H3ULvaU6Z","0","EXklP9Aj6ZXeC4Ox-TFExo_pk5u-ocMacfq82evq0rVo"]}-' b'AABAAIcH6E9px8Tcz2kbJd8vmOvcvnb4Pe2QYL5Y6hkbIPsymR7awzvThHx8qkXB' b'G51sJIgUExNoyaAOnkp20psoeAQ') assert vrtser.diger.qb64 == 'EKwtenOwTRhQCzIiBWTPWPCWB6PQ9sF0pnPrsCS_YhuA' # rotate to no backers tevt, kevt = issuer.rotate(cuts=["EqoNZAX5Lu8RuHzwwyn5tCZTe-mDBq5zusCrRo5TDugs"]) assert tevt == (b'{"v":"KERI10JSON0000d8_","i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78' b'p90WN3sG3I","p":"EKwtenOwTRhQCzIiBWTPWPCWB6PQ9sF0pnPrsCS_YhuA","' b's":"2","t":"vrt","bt":"0","br":["EqoNZAX5Lu8RuHzwwyn5tCZTe-mDBq5' b'zusCrRo5TDugs"],"ba":[]}-eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5' b'aMtSrMtY0AAAAAAAAAAAAAAAAAAAAAEgEX0HvF8uLvwvQcbnMq1JaMqoPSiJ0RqZ' b'dhyM7gWfYS4g') assert kevt == (b'{"v":"KERI10JSON000184_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"12","t":"rot","p":"EoRSZSkIHCJjvW9KDO26tFW4VQkh' b'ZXVXuYm8OrfxUfh8","kt":"1","k":["DT1nEDepd6CSAMCE7NY_jlLdG6_mKUl' b'KS_mW-2HJY1hg"],"n":"ER0SqaQnpyIxxtL_UFvE8wpooAjKNiq36zhpwwbfuZo' b'w","bt":"0","br":[],"ba":[],"a":["EZRowynuVBviCH0ZfUx24mkMWn-jGR' b'Bm78p90WN3sG3I","2","ETtfhi2rdeM4yqMuBb1fLXMjZlG_n_I3N00JMfaIBUn' b's"]}-AABAARKOiQnD9BSRUqFg63Q3lUjyMAJ-cZiVVCHO4POe0iEAXdIRp4Ylzdt' b'PJzVTRpuJC2YecICPXkEehBbnQhXwHBg') vrtser = Serder(raw=tevt) tevt, kevt = issuer.revoke(vcdig="EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3ULvaU6Z") assert tevt == (b'{"v":"KERI10JSON0000ff_","i":"EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZH3UL' b'vaU6Z","s":"1","t":"brv","p":"EXklP9Aj6ZXeC4Ox-TFExo_pk5u-ocMacf' b'q82evq0rVo","ra":{"i":"EZRowynuVBviCH0ZfUx24mkMWn-jGRBm78p90WN3s' b'G3I","s":2,"d":"ETtfhi2rdeM4yqMuBb1fLXMjZlG_n_I3N00JMfaIBUns"}}-' b'eABEaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY0AAAAAAAAAAAAAAAA' b'AAAAAEwE97hmLY8BYtFhPxzmN0ZweLfeU_hU7RVgD8e6BvZA92U') assert kevt == (b'{"v":"KERI10JSON00017f_","i":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wu' b'k5aMtSrMtY","s":"13","t":"rot","p":"EX0HvF8uLvwvQcbnMq1JaMqoPSiJ' b'0RqZdhyM7gWfYS4g","kt":"1","k":["DiDeeYNZLsQncGJZ6DR54gAy-HySmzz' b'gl61KFMZ4iR0U"],"n":"E9IUWbvzBjn0ubo_lpKsjCb6ajDS1V23iLHrJFHZ2rV' b'k","bt":"0","br":[],"ba":[],"a":["EJJR2nmwyYAfSVPzhzS6b5CMZAoTNZ' b'H3ULvaU6Z","1","EI_uyS9EE7t3s_TD5PpqqpLXb3PfPt8K0J7VnNLF50-o"]}-' b'AABAAdKHkxbgf1PgVw8dfg4taD8igLLzGlZkifbMcVL3cLOciDn6Ovi39Xsk36Y8' b'a3xHh8WJkIfOaONYscc_bz-jJBw') assert vrtser.diger.qb64 == 'ETtfhi2rdeM4yqMuBb1fLXMjZlG_n_I3N00JMfaIBUns' """ 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 rotate( regk, dig, sn=1, toad=None, baks=None, cuts=None, adds=None, version=Version, kind=Serials.json, ): """ Returns serder of vrt message event Utility function to create a Registry rotation event Parameters: pre is identifier prefix qb64 regk is regsitry identifier prefix qb64 sn is int sequence number toad is int or str hex of witness threshold baks is list of prior backers prefixes qb64 cuts is list of witness prefixes to cut qb64 adds is list of witness prefixes to add qb64 """ if sn < 1: raise ValueError("Invalid sn = {} for vrt.".format(sn)) vs = Versify(version=version, kind=kind, size=0) ilk = Ilks.vrt baks = baks if baks is not None else [] bakset = oset(baks) if len(bakset) != len(baks): raise ValueError("Invalid baks = {}, has duplicates.".format(baks)) cuts = cuts if cuts is not None else [] cutset = oset(cuts) if len(cutset) != len(cuts): raise ValueError("Invalid cuts = {}, has duplicates.".format(cuts)) if (bakset & cutset) != cutset: # some cuts not in wits raise ValueError( "Invalid cuts = {}, not all members in baks.".format(cuts)) adds = adds if adds is not None else [] addset = oset(adds) if len(addset) != len(adds): raise ValueError("Invalid adds = {}, has duplicates.".format(adds)) if cutset & addset: # non empty intersection raise ValueError("Intersecting cuts = {} and adds = {}.".format( cuts, adds)) if bakset & addset: # non empty intersection raise ValueError("Intersecting baks = {} and adds = {}.".format( baks, adds)) newbakset = (bakset - cutset) | addset if len(newbakset) != (len(baks) - len(cuts) + len(adds)): # redundant? raise ValueError( "Invalid member combination among baks = {}, cuts ={}, " "and adds = {}.".format(baks, cuts, adds)) if isinstance(toad, str): toad = "{:x}".format(toad) elif toad is None: if not newbakset: toad = 0 else: # compute default f and m for len(newbakset) toad = ample(len(newbakset)) if newbakset: if toad < 1 or toad > len(newbakset): # out of bounds toad raise ValueError("Invalid toad = {} for resultant wits = {}" "".format(toad, list(newbakset))) else: if toad != 0: # invalid toad raise ValueError("Invalid toad = {} for resultant wits = {}" "".format(toad, list(newbakset))) ked = dict( v=vs, # version string i=regk, # qb64 prefix p=dig, s="{:x}".format(sn), # hex string no leading zeros lowercase t=ilk, bt="{:x}".format(toad), # hex string no leading zeros lowercase br=cuts, # list of qb64 may be empty ba=adds, # list of qb64 may be empty ) return Serder(ked=ked) # return serialized ked
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_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'