use {ErrorCode, IndyHandle, IndyError};
use std::ffi::CString;
use std::ptr::null;
use futures::Future;
use utils::callbacks::{ClosureHandler, ResultHandler};
use ffi::anoncreds;
use ffi::{ResponseStringStringCB,
ResponseI32UsizeCB,
ResponseStringStringStringCB,
ResponseStringCB,
ResponseI32CB,
ResponseEmptyCB,
ResponseBoolCB};
pub fn issuer_create_schema(issuer_did: &str, name: &str, version: &str, attrs: &str) -> Box<Future<Item=(String, String), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string_string();
let err = _issuer_create_schema(command_handle, issuer_did, name, version, attrs, cb);
ResultHandler::str_str(command_handle, err, receiver)
}
fn _issuer_create_schema(command_handle: IndyHandle, issuer_did: &str, name: &str, version: &str, attrs: &str, cb: Option<ResponseStringStringCB>) -> ErrorCode {
let issuer_did = c_str!(issuer_did);
let name = c_str!(name);
let version = c_str!(version);
let attrs = c_str!(attrs);
ErrorCode::from(unsafe {
anoncreds::indy_issuer_create_schema(command_handle, issuer_did.as_ptr(), name.as_ptr(), version.as_ptr(), attrs.as_ptr(), cb)
})
}
pub fn issuer_create_and_store_credential_def(wallet_handle: IndyHandle, issuer_did: &str, schema_json: &str, tag: &str, signature_type: Option<&str>, config_json: &str) -> Box<Future<Item=(String, String), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string_string();
let err = _issuer_create_and_store_credential_def(command_handle, wallet_handle, issuer_did, schema_json, tag, signature_type, config_json, cb);
ResultHandler::str_str(command_handle, err, receiver)
}
fn _issuer_create_and_store_credential_def(command_handle: IndyHandle, wallet_handle: IndyHandle, issuer_did: &str, schema_json: &str, tag: &str, signature_type: Option<&str>, config_json: &str, cb: Option<ResponseStringStringCB>) -> ErrorCode {
let issuer_did = c_str!(issuer_did);
let schema_json = c_str!(schema_json);
let tag = c_str!(tag);
let signature_type_str = opt_c_str!(signature_type);
let config_json = c_str!(config_json);
ErrorCode::from(unsafe {
anoncreds::indy_issuer_create_and_store_credential_def(command_handle, wallet_handle, issuer_did.as_ptr(), schema_json.as_ptr(), tag.as_ptr(), opt_c_ptr!(signature_type, signature_type_str), config_json.as_ptr(), cb)
})
}
pub fn issuer_create_and_store_revoc_reg(wallet_handle: IndyHandle, issuer_did: &str, revoc_def_type: Option<&str>, tag: &str, cred_def_id: &str, config_json: &str, tails_writer_handle: IndyHandle) -> Box<Future<Item=(String, String, String), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string_string_string();
let err = _issuer_create_and_store_revoc_reg(command_handle, wallet_handle, issuer_did, revoc_def_type, tag, cred_def_id, config_json, tails_writer_handle, cb);
ResultHandler::str_str_str(command_handle, err, receiver)
}
fn _issuer_create_and_store_revoc_reg(command_handle: IndyHandle, wallet_handle: IndyHandle, issuer_did: &str, revoc_def_type: Option<&str>, tag: &str, cred_def_id: &str, config_json: &str, tails_writer_handle: IndyHandle, cb: Option<ResponseStringStringStringCB>) -> ErrorCode {
let issuer_did = c_str!(issuer_did);
let revoc_def_type_str = opt_c_str!(revoc_def_type);
let tag = c_str!(tag);
let cred_def_id = c_str!(cred_def_id);
let config_json = c_str!(config_json);
ErrorCode::from(unsafe {
anoncreds::indy_issuer_create_and_store_revoc_reg(command_handle, wallet_handle, issuer_did.as_ptr(), opt_c_ptr!(revoc_def_type, revoc_def_type_str), tag.as_ptr(), cred_def_id.as_ptr(), config_json.as_ptr(), tails_writer_handle, cb)
})
}
pub fn issuer_create_credential_offer(wallet_handle: IndyHandle, cred_def_id: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _issuer_create_credential_offer(command_handle, wallet_handle, cred_def_id, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _issuer_create_credential_offer(command_handle: IndyHandle, wallet_handle: IndyHandle, cred_def_id: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let cred_def_id = c_str!(cred_def_id);
ErrorCode::from(unsafe {
anoncreds::indy_issuer_create_credential_offer(command_handle, wallet_handle, cred_def_id.as_ptr(), cb)
})
}
pub fn issuer_create_credential(wallet_handle: IndyHandle, cred_offer_json: &str, cred_req_json: &str, cred_values_json: &str, rev_reg_id: Option<&str>, blob_storage_reader_handle: IndyHandle) -> Box<Future<Item=(String, Option<String>, Option<String>), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string_opt_string_opt_string();
let err = _issuer_create_credential(command_handle, wallet_handle, cred_offer_json, cred_req_json, cred_values_json, rev_reg_id, blob_storage_reader_handle, cb);
ResultHandler::str_optstr_optstr(command_handle, err, receiver)
}
fn _issuer_create_credential(command_handle: IndyHandle, wallet_handle: IndyHandle, cred_offer_json: &str, cred_req_json: &str, cred_values_json: &str, rev_reg_id: Option<&str>, blob_storage_reader_handle: IndyHandle, cb: Option<ResponseStringStringStringCB>) -> ErrorCode {
let cred_offer_json = c_str!(cred_offer_json);
let cred_req_json = c_str!(cred_req_json);
let cred_values_json = c_str!(cred_values_json);
let rev_reg_id_str = opt_c_str!(rev_reg_id);
ErrorCode::from(unsafe {
anoncreds::indy_issuer_create_credential(command_handle, wallet_handle, cred_offer_json.as_ptr(), cred_req_json.as_ptr(), cred_values_json.as_ptr(), opt_c_ptr!(rev_reg_id, rev_reg_id_str), blob_storage_reader_handle, cb)
})
}
pub fn issuer_revoke_credential(wallet_handle: IndyHandle, blob_storage_reader_cfg_handle: IndyHandle, rev_reg_id: &str, cred_revoc_id: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _issuer_revoke_credential(command_handle, wallet_handle, blob_storage_reader_cfg_handle, rev_reg_id, cred_revoc_id, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _issuer_revoke_credential(command_handle: IndyHandle, wallet_handle: IndyHandle, blob_storage_reader_cfg_handle: IndyHandle, rev_reg_id: &str, cred_revoc_id: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let rev_reg_id = c_str!(rev_reg_id);
let cred_revoc_id = c_str!(cred_revoc_id);
ErrorCode::from(unsafe {
anoncreds::indy_issuer_revoke_credential(command_handle, wallet_handle, blob_storage_reader_cfg_handle, rev_reg_id.as_ptr(), cred_revoc_id.as_ptr(), cb)
})
}
pub fn issuer_merge_revocation_registry_deltas(rev_reg_delta_json: &str, other_rev_reg_delta_json: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _issuer_merge_revocation_registry_deltas(command_handle, rev_reg_delta_json, other_rev_reg_delta_json, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _issuer_merge_revocation_registry_deltas(command_handle: IndyHandle, rev_reg_delta_json: &str, other_rev_reg_delta_json: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let rev_reg_delta_json = c_str!(rev_reg_delta_json);
let other_rev_reg_delta_json = c_str!(other_rev_reg_delta_json);
ErrorCode::from(unsafe {
anoncreds::indy_issuer_merge_revocation_registry_deltas(command_handle, rev_reg_delta_json.as_ptr(), other_rev_reg_delta_json.as_ptr(), cb)
})
}
pub fn prover_create_master_secret(wallet_handle: IndyHandle, master_secret_id: Option<&str>) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _prover_create_master_secret(command_handle, wallet_handle, master_secret_id, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _prover_create_master_secret(command_handle: IndyHandle, wallet_handle: IndyHandle, master_secret_id: Option<&str>, cb: Option<ResponseStringCB>) -> ErrorCode {
let master_secret_id_str = opt_c_str!(master_secret_id);
ErrorCode::from(unsafe {
anoncreds::indy_prover_create_master_secret(command_handle, wallet_handle, opt_c_ptr!(master_secret_id, master_secret_id_str), cb)
})
}
pub fn prover_get_credential(wallet_handle: IndyHandle, cred_id: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _prover_get_credential(command_handle, wallet_handle, cred_id, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _prover_get_credential(command_handle: IndyHandle, wallet_handle: IndyHandle, cred_id: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let cred_id = c_str!(cred_id);
ErrorCode::from(unsafe {
anoncreds::indy_prover_get_credential(command_handle, wallet_handle, cred_id.as_ptr(), cb)
})
}
pub fn prover_create_credential_req(wallet_handle: IndyHandle, prover_did: &str, cred_offer_json: &str, cred_def_json: &str, master_secret_id: &str) -> Box<Future<Item=(String, String), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string_string();
let err = _prover_create_credential_req(command_handle, wallet_handle, prover_did, cred_offer_json, cred_def_json, master_secret_id, cb);
ResultHandler::str_str(command_handle, err, receiver)
}
fn _prover_create_credential_req(command_handle: IndyHandle, wallet_handle: IndyHandle, prover_did: &str, cred_offer_json: &str, cred_def_json: &str, master_secret_id: &str, cb: Option<ResponseStringStringCB>) -> ErrorCode {
let prover_did = c_str!(prover_did);
let cred_offer_json = c_str!(cred_offer_json);
let cred_def_json = c_str!(cred_def_json);
let master_secret_id = c_str!(master_secret_id);
ErrorCode::from(unsafe {
anoncreds::indy_prover_create_credential_req(command_handle, wallet_handle, prover_did.as_ptr(), cred_offer_json.as_ptr(), cred_def_json.as_ptr(), master_secret_id.as_ptr(), cb)
})
}
pub fn prover_store_credential(wallet_handle: IndyHandle, cred_id: Option<&str>, cred_req_metadata_json: &str, cred_json: &str, cred_def_json: &str, rev_reg_def_json: Option<&str>) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _prover_store_credential(command_handle, wallet_handle, cred_id, cred_req_metadata_json, cred_json, cred_def_json, rev_reg_def_json, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _prover_store_credential(command_handle: IndyHandle, wallet_handle: IndyHandle, cred_id: Option<&str>, cred_req_metadata_json: &str, cred_json: &str, cred_def_json: &str, rev_reg_def_json: Option<&str>, cb: Option<ResponseStringCB>) -> ErrorCode {
let cred_id_str = opt_c_str!(cred_id);
let cred_req_metadata_json = c_str!(cred_req_metadata_json);
let cred_json = c_str!(cred_json);
let cred_def_json = c_str!(cred_def_json);
let rev_reg_def_json_str = opt_c_str!(rev_reg_def_json);
ErrorCode::from(unsafe {
anoncreds::indy_prover_store_credential(command_handle, wallet_handle, opt_c_ptr!(cred_id, cred_id_str), cred_req_metadata_json.as_ptr(), cred_json.as_ptr(), cred_def_json.as_ptr(), opt_c_ptr!(rev_reg_def_json, rev_reg_def_json_str), cb)
})
}
pub fn prover_get_credentials(wallet_handle: IndyHandle, filter_json: Option<&str>) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _prover_get_credentials(command_handle, wallet_handle, filter_json, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _prover_get_credentials(command_handle: IndyHandle, wallet_handle: IndyHandle, filter_json: Option<&str>, cb: Option<ResponseStringCB>) -> ErrorCode {
let filter_json_str = opt_c_str!(filter_json);
ErrorCode::from(unsafe {
anoncreds::indy_prover_get_credentials(command_handle, wallet_handle, opt_c_ptr!(filter_json, filter_json_str), cb)
})
}
pub fn prover_search_credentials(wallet_handle: IndyHandle, query_json: Option<&str>) -> Box<Future<Item=(IndyHandle, usize), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_handle_usize();
let err = _prover_search_credentials(command_handle, wallet_handle, query_json, cb);
ResultHandler::handle_usize(command_handle, err, receiver)
}
fn _prover_search_credentials(command_handle: IndyHandle, wallet_handle: IndyHandle, query_json: Option<&str>, cb: Option<ResponseI32UsizeCB>) -> ErrorCode {
let query_json_str = opt_c_str!(query_json);
ErrorCode::from(unsafe {
anoncreds::indy_prover_search_credentials(command_handle, wallet_handle, opt_c_ptr!(query_json, query_json_str), cb)
})
}
pub fn prover_fetch_credentials(search_handle: IndyHandle, count: usize) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _prover_fetch_credentials(command_handle, search_handle, count, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _prover_fetch_credentials(command_handle: IndyHandle, search_handle: IndyHandle, count: usize, cb: Option<ResponseStringCB>) -> ErrorCode {
ErrorCode::from(unsafe {
anoncreds::indy_prover_fetch_credentials(command_handle, search_handle, count, cb)
})
}
pub fn prover_close_credentials_search(search_handle: IndyHandle) -> Box<Future<Item=(), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec();
let err = _prover_close_credentials_search(command_handle, search_handle, cb);
ResultHandler::empty(command_handle, err, receiver)
}
fn _prover_close_credentials_search(command_handle: IndyHandle, search_handle: IndyHandle, cb: Option<ResponseEmptyCB>) -> ErrorCode {
ErrorCode::from(unsafe {
anoncreds::indy_prover_close_credentials_search(command_handle, search_handle, cb)
})
}
pub fn prover_get_credentials_for_proof_req(wallet_handle: IndyHandle, proof_request_json: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _prover_get_credentials_for_proof_req(command_handle, wallet_handle, proof_request_json, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _prover_get_credentials_for_proof_req(command_handle: IndyHandle, wallet_handle: IndyHandle, proof_request_json: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let proof_request_json = c_str!(proof_request_json);
ErrorCode::from(unsafe {
anoncreds::indy_prover_get_credentials_for_proof_req(command_handle, wallet_handle, proof_request_json.as_ptr(), cb)
})
}
pub fn prover_search_credentials_for_proof_req(wallet_handle: IndyHandle, proof_request_json: &str, extra_query_json: Option<&str>) -> Box<Future<Item=IndyHandle, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_handle();
let err = _prover_search_credentials_for_proof_req(command_handle, wallet_handle, proof_request_json, extra_query_json, cb);
ResultHandler::handle(command_handle, err, receiver)
}
fn _prover_search_credentials_for_proof_req(command_handle: IndyHandle, wallet_handle: IndyHandle, proof_request_json: &str, extra_query_json: Option<&str>, cb: Option<ResponseI32CB>) -> ErrorCode {
let proof_request_json = c_str!(proof_request_json);
let extra_query_json_str = opt_c_str!(extra_query_json);
ErrorCode::from(unsafe {
anoncreds::indy_prover_search_credentials_for_proof_req(command_handle, wallet_handle, proof_request_json.as_ptr(), opt_c_ptr!(extra_query_json, extra_query_json_str), cb)
})
}
pub fn prover_fetch_credentials_for_proof_req(search_handle: IndyHandle, item_referent: &str, count: usize) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _prover_fetch_credentials_for_proof_req(command_handle, search_handle, item_referent, count, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _prover_fetch_credentials_for_proof_req(command_handle: IndyHandle, search_handle: IndyHandle, item_referent: &str, count: usize, cb: Option<ResponseStringCB>) -> ErrorCode {
let item_referent = c_str!(item_referent);
ErrorCode::from(unsafe {
anoncreds::indy_prover_fetch_credentials_for_proof_req(command_handle, search_handle, item_referent.as_ptr(), count, cb)
})
}
pub fn prover_close_credentials_search_for_proof_req(search_handle: IndyHandle) -> Box<Future<Item=(), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec();
let err = _prover_close_credentials_search_for_proof_req(command_handle, search_handle, cb);
ResultHandler::empty(command_handle, err, receiver)
}
fn _prover_close_credentials_search_for_proof_req(command_handle: IndyHandle, search_handle: IndyHandle, cb: Option<ResponseEmptyCB>) -> ErrorCode {
ErrorCode::from(unsafe {
anoncreds::indy_prover_close_credentials_search_for_proof_req(command_handle, search_handle, cb)
})
}
pub fn prover_create_proof(wallet_handle: IndyHandle, proof_req_json: &str, requested_credentials_json: &str, master_secret_id: &str, schemas_json: &str, credential_defs_json: &str, rev_states_json: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _prover_create_proof(command_handle, wallet_handle, proof_req_json, requested_credentials_json, master_secret_id, schemas_json, credential_defs_json, rev_states_json, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _prover_create_proof(command_handle: IndyHandle, wallet_handle: IndyHandle, proof_req_json: &str, requested_credentials_json: &str, master_secret_id: &str, schemas_json: &str, credential_defs_json: &str, rev_states_json: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let proof_req_json = c_str!(proof_req_json);
let requested_credentials_json = c_str!(requested_credentials_json);
let master_secret_id = c_str!(master_secret_id);
let schemas_json = c_str!(schemas_json);
let credential_defs_json = c_str!(credential_defs_json);
let rev_states_json = c_str!(rev_states_json);
ErrorCode::from(unsafe {
anoncreds::indy_prover_create_proof(command_handle, wallet_handle, proof_req_json.as_ptr(), requested_credentials_json.as_ptr(), master_secret_id.as_ptr(), schemas_json.as_ptr(), credential_defs_json.as_ptr(), rev_states_json.as_ptr(), cb)
})
}
pub fn 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) -> Box<Future<Item=bool, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_bool();
let err = _verifier_verify_proof(command_handle, proof_request_json, proof_json, schemas_json, credential_defs_json, rev_reg_defs_json, rev_regs_json, cb);
ResultHandler::bool(command_handle, err, receiver)
}
fn _verifier_verify_proof(command_handle: IndyHandle, proof_request_json: &str, proof_json: &str, schemas_json: &str, credential_defs_json: &str, rev_reg_defs_json: &str, rev_regs_json: &str, cb: Option<ResponseBoolCB>) -> ErrorCode {
let proof_request_json = c_str!(proof_request_json);
let proof_json = c_str!(proof_json);
let schemas_json = c_str!(schemas_json);
let credential_defs_json = c_str!(credential_defs_json);
let rev_reg_defs_json = c_str!(rev_reg_defs_json);
let rev_regs_json = c_str!(rev_regs_json);
ErrorCode::from(unsafe {
anoncreds::indy_verifier_verify_proof(command_handle, proof_request_json.as_ptr(), proof_json.as_ptr(), schemas_json.as_ptr(), credential_defs_json.as_ptr(), rev_reg_defs_json.as_ptr(), rev_regs_json.as_ptr(), cb)
})
}
pub fn create_revocation_state(blob_storage_reader_handle: IndyHandle, rev_reg_def_json: &str, rev_reg_delta_json: &str, timestamp: u64, cred_rev_id: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _create_revocation_state(command_handle, blob_storage_reader_handle, rev_reg_def_json, rev_reg_delta_json, timestamp, cred_rev_id, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _create_revocation_state(command_handle: IndyHandle, blob_storage_reader_handle: IndyHandle, rev_reg_def_json: &str, rev_reg_delta_json: &str, timestamp: u64, cred_rev_id: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let rev_reg_def_json = c_str!(rev_reg_def_json);
let rev_reg_delta_json = c_str!(rev_reg_delta_json);
let cred_rev_id = c_str!(cred_rev_id);
ErrorCode::from(unsafe {
anoncreds::indy_create_revocation_state(command_handle, blob_storage_reader_handle, rev_reg_def_json.as_ptr(), rev_reg_delta_json.as_ptr(), timestamp, cred_rev_id.as_ptr(), cb)
})
}
pub fn update_revocation_state(blob_storage_reader_handle: IndyHandle, rev_state_json: &str, rev_reg_def_json: &str, rev_reg_delta_json: &str, timestamp: u64, cred_rev_id: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _update_revocation_state(command_handle, blob_storage_reader_handle, rev_state_json, rev_reg_def_json, rev_reg_delta_json, timestamp, cred_rev_id, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _update_revocation_state(command_handle: IndyHandle, blob_storage_reader_handle: IndyHandle, rev_state_json: &str, rev_reg_def_json: &str, rev_reg_delta_json: &str, timestamp: u64, cred_rev_id: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let rev_state_json = c_str!(rev_state_json);
let rev_reg_def_json = c_str!(rev_reg_def_json);
let rev_reg_delta_json = c_str!(rev_reg_delta_json);
let cred_rev_id = c_str!(cred_rev_id);
ErrorCode::from(unsafe {
anoncreds::indy_update_revocation_state(command_handle, blob_storage_reader_handle, rev_state_json.as_ptr(), rev_reg_def_json.as_ptr(), rev_reg_delta_json.as_ptr(), timestamp, cred_rev_id.as_ptr(), cb)
})
}