async def verifier_verify_proof(proof_request_json: str,
                                proof_json: str,
                                schemas_json: str,
                                credential_defs_json: str,
                                rev_reg_defs_json: str,
                                rev_regs_json: str) -> bool:
    """
    Verifies a proof (of multiple credential).
    All required schemas, public keys and revocation registries must be provided.

    :param proof_request_json: 
         {
             "name": string,
             "version": string,
             "nonce": string,
             "requested_attributes": { // set of requested attributes
                  "<attr_referent>": <attr_info>, // see below
                  ...,
             },
             "requested_predicates": { // set of requested predicates
                  "<predicate_referent>": <predicate_info>, // see below
                  ...,
              },
             "non_revoked": Optional<<non_revoc_interval>>, // see below,
                            // If specified prover must proof non-revocation
                            // for date in this interval for each attribute
                            // (can be overridden on attribute level)
         }
    :param proof_json: created for request proof json
         {
             "requested_proof": {
                 "revealed_attrs": {
                     "requested_attr1_id": {sub_proof_index: number, raw: string, encoded: string},
                     "requested_attr4_id": {sub_proof_index: number: string, encoded: string},
                 },
                 "unrevealed_attrs": {
                     "requested_attr3_id": {sub_proof_index: number}
                 },
                 "self_attested_attrs": {
                     "requested_attr2_id": self_attested_value,
                 },
                 "requested_predicates": {
                     "requested_predicate_1_referent": {sub_proof_index: int},
                     "requested_predicate_2_referent": {sub_proof_index: int},
                 }
             }
             "proof": {
                 "proofs": [ <credential_proof>, <credential_proof>, <credential_proof> ],
                 "aggregated_proof": <aggregated_proof>
             }
             "identifiers": [{schema_id, cred_def_id, Optional<rev_reg_id>, Optional<timestamp>}]
         }
    :param schemas_json: all schema jsons participating in the proof
         {
             <schema1_id>: <schema1_json>,
             <schema2_id>: <schema2_json>,
             <schema3_id>: <schema3_json>,
         }
    :param credential_defs_json: all credential definitions json participating in the proof
         {
             "cred_def1_id": <credential_def1_json>,
             "cred_def2_id": <credential_def2_json>,
             "cred_def3_id": <credential_def3_json>,
         }
    :param rev_reg_defs_json: all revocation registry definitions json participating in the proof
         {
             "rev_reg_def1_id": <rev_reg_def1_json>,
             "rev_reg_def2_id": <rev_reg_def2_json>,
             "rev_reg_def3_id": <rev_reg_def3_json>,
         }
    :param rev_regs_json: all revocation registries json participating in the proof
         {
             "rev_reg_def1_id": {
                 "timestamp1": <rev_reg1>,
                 "timestamp2": <rev_reg2>,
             },
             "rev_reg_def2_id": {
                 "timestamp3": <rev_reg3>
             },
             "rev_reg_def3_id": {
                 "timestamp4": <rev_reg4>
             },
         }
    :return: valid: true - if signature is valid, false - otherwise
    """

    logger = logging.getLogger(__name__)
    logger.debug("verifier_verify_proof: >>> proof_request_json: %r, proof_json: %r, schemas_json: %r, "
                 "credential_defs_jsons: %r, rev_reg_defs_json: %r, rev_regs_json: %r",
                 proof_request_json,
                 proof_json,
                 schemas_json,
                 credential_defs_json,
                 rev_reg_defs_json,
                 rev_regs_json)

    if not hasattr(verifier_verify_proof, "cb"):
        logger.debug("verifier_verify_proof: Creating callback")
        verifier_verify_proof.cb = create_cb(CFUNCTYPE(None, c_int32, c_int32, c_bool))

    c_proof_request_json = c_char_p(proof_request_json.encode('utf-8'))
    c_proof_json = c_char_p(proof_json.encode('utf-8'))
    c_schemas_json = c_char_p(schemas_json.encode('utf-8'))
    c_credential_defs_json = c_char_p(credential_defs_json.encode('utf-8'))
    c_rev_reg_defs_json = c_char_p(rev_reg_defs_json.encode('utf-8'))
    c_rev_regs_json = c_char_p(rev_regs_json.encode('utf-8'))

    res = await do_call('indy_verifier_verify_proof',
                        c_proof_request_json,
                        c_proof_json,
                        c_schemas_json,
                        c_credential_defs_json,
                        c_rev_reg_defs_json,
                        c_rev_regs_json,
                        verifier_verify_proof.cb)

    logger.debug("verifier_verify_proof: <<< res: %r", res)
    return res