def test_build_proof():
sidSalt = coring.Salter(raw=b'0123456789abcdef').qb64
with basing.openDB(name="sid") as sigDB, \
keeping.openKS(name="sid") as sigKS:
sigHab = habbing.Habitat(ks=sigKS, db=sigDB, salt=sidSalt, icount=3, ncount=3, temp=True)
sed = dict()
sed["$id"] = ""
sed["$schema"] = "http://json-schema.org/draft-07/schema#"
sed.update(dict(
type="object",
properties=dict(
id=dict(
type="string"
),
lei=dict(
type="string"
)
)
))
schemer = scheming.Schemer(sed=sed, typ=scheming.JSONSchema(), code=coring.MtrDex.Blake3_256)
credSubject = dict(
id="did:keri:Efaavv0oadfghasdfn443fhbyyr4v", # this needs to be generated from a KEL
lei="254900OPPU84GM83MG36",
issuanceDate="2021-06-27T21:26:21.233257+00:00",
)
cache = CacheResolver()
cache.add(schemer.said, schemer.raw)
creder = credential(issuer=sigHab.pre,
schema=schemer.said,
subject=credSubject,
typ=JSONSchema(resolver=cache))
sigHab.rotate()
sigHab.rotate()
sigHab.rotate()
sigHab.rotate()
prefixer = coring.Prefixer(qb64=sigHab.kever.prefixer.qb64)
seqner = coring.Seqner(sn=sigHab.kever.lastEst.s)
diger = coring.Diger(qb64=sigHab.kever.lastEst.d)
sigers = sigHab.mgr.sign(ser=creder.raw, verfers=sigHab.kever.verfers, indexed=True)
proof = buildProof(prefixer, seqner, diger, sigers)
assert proof == (
b'-FABEiRjCnZfca8gUZqecerjGpjkiY8dIkGudP6GfapWi5MU0AAAAAAAAAAAAAAAAAAAAABAECc96yX1sYswnD6LXEcoNuJ0e'
b'hi8gkFMEGedqURhXMBU-AADAAGcSUhma16SY3MiKU7n6mK3JzWS2oAiBRB-jeycIDrQ2Z-36QHrMorzRAO9Iw7FvIKrneaLZP'
b'whz6DFFiXM4oBgAB1g2CudOfOFd9BqesyAIlCDRAkxAQynrED4_ot1MkhKwjmK71XUx1Xer25iWtHMa9sny07AsTO-KE3vu9e'
b'qTPDQAClDQMXWg3I8qeVEjA6JA9xBW2uESMtMzNVQ8lH31UCizqYVjXort--QEJTsfIt_b0Qq1JOCtaj7Y6U-DWHoulBA')
prefixer, seqner, diger, isigers = parseProof(proof)
assert prefixer.qb64 == sigHab.pre
assert diger.qb64 == sigHab.kever.lastEst.d
assert seqner.sn == 4
assert len(isigers) == 3
def test_credential():
d = dict(i="",
issuanceDate="2021-06-27T21:26:21.233257+00:00",
type=[
"VerifiablePresentation",
"LegalEntityEngagementContextRolevLEICredential"
],
personLegalName="John Doe",
engagementContextRole="Project Manager",
credentialStatus="EymRy7xMwsxUelUauaXtMxTfPAMPAI6FkekwlOjkggt",
LEI="254900OPPU84GM83MG36")
# test source chaining with labeled edge
s = [
dict(qualifiedvLEIIssuervLEICredential=
"EGtyThM1rLBSMZ_ozM1uAnFvSfC0N1jaQ42aKU5sHYTGFD")
]
saider = scheming.Saider(sed=d,
code=coring.MtrDex.Blake3_256,
idder=scheming.Ids.i)
assert saider.qb64 == "ESRs5eTGniYdVFwPtHYtZ4vMxrgJOaK_5HH9wEmT6rq8"
d["i"] = saider.qb64
cred = credential(schema="EZllThM1rLBSMZ_ozM1uAnFvSfC0N1jaQ42aKU5sCZ5Q",
issuer="EYNHFK056fqNSG_MDE7d_Eqk0bazefvd4eeQLMPPNBnM",
subject=d,
source=s)
assert cred.raw == (
b'{"v":"KERI10JSON000273_","i":"EVbiCCuRv-joKhOUCYUQsdkgsExGjQo7bRoZT6HdcuWk",'
b'"x":"EZllThM1rLBSMZ_ozM1uAnFvSfC0N1jaQ42aKU5sCZ5Q","ti":"EYNHFK056fqNSG_MDE7d_Eqk0bazefvd4eeQLMPPNBnM",'
b'"d":{"i":"ESRs5eTGniYdVFwPtHYtZ4vMxrgJOaK_5HH9wEmT6rq8","issuanceDate":"2021-06-27T21:26:21.233257+00:00",'
b'"type":["VerifiablePresentation","LegalEntityEngagementContextRolevLEICredential"],"personLegalName":"John '
b'Doe","engagementContextRole":"Project Manager",'
b'"credentialStatus":"EymRy7xMwsxUelUauaXtMxTfPAMPAI6FkekwlOjkggt","LEI":"254900OPPU84GM83MG36"},'
b'"s":[{"qualifiedvLEIIssuervLEICredential":"EGtyThM1rLBSMZ_ozM1uAnFvSfC0N1jaQ42aKU5sHYTGFD"}]}'
)
def test_issuing():
sidSalt = coring.Salter(raw=b'0123456789abcdef').qb64
with basing.openDB(name="sid") as sidDB, \
keeping.openKS(name="sid") as sidKS, \
basing.openDB(name="red") as redDB, \
openPocket(name="red") as redPDB:
limit = 1.0
tock = 1.0
doist = doing.Doist(limit=limit, tock=tock)
sidHab = habbing.Habitat(ks=sidKS, db=sidDB, salt=sidSalt, temp=True)
sidPre = sidHab.pre
assert sidPre == "E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E"
sidIcpMsg = sidHab.makeOwnInception()
redKvy = eventing.Kevery(db=redDB)
parsing.Parser().parse(ims=bytearray(sidIcpMsg), kvy=redKvy)
assert redKvy.kevers[sidPre].sn == 0 # accepted event
sed = dict()
sed["$id"] = ""
sed["$schema"] = "http://json-schema.org/draft-07/schema#"
sed.update(
dict(type="object",
properties=dict(id=dict(type="string"),
lei=dict(type="string"))))
schemer = scheming.Schemer(sed=sed, code=coring.MtrDex.Blake3_256)
assert schemer.said == "EeCCZi1R5xHUlhsyQNm_7NrUQTEKZH5P9vBomnc9AihY"
cache = scheming.CacheResolver()
cache.add(schemer.said, schemer.raw)
jsonSchema = JSONSchema(resolver=cache)
# Create Red's wallet and Issue Handler for receiving the credential
redWallet = Wallet(hab=sidHab, db=redPDB)
redIssueHandler = IssueHandler(wallet=redWallet, typ=jsonSchema)
redExc = exchanging.Exchanger(hab=sidHab,
tymth=doist.tymen(),
handlers=[redIssueHandler])
# Build the credential subject and then the Credentialer for the full credential
credSubject = dict(
id=
"did:keri:Efaavv0oadfghasdfn443fhbyyr4v", # this needs to be generated from a KEL
lei="254900OPPU84GM83MG36",
issuanceDate="2021-06-27T21:26:21.233257+00:00",
)
creder = credential(issuer=sidHab.pre,
schema=schemer.said,
subject=credSubject,
typ=jsonSchema)
assert creder.said == "EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM"
msg = sidHab.endorse(serder=creder)
assert msg == (
b'{"v":"KERI10JSON000136_","i":"EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM",'
b'"x":"EeCCZi1R5xHUlhsyQNm_7NrUQTEKZH5P9vBomnc9AihY","ti":"E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E",'
b'"d":{"id":"did:keri:Efaavv0oadfghasdfn443fhbyyr4v","lei":"254900OPPU84GM83MG36",'
b'"issuanceDate":"2021-06-27T21:26:21.233257+00:00"}}-VA0-FABE4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE'
b'-YfcI9E0AAAAAAAAAAAAAAAAAAAAAAAElHzHwX3V6itsD2Ksg_CNBbUNTBYzLYw-AxDNI7_ZmaI'
b'-AABAA0pXbQllgzXr88IczAnsPrdhgFKs9wNQvfSfzyrtcvbTwq-U1DmBluAklntCqH1AbBL6TWLZIDGi83BHLWJ82CA'
)
# Create the issue credential payload
pl = dict(vc=[envelope(msg, typ=jsonSchema)])
# Create the `exn` message for issue credential
sidExcSrdr = exchanging.exchange(route="/credential/issue", payload=pl)
excMsg = sidHab.sanction(sidExcSrdr)
# Parse the exn issue credential message on Red's side
parsing.Parser().parse(ims=bytearray(excMsg), kvy=redKvy, exc=redExc)
doist.do(doers=[redExc])
assert doist.tyme == limit
ser = (
b'{"v":"KERI10JSON000136_","i":"EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM",'
b'"x":"EeCCZi1R5xHUlhsyQNm_7NrUQTEKZH5P9vBomnc9AihY","ti":"E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E",'
b'"d":{"id":"did:keri:Efaavv0oadfghasdfn443fhbyyr4v","lei":"254900OPPU84GM83MG36",'
b'"issuanceDate":"2021-06-27T21:26:21.233257+00:00"}}')
sig0 = (
b'AA0pXbQllgzXr88IczAnsPrdhgFKs9wNQvfSfzyrtcvbTwq-U1DmBluAklntCqH1AbBL6TWLZIDGi83BHLWJ82CA'
)
# verify we can load serialized VC by SAID
key = creder.said.encode("utf-8")
assert redPDB.getSers(key) == ser
# verify the signature
sigs = redPDB.getSigs(key)
assert len(sigs) == 1
assert sigs[0] == sig0
# verify we can look up credential by Schema SAID
schema = redPDB.getSchms(schemer.saider.qb64b)
assert len(schema) == 1
assert schema[0] == key
def test_proving():
sidSalt = coring.Salter(raw=b'0123456789abcdef').qb64
hanSalt = coring.Salter(raw=b'abcdef0123456789').qb64
vicSalt = coring.Salter(raw=b'fedcba9876543210').qb64
with basing.openDB(name="sid") as sidDB, \
keeping.openKS(name="sid") as sidKS, \
basing.openDB(name="vic") as vicDB, \
keeping.openKS(name="vic") as vicKS, \
basing.openDB(name="han") as hanDB, \
keeping.openKS(name="han") as hanKS, \
openPocket(name="han") as hanPDB:
limit = 1.0
tock = 1.0
doist = doing.Doist(limit=limit, tock=tock)
sidHab = habbing.Habitat(ks=sidKS, db=sidDB, salt=sidSalt, temp=True)
assert sidHab.pre == "E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E"
sidIcpMsg = sidHab.makeOwnInception()
hanKvy = eventing.Kevery(db=hanDB)
parsing.Parser().parse(ims=bytearray(sidIcpMsg), kvy=hanKvy)
assert hanKvy.kevers[sidHab.pre].sn == 0 # accepted event
hanHab = habbing.Habitat(ks=hanKS, db=hanDB, salt=hanSalt, temp=True)
assert hanHab.pre == "EKDWzykRd45o5UQyprm_9e8UcltXGo1tZCrdfGBTA8tc"
hanIcpMsg = hanHab.makeOwnInception()
vicKvy = eventing.Kevery(db=vicDB)
parsing.Parser().parse(ims=bytearray(hanIcpMsg), kvy=vicKvy)
assert vicKvy.kevers[hanHab.pre].sn == 0 # accepted event
vicHab = habbing.Habitat(ks=vicKS, db=vicDB, salt=vicSalt, temp=True)
assert vicHab.pre == "E8HQASAgOnZnQ4T7rv3dcvj0-UydrTTtyCprhEASk__o"
vicIcpMsg = vicHab.makeOwnInception()
parsing.Parser().parse(ims=bytearray(vicIcpMsg), kvy=hanKvy)
assert hanKvy.kevers[vicHab.pre].sn == 0 # accepted event
sed = dict()
sed["$id"] = ""
sed["$schema"] = "http://json-schema.org/draft-07/schema#"
sed.update(
dict(type="object",
properties=dict(id=dict(type="string"),
lei=dict(type="string"))))
schemer = scheming.Schemer(sed=sed,
typ=scheming.JSONSchema(),
code=coring.MtrDex.Blake3_256)
cache = CacheResolver()
cache.add(schemer.said, schemer.raw)
jsonSchema = JSONSchema(resolver=cache)
credSubject = dict(
id=
"did:keri:Efaavv0oadfghasdfn443fhbyyr4v", # this needs to be generated from a KEL
lei="254900OPPU84GM83MG36",
issuanceDate="2021-06-27T21:26:21.233257+00:00",
)
creder = credential(issuer=sidHab.pre,
schema=schemer.said,
subject=credSubject,
typ=JSONSchema(resolver=cache))
assert creder.said == "EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM"
msg = sidHab.endorse(serder=creder)
hanWallet = Wallet(hab=hanHab, db=hanPDB)
parseCredential(ims=msg,
wallet=hanWallet,
typ=JSONSchema(resolver=cache))
# verify we can load serialized VC by SAID
key = creder.said.encode("utf-8")
assert hanPDB.getSers(key) is not None
# Create Red's wallet and Issue Handler for receiving the credential
hanRequestHandler = RequestHandler(wallet=hanWallet, typ=jsonSchema)
hanExc = exchanging.Exchanger(hab=hanHab,
tymth=doist.tymen(),
handlers=[hanRequestHandler])
# Create the issue credential payload
pl = dict(input_descriptors=[dict(x=schemer.said)])
# Create the `exn` message for presentation request
vicExcSrdr = exchanging.exchange(route="/presentation/request",
payload=pl)
excMsg = vicHab.sanction(vicExcSrdr)
# Parse the exn presentation request message on Han's side
parsing.Parser().parse(ims=bytearray(excMsg), kvy=hanKvy, exc=hanExc)
doist.do(doers=[hanExc])
assert doist.tyme == limit
resp = hanRequestHandler.cues.popleft()
assert resp is not None
respSer = coring.Serder(raw=resp.raw)
assert respSer.ked['t'] == coring.Ilks.exn
assert respSer.ked['r'] == "/presentation/proof"
data = respSer.ked['q']
assert "presentation_submission" in data
pe = data["presentation_submission"]
assert "descriptor_map" in pe
dm = pe["descriptor_map"]
assert len(dm) == 1
assert dm[0]["id"] == schemer.said
assert "verifiableCredential" in data
vcs = data["verifiableCredential"]
assert len(vcs) == 1
proof = (
"-FABE4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E0AAAAAAAAAAAAAAAAAAAAAAAElHzHwX3V6itsD2Ksg_CNBbUNTBYzLYw"
"-AxDNI7_ZmaI-AABAA0pXbQllgzXr88IczAnsPrdhgFKs9wNQvfSfzyrtcvbTwq-U1DmBluAklntCqH1AbBL6TWLZIDGi83BHLWJ82CA"
)
assert vcs[0]["proof"] == proof
def test_proving():
sidSalt = coring.Salter(raw=b'0123456789abcdef').qb64
with basing.openDB(name="sid") as sidDB, \
keeping.openKS(name="sid") as sidKS:
sidHab = habbing.Habitat(ks=sidKS, db=sidDB, salt=sidSalt, temp=True)
assert sidHab.pre == "E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E"
sed = dict()
sed["$id"] = ""
sed["$schema"] = "http://json-schema.org/draft-07/schema#"
sed.update(
dict(type="object",
properties=dict(id=dict(type="string"),
lei=dict(type="string"))))
schemer = scheming.Schemer(sed=sed,
typ=scheming.JSONSchema(),
code=coring.MtrDex.Blake3_256)
credSubject = dict(
id=
"did:keri:Efaavv0oadfghasdfn443fhbyyr4v", # this needs to be generated from a KEL
lei="254900OPPU84GM83MG36",
issuanceDate="2021-06-27T21:26:21.233257+00:00",
)
cache = CacheResolver()
cache.add(schemer.said, schemer.raw)
creder = credential(issuer=sidHab.pre,
schema=schemer.said,
subject=credSubject,
typ=JSONSchema(resolver=cache))
msg = sidHab.endorse(serder=creder)
assert msg == (
b'{"v":"KERI10JSON000136_","i":"EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM",'
b'"x":"EeCCZi1R5xHUlhsyQNm_7NrUQTEKZH5P9vBomnc9AihY","ti":"E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E",'
b'"d":{"id":"did:keri:Efaavv0oadfghasdfn443fhbyyr4v","lei":"254900OPPU84GM83MG36",'
b'"issuanceDate":"2021-06-27T21:26:21.233257+00:00"}}-VA0-FABE4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE'
b'-YfcI9E0AAAAAAAAAAAAAAAAAAAAAAAElHzHwX3V6itsD2Ksg_CNBbUNTBYzLYw-AxDNI7_ZmaI'
b'-AABAA0pXbQllgzXr88IczAnsPrdhgFKs9wNQvfSfzyrtcvbTwq-U1DmBluAklntCqH1AbBL6TWLZIDGi83BHLWJ82CA'
)
creder = Credentialer(raw=msg, typ=JSONSchema(resolver=cache))
proof = msg[creder.size:]
ctr = Counter(qb64b=proof, strip=True)
assert ctr.code == CtrDex.AttachedMaterialQuadlets
assert ctr.count == 52
pags = ctr.count * 4
assert len(proof) == pags
ctr = Counter(qb64b=proof, strip=True)
assert ctr.code == CtrDex.TransIndexedSigGroups
assert ctr.count == 1
prefixer = Prefixer(qb64b=proof, strip=True)
assert prefixer.qb64 == sidHab.pre
seqner = Seqner(qb64b=proof, strip=True)
assert seqner.sn == sidHab.kever.sn
diger = Diger(qb64b=proof, strip=True)
assert diger.qb64 == sidHab.kever.serder.dig
ictr = Counter(qb64b=proof, strip=True)
assert ictr.code == CtrDex.ControllerIdxSigs
isigers = []
for i in range(ictr.count):
isiger = Siger(qb64b=proof, strip=True)
isiger.verfer = sidHab.kever.serder.verfers[i]
isigers.append(isiger)
assert len(isigers) == 1
siger = isigers[0]
assert siger.verfer.verify(siger.raw, creder.raw) is True
def test_wallet():
sidSalt = coring.Salter(raw=b'0123456789abcdef').qb64
with basing.openDB(name="sid") as sidDB, \
keeping.openKS(name="sid") as sidKS, \
openPocket(name="sid") as sidPDB:
sidHab = habbing.Habitat(ks=sidKS, db=sidDB, salt=sidSalt, temp=True)
assert sidHab.pre == "E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E"
sed = dict()
sed["$id"] = ""
sed["$schema"] = "http://json-schema.org/draft-07/schema#"
sed.update(dict(
type="object",
properties=dict(
id=dict(
type="string"
),
lei=dict(
type="string"
)
)
))
schemer = scheming.Schemer(sed=sed, typ=scheming.JSONSchema(), code=coring.MtrDex.Blake3_256)
credSubject = dict(
id="did:keri:Efaavv0oadfghasdfn443fhbyyr4v", # this needs to be generated from a KEL
lei="254900OPPU84GM83MG36",
issuanceDate="2021-06-27T21:26:21.233257+00:00",
)
cache = CacheResolver()
cache.add(schemer.said, schemer.raw)
creder = credential(issuer=sidHab.pre,
schema=schemer.said,
subject=credSubject,
typ=JSONSchema(resolver=cache))
assert creder.said == "EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM"
msg = sidHab.endorse(serder=creder)
assert msg == (
b'{"v":"KERI10JSON000136_","i":"EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM",'
b'"x":"EeCCZi1R5xHUlhsyQNm_7NrUQTEKZH5P9vBomnc9AihY","ti":"E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E",'
b'"d":{"id":"did:keri:Efaavv0oadfghasdfn443fhbyyr4v","lei":"254900OPPU84GM83MG36",'
b'"issuanceDate":"2021-06-27T21:26:21.233257+00:00"}}-VA0-FABE4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE'
b'-YfcI9E0AAAAAAAAAAAAAAAAAAAAAAAElHzHwX3V6itsD2Ksg_CNBbUNTBYzLYw-AxDNI7_ZmaI'
b'-AABAA0pXbQllgzXr88IczAnsPrdhgFKs9wNQvfSfzyrtcvbTwq-U1DmBluAklntCqH1AbBL6TWLZIDGi83BHLWJ82CA')
ser = (
b'{"v":"KERI10JSON000136_","i":"EgaaYOPdG7vootT99cmClvwOoM-hjUIpv5Xl6hFuTcyM",'
b'"x":"EeCCZi1R5xHUlhsyQNm_7NrUQTEKZH5P9vBomnc9AihY","ti":"E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E",'
b'"d":{"id":"did:keri:Efaavv0oadfghasdfn443fhbyyr4v","lei":"254900OPPU84GM83MG36",'
b'"issuanceDate":"2021-06-27T21:26:21.233257+00:00"}}')
seal = (
b'E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E0AAAAAAAAAAAAAAAAAAAAAAAElHzHwX3V6itsD2Ksg_CNBbUNTBYzLYw'
b'-AxDNI7_ZmaI')
sig0 = (
b'AA0pXbQllgzXr88IczAnsPrdhgFKs9wNQvfSfzyrtcvbTwq-U1DmBluAklntCqH1AbBL6TWLZIDGi83BHLWJ82CA'
)
sidWallet = Wallet(hab=sidHab, db=sidPDB)
parseCredential(ims=msg, wallet=sidWallet, typ=JSONSchema(resolver=cache))
# verify we can load serialized VC by SAID
key = creder.said.encode("utf-8")
assert sidPDB.getSers(key) == ser
# verify the signature
sigs = sidPDB.getSigs(key)
assert len(sigs) == 1
assert sigs[0] == sig0
# verify the seal
sl = sidPDB.getSeals(key)
assert sl == seal
# verify we can look up credential by Schema SAID
schema = sidPDB.getSchms(schemer.saider.qb64b)
assert len(schema) == 1
assert schema[0] == key