async def testRevealedAndPredicateDifferentIssuers(prover1, allClaims, schemaGvtId, schemaXyzId, attrRepo, schemaGvt): proofRequest = ProofRequest( "proof1", "1.0", 1, verifiableAttributes={'attr_uuid': AttributeInfo(name='status')}, predicates={'predicate_uuid': PredicateGE('age', 18)}) claimsGvt = await prover1.wallet.getClaimSignature(schemaGvtId) claimsXyz = await prover1.wallet.getClaimSignature(schemaXyzId) proofClaims = { schemaGvt.seqId: ProofClaims(claimsGvt, [], [PredicateGE('age', 18)]), schemaGvt.seqId: ProofClaims(claimsXyz, ['status'], []) } attr = attrRepo.getAttributes(schemaXyzId.schemaKey, prover1.proverId)['status'] requestedProof = RequestedProof( revealed_attrs={ 'attr_uuid': [schemaGvt.seqId, attr, str(encodeAttr(attr))] }, predicates={'predicate_uuid': schemaGvt.seqId}) assert proofClaims, requestedProof == await prover1._findClaims( proofRequest)
async def testMultipledPredicates(prover1, allClaims, schemaGvtId, schemaXyzId, schemaGvt): proofRequest = ProofRequest("proof1", "1.0", 1, predicates={ 'predicate_uuid1': PredicateGE('age', 18), 'predicate_uuid2': PredicateGE('period', 8) }) claimsGvt = await prover1.wallet.getClaimSignature(schemaGvtId) claimsXyz = await prover1.wallet.getClaimSignature(schemaXyzId) proofClaims = { schemaGvt.seqId: ProofClaims(claimsGvt, [], [PredicateGE('age', 18)]), schemaGvt.seqId: ProofClaims(claimsXyz, [], [PredicateGE('period', 8)]) } requestedProof = RequestedProof(predicates={ 'predicate_uuid1': schemaGvt.seqId, 'predicate_uuid2': schemaGvt.seqId }) assert proofClaims, requestedProof == await prover1._findClaims( proofRequest)
async def testGePredicateNegativeForOne(prover1, prover2, verifier, allClaims): proofInput = ProofInput(['name'], [PredicateGE('age', 18), PredicateGE('period', 9)]) assert await presentProofAndVerify(verifier, proofInput, prover2) with pytest.raises(ValueError): await presentProofAndVerify(verifier, proofInput, prover1)
async def testGePredicate(prover1, prover2, verifier, allClaims): proofRequest = ProofRequest("proof1", "1.0", verifier.generateNonce(), verifiableAttributes={'attr_uuid1': AttributeInfo(name='name')}, predicates={'predicate_uuid1': PredicateGE('age', 18), 'predicate_uuid2': PredicateGE('period', 3)}) assert await presentProofAndVerify(verifier, proofRequest, prover1) assert await presentProofAndVerify(verifier, proofRequest, prover2)
async def testMultipleGePredicateNegative(prover1, verifier, claimsProver1): proofRequest = ProofRequest("proof1", "1.0", verifier.generateNonce(), verifiableAttributes={'attr_uuid': AttributeInfo(name='name')}, predicates={'predicate_uuid1': PredicateGE('age', 18), 'predicate_uuid2': PredicateGE('period', 9)}) with pytest.raises(ValueError): await presentProofAndVerify(verifier, proofRequest, prover1)
async def testMultipleGePredicateMultipleRevealed(prover1, verifier, claimsProver1): proofRequest = ProofRequest("proof1", "1.0", verifier.generateNonce(), verifiableAttributes={'attr_uuid1': AttributeInfo(name='name'), 'attr_uuid2': AttributeInfo(name='status')}, predicates={'predicate_uuid1': PredicateGE('age', 18), 'predicate_uuid2': PredicateGE('period', 5)}) await presentProofAndVerify(verifier, proofRequest, prover1)
async def testGePredicateNegativeForBoth(prover1, prover2, verifier, allClaims): proofRequest = ProofRequest("proof1", "1.0", verifier.generateNonce(), verifiableAttributes={'attr_uuid1': AttributeInfo(name='name')}, predicates={'predicate_uuid1': PredicateGE('age', 38), 'predicate_uuid2': PredicateGE('period', 30)}) with pytest.raises(ValueError): await presentProofAndVerify(verifier, proofRequest, prover1) with pytest.raises(ValueError): await presentProofAndVerify(verifier, proofRequest, prover2)
async def testPredicateNotFound(prover1, allClaims): proofRequest = ProofRequest("proof1", "1.0", 1, predicates={ 'predicate_uuid1': PredicateGE('age', 18), 'predicate_uuid2': PredicateGE('aaaa', 8) }) with pytest.raises(ValueError): await prover1._findClaims(proofRequest)
async def testRevealedEmpty(prover1, allClaims, schemaGvtId): proofInput = ProofInput([], [PredicateGE('age', 18)]) claimsGvt = await prover1.wallet.getClaims(schemaGvtId) proofClaims = { schemaGvtId.schemaKey: ProofClaims(claimsGvt, [], [PredicateGE('age', 18)]) } revealedAttrs = {} assert (proofClaims, revealedAttrs) == await prover1._findClaims(proofInput)
async def testOnePredicateOnly(prover1, allClaims, schemaGvtId, schemaGvt): proofRequest = ProofRequest("proof1", "1.0", 1, predicates={'uuid': PredicateGE('age', 18)}) claimsGvt = await prover1.wallet.getClaimSignature(schemaGvtId) proofClaims = {schemaGvt.seqId: ProofClaims(claimsGvt, [], [PredicateGE('age', 18)])} requestedProof = RequestedProof(predicates={'uuid': schemaGvt.seqId}) assert proofClaims, requestedProof == await prover1._findClaims(proofRequest)
async def testMultipleGePredicate(prover1, verifier, claimsProver1Gvt): proofRequest = ProofRequest( "proof1", "1.0", verifier.generateNonce(), verifiableAttributes={'attr_uuid': AttributeInfo(name='name')}, predicates={ 'predicate_uuid1': PredicateGE('age', 18), 'predicate_uuid2': PredicateGE('height', 170) }) assert await presentProofAndVerify(verifier, proofRequest, prover1)
async def testSingleIssuerMultipleCredDefsSingleProver(primes1, primes2): # 1. Init entities publicRepo = PublicRepoInMemory() attrRepo = AttributeRepoInMemory() issuer = Issuer(IssuerWalletInMemory('issuer1', publicRepo), attrRepo) # 2. Create a Schema schema1 = await issuer.genSchema('GVT', '1.0', GVT.attribNames()) schemaId1 = ID(schema1.getKey()) schema2 = await issuer.genSchema('XYZCorp', '1.0', XYZCorp.attribNames()) schemaId2 = ID(schema2.getKey()) # 3. Create keys for the Schema await issuer.genKeys(schemaId1, **primes1) await issuer.genKeys(schemaId2, **primes2) # 4. Issue accumulator await issuer.issueAccumulator(schemaId=schemaId1, iA='110', L=5) await issuer.issueAccumulator(schemaId=schemaId2, iA=9999999, L=5) # 4. set attributes for user1 userId = '111' attrs1 = GVT.attribs(name='Alex', age=28, height=175, sex='male') attrs2 = XYZCorp.attribs(status='FULL', period=8) attrRepo.addAttributes(schema1.getKey(), userId, attrs1) attrRepo.addAttributes(schema2.getKey(), userId, attrs2) # 5. request Claims prover = Prover(ProverWalletInMemory(userId, publicRepo)) claimsReqs = await prover.createClaimRequests([schemaId1, schemaId2]) claims = await issuer.issueClaims(claimsReqs) await prover.processClaims(claims) # 6. proof Claims verifier = Verifier(WalletInMemory('verifier1', publicRepo)) proofRequest = ProofRequest("proof1", "1.0", verifier.generateNonce(), verifiableAttributes={ 'attr_uuid1': AttributeInfo('name', schema1.seqId) }, predicates={ 'predicate_uuid1': PredicateGE('age', 18), 'predicate_uuid2': PredicateGE('period', 5) }) proof = await prover.presentProof(proofRequest) assert proof.requestedProof.revealed_attrs['attr_uuid1'][1] == 'Alex' assert await verifier.verify(proofRequest, proof)
async def testRevealedAndPredicateSameIssuer(prover1, allClaims, schemaGvtId, attrRepo): proofInput = ProofInput(['name'], [PredicateGE('age', 18)]) claimsGvt = await prover1.wallet.getClaims(schemaGvtId) proofClaims = { schemaGvtId.schemaKey: ProofClaims(claimsGvt, ['name'], [PredicateGE('age', 18)]) } revealedAttrs = { 'name': attrRepo.getAttributes(schemaGvtId.schemaKey, prover1.proverId)['name'] } assert (proofClaims, revealedAttrs) == await prover1._findClaims(proofInput)
async def testMultiplIssuersSingleProver(primes1, primes2): # 1. Init entities publicRepo = PublicRepoInMemory() attrRepo = AttributeRepoInMemory() issuer1 = Issuer(IssuerWalletInMemory('issuer1', publicRepo), attrRepo) issuer2 = Issuer(IssuerWalletInMemory('issuer2', publicRepo), attrRepo) # 2. Create a Schema schema1 = await issuer1.genSchema('GVT', '1.0', GVT.attribNames()) schemaId1 = ID(schema1.getKey()) schema2 = await issuer2.genSchema('XYZCorp', '1.0', XYZCorp.attribNames()) schemaId2 = ID(schema2.getKey()) # 3. Create keys for the Schema await issuer1.genKeys(schemaId1, **primes1) await issuer2.genKeys(schemaId2, **primes2) # 4. Issue accumulator await issuer1.issueAccumulator(schemaId=schemaId1, iA='110', L=5) await issuer2.issueAccumulator(schemaId=schemaId2, iA=9999999, L=5) # 4. set attributes for user1 userId = '111' attrs1 = GVT.attribs(name='Alex', age=28, height=175, sex='male') attrs2 = XYZCorp.attribs(status='FULL', period=8) attrRepo.addAttributes(schema1.getKey(), userId, attrs1) attrRepo.addAttributes(schema2.getKey(), userId, attrs2) # 5. request Claims prover = Prover(ProverWalletInMemory(userId, publicRepo)) claimsReq1 = await prover.createClaimRequest(schemaId1) claimsReq2 = await prover.createClaimRequest(schemaId2) claims1 = await issuer1.issueClaim(schemaId1, claimsReq1) claims2 = await issuer2.issueClaim(schemaId2, claimsReq2) await prover.processClaim(schemaId1, claims1) await prover.processClaim(schemaId2, claims2) # 6. proof Claims proofInput = ProofInput(['name', 'status'], [PredicateGE('age', 18), PredicateGE('period', 5)]) verifier = Verifier(WalletInMemory('verifier1', publicRepo)) nonce = verifier.generateNonce() proof, revealedAttrs = await prover.presentProof(proofInput, nonce) assert revealedAttrs['name'] == 'Alex' assert revealedAttrs['status'] == 'FULL' assert await verifier.verify(proofInput, proof, revealedAttrs, nonce)
async def doTestAnonCredsPrimaryOnly(): # 1. Create a Schema schema = await issuer.genSchema('GVT', '1.0', GVT.attribNames()) schemaId = ID(schemaKey=schema.getKey(), schemaId=schema.seqId) # 2. Create keys for the Schema await issuer.genKeys(schemaId, **primes1) # 3. Issue accumulator #TODO: Not implemented yet #await issuer.issueAccumulator(schemaId=schemaId, iA='110', L=5) # 4. set attributes for user1 attrs = GVT.attribs(name='Alex', age=28, height=175, sex='male') proverId = str(prover.proverId) attrRepo.addAttributes(schema.getKey(), proverId, attrs) # 5. request Claims claimsReq = await prover.createClaimRequest(schemaId, proverId, False) claims = await issuer.issueClaim(schemaId, claimsReq) await prover.processClaim(schemaId, claims) # 6. proof Claims proofInput = ProofInput( ['name'], [PredicateGE('age', 18)]) nonce = verifier.generateNonce() proof, revealedAttrs = await prover.presentProof(proofInput, nonce) assert await verifier.verify(proofInput, proof, revealedAttrs, nonce)
async def testSingleIssuerSingleProver(primes1): # 1. Init entities publicRepo = PublicRepoInMemory() attrRepo = AttributeRepoInMemory() issuer = Issuer(IssuerWalletInMemory('issuer1', publicRepo), attrRepo) # 2. Create a Schema schema = await issuer.genSchema('GVT', '1.0', GVT.attribNames()) schemaId = ID(schema.getKey()) # 3. Create keys for the Schema await issuer.genKeys(schemaId, **primes1) # 4. Issue accumulator await issuer.issueAccumulator(schemaId=schemaId, iA='110', L=5) # 4. set attributes for user1 userId = '111' attrs = GVT.attribs(name='Alex', age=28, height=175, sex='male') attrRepo.addAttributes(schema.getKey(), userId, attrs) # 5. request Claims prover = Prover(ProverWalletInMemory(userId, publicRepo)) claimsReq = await prover.createClaimRequest(schemaId) claims = await issuer.issueClaim(schemaId, claimsReq) await prover.processClaim(schemaId, claims) # 6. proof Claims proofInput = ProofInput(['name'], [PredicateGE('age', 18)]) verifier = Verifier(WalletInMemory('verifier1', publicRepo)) nonce = verifier.generateNonce() proof, revealedAttrs = await prover.presentProof(proofInput, nonce) assert revealedAttrs['name'] == 'Alex' assert await verifier.verify(proofInput, proof, revealedAttrs, nonce)
async def create_proof_request(conn): # 1. Init entities public_repo = PublicRepoInMemory() attr_repo = AttributeRepoInMemory() issuer = Issuer(IssuerWalletInMemory('issuer1', public_repo), attr_repo) # 2. Create a Schema schema = await issuer.genSchema('GVT', '1.0', GVT.attribNames()) schema_id = ID(schema.getKey()) # 3. Create keys for the Schema global global_dict await issuer.wallet.submitPublicKeys(schema_id, global_dict['public_key']) # 4. set attributes for user1 prover_id = 'BzfFCYk' attributes = GVT.attribs(name='Alex', age=28, height=175, sex='male') attr_repo.addAttributes(schema.getKey(), prover_id, attributes) verifier = Verifier(WalletInMemory('verifier1', public_repo)) proof_request = ProofRequest( name='Test_proof', version='1.0', nonce=verifier.generateNonce(), verifiableAttributes={ 'attr_uuid': AttributeInfo('name', schema.seqId)}, predicates={'predicate_uuid': PredicateGE('age', 18)}) global_dict['verifier'] = verifier global_dict['proof_request'] = proof_request conn.send(json.dumps(proof_request.to_str_dict()).encode())
async def testMultipledPredicates(prover1, allClaims, schemaGvtId, schemaXyzId): proofInput = ProofInput([], [PredicateGE('age', 18), PredicateGE('period', 8)]) claimsGvt = await prover1.wallet.getClaims(schemaGvtId) claimsXyz = await prover1.wallet.getClaims(schemaXyzId) proofClaims = { schemaGvtId.schemaKey: ProofClaims(claimsGvt, [], [PredicateGE('age', 18)]), schemaXyzId.schemaKey: ProofClaims(claimsXyz, [], [PredicateGE('period', 8)]) } revealedAttrs = {} assert (proofClaims, revealedAttrs) == await prover1._findClaims(proofInput)
async def testClaimProofFromToDictPrimaryOnly(prover1, nonce, claimsProver1Gvt): proofInput = ProofInput(['name'], [PredicateGE('age', 18)]) proof, _ = await prover1.presentProof(proofInput, nonce) proofs = [Proof(primaryProof=proof.proofs[0].primaryProof)] proof = proof._replace(proofs=proofs) assert proof == FullProof.fromStrDict(proof.toStrDict())
async def test_primary_proof_from_to_dict(): n = cmod.integer(12345) eqProof = PrimaryEqualProof(e=cmod.integer(1), v=cmod.integer(11), m={'name': cmod.integer(12)}, m1=cmod.integer(12), m2=cmod.integer(32), Aprime=cmod.integer(32) % n, revealedAttrs={'name': cmod.integer(35)}) predicate = PredicateGE(attrName='age', value=18) geProof = PrimaryPredicateGEProof(alpha=cmod.integer(1), mj=cmod.integer(12), r={'1': cmod.integer(13)}, u={'1': cmod.integer(42)}, T={'1': cmod.integer(21) % n}, predicate=predicate) primaryProof = PrimaryProof(eqProof=eqProof, geProofs=[geProof]) proof_serialized = { 'eq_proof': { 'a_prime': '32', 'e': '1', 'm': { 'name': '12' }, 'm1': '12', 'm2': '32', 'v': '11', 'revealed_attrs': { 'name': '35' } }, 'ge_proofs': [{ 'alpha': '1', 'mj': '12', 't': { '1': '21' }, 'r': { '1': '13' }, 'u': { '1': '42' }, 'predicate': { 'p_type': 'GE', 'attr_name': 'age', 'value': 18, 'schema_seq_no': None, 'issuer_did': None } }] } assert primaryProof.to_str_dict() == proof_serialized assert primaryProof == PrimaryProof.from_str_dict(proof_serialized, n) assert primaryProof == PrimaryProof.from_str_dict( primaryProof.to_str_dict(), n)
async def test_requested_proof_from_to_dict(prover1, nonce, claimsProver1Gvt): proofRequest = ProofRequest( "proof1", "1.0", 1, verifiableAttributes={'attr_uuid': AttributeInfo(name='name')}, predicates={'predicate_uuid': PredicateGE('age', 18)}) proof = await prover1.presentProof(proofRequest) requested_proof_serialized = { 'revealed_attrs': { 'attr_uuid': ['1', 'Alex', '1139481716457488690172217916278103335'] }, 'predicates': { 'predicate_uuid': '1' }, 'self_attested_attrs': {}, 'unrevealed_attrs': {} } assert proof.requestedProof.to_str_dict() == requested_proof_serialized assert proof.requestedProof == RequestedProof.from_str_dict( requested_proof_serialized) assert proof.requestedProof == RequestedProof.from_str_dict( proof.requestedProof.to_str_dict())
def test_proof_request_from_to_dict(): proofRequest = ProofRequest( "proof1", "1.0", 1, verifiableAttributes={'attr_uuid': AttributeInfo(name='name')}, predicates={'predicate_uuid': PredicateGE('age', 18)}) proof_input_serialized = { 'name': 'proof1', 'version': '1.0', 'nonce': '1', 'requested_attrs': { 'attr_uuid': { 'name': 'name', 'schema_seq_no': None, 'issuer_did': None } }, 'requested_predicates': { 'predicate_uuid': { 'p_type': 'GE', 'value': 18, 'attr_name': 'age', 'schema_seq_no': None, 'issuer_did': None } } } assert proofRequest.to_str_dict() == proof_input_serialized assert proofRequest == ProofRequest.from_str_dict(proof_input_serialized) assert proofRequest == ProofRequest.from_str_dict( proofRequest.to_str_dict())
async def test_ge_proof_from_to_dict(): n = cmod.integer(12345) predicate = PredicateGE(attrName='age', value=18) geProof = PrimaryPredicateGEProof(alpha=cmod.integer(1), mj=cmod.integer(12), r={'1': cmod.integer(13)}, u={'1': cmod.integer(42)}, T={'1': cmod.integer(21) % n}, predicate=predicate) proof_serialized = { 'alpha': '1', 'mj': '12', 't': {'1': '21'}, 'r': {'1': '13'}, 'u': {'1': '42'}, 'predicate': { 'p_type': 'GE', 'attr_name': 'age', 'value': 18, 'schema_seq_no': None, 'issuer_did': None } } assert geProof.to_str_dict() == proof_serialized assert geProof == PrimaryPredicateGEProof.from_str_dict( proof_serialized, n) assert geProof == PrimaryPredicateGEProof.from_str_dict( geProof.to_str_dict(), n)
async def testGePredicateForEqual(prover1, verifier, claimsProver1Gvt): proofRequest = ProofRequest( "proof1", "1.0", verifier.generateNonce(), verifiableAttributes={'attr_uuid': AttributeInfo(name='name')}, predicates={'predicate_uuid': PredicateGE('age', 28)}) assert await presentProofAndVerify(verifier, proofRequest, prover1)
async def testRevealedAndPredicateDifferentIssuers(prover1, allClaims, schemaGvtId, schemaXyzId, attrRepo): proofInput = ProofInput(['status'], [PredicateGE('age', 18)]) claimsGvt = await prover1.wallet.getClaims(schemaGvtId) claimsXyz = await prover1.wallet.getClaims(schemaXyzId) proofClaims = { schemaGvtId.schemaKey: ProofClaims(claimsGvt, [], [PredicateGE('age', 18)]), schemaXyzId.schemaKey: ProofClaims(claimsXyz, ['status'], []) } revealedAttrs = { 'status': attrRepo.getAttributes(schemaXyzId.schemaKey, prover1.proverId)['status'] } assert (proofClaims, revealedAttrs) == await prover1._findClaims(proofInput)
async def testClaimProofFromToDict(prover1, nonce, claimsProver1Gvt): proofRequest = ProofRequest("proof1", "1.0", 1, verifiableAttributes={ 'attr_uuid': AttributeInfo(name='name')}, predicates={'predicate_uuid': PredicateGE('age', 18)}) proof = await prover1.presentProof(proofRequest) assert proof == FullProof.fromStrDict(proof.toStrDict())
async def testMultipleAll(prover1, allClaims, schemaGvtId, schemaXyzId, attrRepo, schemaGvt): proofRequest = ProofRequest("proof1", "1.0", 1, verifiableAttributes={ 'attr_uuid1': AttributeInfo(name='status'), 'attr_uuid2': AttributeInfo(name='name') }, predicates={ 'predicate_uuid1': PredicateGE('age', 18), 'predicate_uuid2': PredicateGE('period', 8) }) claimsGvt = await prover1.wallet.getClaimSignature(schemaGvtId) claimsXyz = await prover1.wallet.getClaimSignature(schemaXyzId) proofClaims = { schemaGvt.seqId: ProofClaims(claimsGvt, ['name'], [PredicateGE('age', 18)]), schemaGvt.seqId: ProofClaims(claimsXyz, ['status'], [PredicateGE('period', 8)]) } attr1 = attrRepo.getAttributes(schemaXyzId.schemaKey, prover1.proverId)['status'] attr2 = attrRepo.getAttributes(schemaGvtId.schemaKey, prover1.proverId)['name'] requestedProof = RequestedProof(revealed_attrs={ 'attr_uuid1': [schemaGvt.seqId, attr1, str(encodeAttr(attr1))], 'attr_uuid2': [schemaGvt.seqId, attr2, str(encodeAttr(attr2))] }, predicates={ 'predicate_uuid1': schemaGvt.seqId, 'predicate_uuid2': schemaGvt.seqId }) assert proofClaims, requestedProof == await prover1._findClaims( proofRequest)
async def testPrimaryClaimPredicatesOnly(prover1, verifier, claimsProver1Gvt, nonce, schemaGvtId): predicates = [PredicateGE('age', 18)] proofInput = ProofInput(predicates=predicates) claims, revealedAttrs = await prover1._findClaims(proofInput) claims = {schemaKey: ProofClaims( Claims(primaryClaim=proofClaim.claims.primaryClaim), predicates=predicates) for schemaKey, proofClaim in claims.items()} proof = await prover1._prepareProof(claims, nonce) assert await verifier.verify(proofInput, proof, revealedAttrs, nonce)
async def testMultipleAll(prover1, allClaims, schemaGvtId, schemaXyzId, attrRepo): proofInput = ProofInput(['status', 'name'], [PredicateGE('age', 18), PredicateGE('period', 8)]) claimsGvt = await prover1.wallet.getClaims(schemaGvtId) claimsXyz = await prover1.wallet.getClaims(schemaXyzId) proofClaims = { schemaGvtId.schemaKey: ProofClaims(claimsGvt, ['name'], [PredicateGE('age', 18)]), schemaXyzId.schemaKey: ProofClaims(claimsXyz, ['status'], [PredicateGE('period', 8)]) } revealedAttrs = { 'name': attrRepo.getAttributes(schemaGvtId.schemaKey, prover1.proverId)['name'], 'status': attrRepo.getAttributes(schemaXyzId.schemaKey, prover1.proverId)['status'], } assert (proofClaims, revealedAttrs) == await prover1._findClaims(proofInput)
async def testClaimProofFromToDictPrimaryOnly(prover1, nonce, claimsProver1Gvt, schemaGvt): proofRequest = ProofRequest("proof1", "1.0", 1, verifiableAttributes={ 'attr_uuid': AttributeInfo(name='name')}, predicates={'predicate_uuid': PredicateGE('age', 18)}) proof = await prover1.presentProof(proofRequest) proofInfo = proof.proofs[str(schemaGvt.seqId)] proofs = {schemaGvt.seqId: ProofInfo(Proof(primaryProof=proofInfo.proof.primaryProof), issuer_did=schemaGvt.issuerId, schema_seq_no=proofInfo.schema_seq_no)} proof = proof._replace(proofs=proofs) assert proof == FullProof.fromStrDict(proof.toStrDict())