docs: async def prover_create_credential_req(wallet_handle: int,
                                         prover_did: str,
                                         cred_offer_json: str,
                                         cred_def_json: str,
                                         master_secret_id: str) -> (str, str):
      """
      Creates a clam request for the given credential offer.
  
      The method creates a blinded master secret for a master secret identified by a provided name.
      The master secret identified by the name must be already stored in the secure wallet (see prover_create_master_secret)
      The blinded master secret is a part of the credential request.
  
      :param wallet_handle: wallet handler (created by open_wallet).
      :param prover_did: a DID of the prover
      :param cred_offer_json: credential offer as a json containing information about the issuer and a credential
      :param cred_def_json: credential definition json related to <cred_def_id> in <cred_offer_json>
      :param master_secret_id: the id of the master secret stored in the wallet
      :return: 
       cred_req_json: Credential request json for creation of credential by Issuer
       {
        "prover_did" : string,
        "cred_def_id" : string,
           // Fields below can depend on Cred Def type
        "blinded_ms" : <blinded_master_secret>,
        "blinded_ms_correctness_proof" : <blinded_ms_correctness_proof>,
        "nonce": string
      }
       cred_req_metadata_json: Credential request metadata json for processing of received form Issuer credential.
          Note: cred_req_metadata_json mustn't be shared with Issuer.
      """
  
      logger = logging.getLogger(__name__)
      logger.debug("prover_create_credential_req: >>> wallet_handle: %r, prover_did: %r, cred_offer_json: %r,"
                   " cred_def_json: %r, master_secret_id: %r",
                   wallet_handle,
                   prover_did,
                   cred_offer_json,
                   cred_def_json,
                   master_secret_id)
  
      if not hasattr(prover_create_credential_req, "cb"):
          logger.debug("prover_create_credential_req: Creating callback")
          prover_create_credential_req.cb = create_cb(CFUNCTYPE(None, c_int32, c_int32, c_char_p, c_char_p))
  
      c_wallet_handle = c_int32(wallet_handle)
      c_prover_did = c_char_p(prover_did.encode('utf-8'))
      c_cred_offer_json = c_char_p(cred_offer_json.encode('utf-8'))
      c_cred_def_json = c_char_p(cred_def_json.encode('utf-8'))
      c_master_secret_id = c_char_p(master_secret_id.encode('utf-8'))
  
      (credential_req_json, credential_req_metadata_json) = await do_call('indy_prover_create_credential_req',
                                                                          c_wallet_handle,
                                                                          c_prover_did,
                                                                          c_cred_offer_json,
                                                                          c_cred_def_json,
                                                                          c_master_secret_id,
                                                                          prover_create_credential_req.cb)
  
      credential_req_json = credential_req_json.decode()
      credential_req_metadata_json = credential_req_metadata_json.decode()
      res = (credential_req_json, credential_req_metadata_json)
  
      logger.debug("prover_create_credential_req: <<< res: %r", res)
      return res