docs: 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