use {ErrorCode, IndyHandle, IndyError};
use std::ffi::CString;
use std::ptr::null;
use futures::Future;
use ffi::ledger;
use ffi::{ResponseStringCB,
ResponseStringStringCB,
ResponseStringStringU64CB};
use utils::callbacks::{ClosureHandler, ResultHandler};
pub fn sign_and_submit_request(pool_handle: IndyHandle, wallet_handle: IndyHandle, submitter_did: &str, request_json: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _sign_and_submit_request(command_handle, pool_handle, wallet_handle, submitter_did, request_json, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _sign_and_submit_request(command_handle: IndyHandle, pool_handle: IndyHandle, wallet_handle: IndyHandle, submitter_did: &str, request_json: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did = c_str!(submitter_did);
let request_json = c_str!(request_json);
ErrorCode::from(unsafe {
ledger::indy_sign_and_submit_request(command_handle,
pool_handle,
wallet_handle,
submitter_did.as_ptr(),
request_json.as_ptr(),
cb)
})
}
pub fn submit_request(pool_handle: IndyHandle, request_json: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _submit_request(command_handle, pool_handle, request_json, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _submit_request(command_handle: IndyHandle, pool_handle: IndyHandle, request_json: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let request_json = c_str!(request_json);
ErrorCode::from(unsafe { ledger::indy_submit_request(command_handle, pool_handle, request_json.as_ptr(), cb) })
}
pub fn submit_action(pool_handle: IndyHandle, request_json: &str, nodes: Option<&str>, wait_timeout: Option<i32>) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _submit_action(command_handle, pool_handle, request_json, nodes, wait_timeout, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _submit_action(command_handle: IndyHandle, pool_handle: IndyHandle, request_json: &str, nodes: Option<&str>, wait_timeout: Option<i32>, cb: Option<ResponseStringCB>) -> ErrorCode {
let request_json = c_str!(request_json);
let nodes_str = opt_c_str!(nodes);
ErrorCode::from(unsafe {
ledger::indy_submit_action(command_handle, pool_handle, request_json.as_ptr(), opt_c_ptr!(nodes, nodes_str), wait_timeout.unwrap_or(-1), cb)
})
}
pub fn sign_request(wallet_handle: IndyHandle, submitter_did: &str, request_json: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _sign_request(command_handle, wallet_handle, submitter_did, request_json, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _sign_request(command_handle: IndyHandle, wallet_handle: IndyHandle, submitter_did: &str, request_json: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did = c_str!(submitter_did);
let request_json = c_str!(request_json);
ErrorCode::from(unsafe { ledger::indy_sign_request(command_handle, wallet_handle, submitter_did.as_ptr(), request_json.as_ptr(), cb) })
}
pub fn multi_sign_request(wallet_handle: IndyHandle, submitter_did: &str, request_json: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _multi_sign_request(command_handle, wallet_handle, submitter_did, request_json, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _multi_sign_request(command_handle: IndyHandle, wallet_handle: IndyHandle, submitter_did: &str, request_json: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did = c_str!(submitter_did);
let request_json = c_str!(request_json);
ErrorCode::from(unsafe { ledger::indy_multi_sign_request(command_handle, wallet_handle, submitter_did.as_ptr(), request_json.as_ptr(), cb) })
}
pub fn build_get_ddo_request(submitter_did: Option<&str>, target_did: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_get_ddo_request(command_handle, submitter_did, target_did, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_get_ddo_request(command_handle: IndyHandle, submitter_did: Option<&str>, target_did: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did_str = opt_c_str!(submitter_did);
let target_did = c_str!(target_did);
ErrorCode::from(unsafe { ledger::indy_build_get_ddo_request(command_handle, opt_c_ptr!(submitter_did, submitter_did_str), target_did.as_ptr(), cb) })
}
pub fn build_nym_request(submitter_did: &str, target_did: &str, verkey: Option<&str>, data: Option<&str>, role: Option<&str>) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_nym_request(command_handle, submitter_did, target_did, verkey, data, role, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_nym_request(command_handle: IndyHandle,
submitter_did: &str,
target_did: &str,
verkey: Option<&str>,
data: Option<&str>,
role: Option<&str>,
cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did = c_str!(submitter_did);
let target_did = c_str!(target_did);
let verkey_str = opt_c_str!(verkey);
let data_str = opt_c_str!(data);
let role_str = opt_c_str!(role);
ErrorCode::from(unsafe {
ledger::indy_build_nym_request(command_handle,
submitter_did.as_ptr(),
target_did.as_ptr(),
opt_c_ptr!(verkey, verkey_str),
opt_c_ptr!(data, data_str),
opt_c_ptr!(role, role_str),
cb)
})
}
pub fn build_get_nym_request(submitter_did: Option<&str>, target_did: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_get_nym_request(command_handle, submitter_did, target_did, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_get_nym_request(command_handle: IndyHandle, submitter_did: Option<&str>, target_did: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did_str = opt_c_str!(submitter_did);
let target_did = c_str!(target_did);
ErrorCode::from(unsafe { ledger::indy_build_get_nym_request(command_handle, opt_c_ptr!(submitter_did, submitter_did_str), target_did.as_ptr(), cb) })
}
pub fn build_get_txn_request(submitter_did: Option<&str>, ledger_type: Option<&str>, seq_no: i32) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_get_txn_request(command_handle, submitter_did, ledger_type, seq_no, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_get_txn_request(command_handle: IndyHandle, submitter_did: Option<&str>, ledger_type: Option<&str>, seq_no: i32, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did_str = opt_c_str!(submitter_did);
let ledger_type_str = opt_c_str!(ledger_type);
ErrorCode::from(unsafe { ledger::indy_build_get_txn_request(command_handle, opt_c_ptr!(submitter_did, submitter_did_str), opt_c_ptr!(ledger_type, ledger_type_str), seq_no, cb) })
}
pub fn build_attrib_request(submitter_did: &str, target_did: &str, hash: Option<&str>, raw: Option<&str>, enc: Option<&str>) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_attrib_request(command_handle, submitter_did, target_did, hash, raw, enc, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_attrib_request(command_handle: IndyHandle, submitter_did: &str, target_did: &str, hash: Option<&str>, raw: Option<&str>, enc: Option<&str>, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did = c_str!(submitter_did);
let target_did = c_str!(target_did);
let hash_str = opt_c_str!(hash);
let raw_str = opt_c_str!(raw);
let enc_str = opt_c_str!(enc);
ErrorCode::from(unsafe {
ledger::indy_build_attrib_request(command_handle,
submitter_did.as_ptr(),
target_did.as_ptr(),
opt_c_ptr!(hash, hash_str),
opt_c_ptr!(raw, raw_str),
opt_c_ptr!(enc, enc_str),
cb)
})
}
pub fn build_get_attrib_request(submitter_did: Option<&str>, target_did: &str, raw: Option<&str>, hash: Option<&str>, enc: Option<&str>) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_get_attrib_request(command_handle, submitter_did, target_did, raw, hash, enc, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_get_attrib_request(command_handle: IndyHandle, submitter_did: Option<&str>, target_did: &str, raw: Option<&str>, hash: Option<&str>, enc: Option<&str>, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did_str = opt_c_str!(submitter_did);
let target_did = c_str!(target_did);
let raw_str = opt_c_str!(raw);
let hash_str = opt_c_str!(hash);
let enc_str = opt_c_str!(enc);
ErrorCode::from(unsafe {
ledger::indy_build_get_attrib_request(command_handle,
opt_c_ptr!(submitter_did, submitter_did_str),
target_did.as_ptr(),
opt_c_ptr!(raw, raw_str),
opt_c_ptr!(hash, hash_str),
opt_c_ptr!(enc, enc_str),
cb)
})
}
pub fn build_schema_request(submitter_did: &str, data: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_schema_request(command_handle, submitter_did, data, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_schema_request(command_handle: IndyHandle, submitter_did: &str, data: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did = c_str!(submitter_did);
let data = c_str!(data);
ErrorCode::from(unsafe { ledger::indy_build_schema_request(command_handle, submitter_did.as_ptr(), data.as_ptr(), cb) })
}
pub fn build_get_schema_request(submitter_did: Option<&str>, id: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_get_schema_request(command_handle, submitter_did, id, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_get_schema_request(command_handle: IndyHandle, submitter_did: Option<&str>, id: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did_str = opt_c_str!(submitter_did);
let id = c_str!(id);
ErrorCode::from(unsafe { ledger::indy_build_get_schema_request(command_handle, opt_c_ptr!(submitter_did, submitter_did_str), id.as_ptr(), cb) })
}
pub fn parse_get_schema_response(get_schema_response: &str) -> Box<Future<Item=(String, String), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string_string();
let err = _parse_get_schema_response(command_handle, get_schema_response, cb);
ResultHandler::str_str(command_handle, err, receiver)
}
fn _parse_get_schema_response(command_handle: IndyHandle, get_schema_response: &str, cb: Option<ResponseStringStringCB>) -> ErrorCode {
let get_schema_response = c_str!(get_schema_response);
ErrorCode::from(unsafe { ledger::indy_parse_get_schema_response(command_handle, get_schema_response.as_ptr(), cb) })
}
pub fn build_cred_def_request(submitter_did: &str, data: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_cred_def_request(command_handle, submitter_did, data, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_cred_def_request(command_handle: IndyHandle, submitter_did: &str, data: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did = c_str!(submitter_did);
let data = c_str!(data);
ErrorCode::from(unsafe { ledger::indy_build_cred_def_request(command_handle, submitter_did.as_ptr(), data.as_ptr(), cb) })
}
pub fn build_get_cred_def_request(submitter_did: Option<&str>, id: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_get_cred_def_request(command_handle, submitter_did, id, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_get_cred_def_request(command_handle: IndyHandle, submitter_did: Option<&str>, id: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did_str = opt_c_str!(submitter_did);
let id = c_str!(id);
ErrorCode::from(unsafe { ledger::indy_build_get_cred_def_request(command_handle, opt_c_ptr!(submitter_did, submitter_did_str), id.as_ptr(), cb) })
}
pub fn parse_get_cred_def_response(get_cred_def_response: &str) -> Box<Future<Item=(String, String), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string_string();
let err = _parse_get_cred_def_response(command_handle, get_cred_def_response, cb);
ResultHandler::str_str(command_handle, err, receiver)
}
fn _parse_get_cred_def_response(command_handle: IndyHandle, get_cred_def_response: &str, cb: Option<ResponseStringStringCB>) -> ErrorCode {
let get_cred_def_response = c_str!(get_cred_def_response);
ErrorCode::from(unsafe { ledger::indy_parse_get_cred_def_response(command_handle, get_cred_def_response.as_ptr(), cb) })
}
pub fn build_node_request(submitter_did: &str, target_did: &str, data: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_node_request(command_handle, submitter_did, target_did, data, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_node_request(command_handle: IndyHandle, submitter_did: &str, target_did: &str, data: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did = c_str!(submitter_did);
let target_did = c_str!(target_did);
let data = c_str!(data);
ErrorCode::from(unsafe { ledger::indy_build_node_request(command_handle, submitter_did.as_ptr(), target_did.as_ptr(), data.as_ptr(), cb) })
}
pub fn build_get_validator_info_request(submitter_did: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_get_validator_info_request(command_handle, submitter_did, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_get_validator_info_request(command_handle: IndyHandle, submitter_did: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did = c_str!(submitter_did);
ErrorCode::from(unsafe {
ledger::indy_build_get_validator_info_request(command_handle, submitter_did.as_ptr(), cb)
})
}
pub fn build_pool_config_request(submitter_did: &str, writes: bool, force: bool) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_pool_config_request(command_handle, submitter_did, writes, force, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_pool_config_request(command_handle: IndyHandle, submitter_did: &str, writes: bool, force: bool, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did = c_str!(submitter_did);
ErrorCode::from(unsafe { ledger::indy_build_pool_config_request(command_handle, submitter_did.as_ptr(), writes, force, cb) })
}
pub fn build_pool_restart_request(submitter_did: &str, action: &str, datetime: Option<&str>) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_pool_restart_request(command_handle, submitter_did, action, datetime, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_pool_restart_request(command_handle: IndyHandle, submitter_did: &str, action: &str, datetime: Option<&str>, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did = c_str!(submitter_did);
let action = c_str!(action);
let datetime_str = opt_c_str!(datetime);
ErrorCode::from(unsafe {
ledger::indy_build_pool_restart_request(command_handle,
submitter_did.as_ptr(),
action.as_ptr(),
opt_c_ptr!(datetime, datetime_str),
cb)
})
}
pub fn build_pool_upgrade_request(submitter_did: &str,
name: &str,
version: &str,
action: &str,
sha256: &str,
upgrade_timeout: Option<u32>,
schedule: Option<&str>,
justification: Option<&str>,
reinstall: bool,
force: bool,
package: Option<&str>) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_pool_upgrade_request(command_handle, submitter_did, name, version, action, sha256, upgrade_timeout, schedule, justification, reinstall, force, package, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_pool_upgrade_request(command_handle: IndyHandle,
submitter_did: &str,
name: &str,
version: &str,
action: &str,
sha256: &str,
upgrade_timeout: Option<u32>,
schedule: Option<&str>,
justification: Option<&str>,
reinstall: bool,
force: bool,
package: Option<&str>,
cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did = c_str!(submitter_did);
let name = c_str!(name);
let version = c_str!(version);
let action = c_str!(action);
let sha256 = c_str!(sha256);
let upgrade_timeout = upgrade_timeout.map(|t| t as i32).unwrap_or(-1);
let schedule_str = opt_c_str!(schedule);
let justification_str = opt_c_str!(justification);
let package_str = opt_c_str!(package);
ErrorCode::from(unsafe {
ledger::indy_build_pool_upgrade_request(command_handle,
submitter_did.as_ptr(),
name.as_ptr(),
version.as_ptr(),
action.as_ptr(),
sha256.as_ptr(),
upgrade_timeout,
opt_c_ptr!(schedule, schedule_str),
opt_c_ptr!(justification, justification_str),
reinstall,
force,
opt_c_ptr!(package, package_str),
cb)
})
}
pub fn build_revoc_reg_def_request(submitter_did: &str, data: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_revoc_reg_def_request(command_handle, submitter_did, data, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_revoc_reg_def_request(command_handle: IndyHandle, submitter_did: &str, data: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did = c_str!(submitter_did);
let data = c_str!(data);
ErrorCode::from(unsafe { ledger::indy_build_revoc_reg_def_request(command_handle, submitter_did.as_ptr(), data.as_ptr(), cb) })
}
pub fn build_get_revoc_reg_def_request(submitter_did: Option<&str>, id: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_get_revoc_reg_def_request(command_handle, submitter_did, id, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_get_revoc_reg_def_request(command_handle: IndyHandle, submitter_did: Option<&str>, id: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did_str = opt_c_str!(submitter_did);
let id = c_str!(id);
ErrorCode::from(unsafe { ledger::indy_build_get_revoc_reg_def_request(command_handle, opt_c_ptr!(submitter_did, submitter_did_str), id.as_ptr(), cb) })
}
pub fn parse_get_revoc_reg_def_response(get_revoc_reg_def_response: &str) -> Box<Future<Item=(String, String), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string_string();
let err = _parse_get_revoc_reg_def_response(command_handle, get_revoc_reg_def_response, cb);
ResultHandler::str_str(command_handle, err, receiver)
}
fn _parse_get_revoc_reg_def_response(command_handle: IndyHandle, get_revoc_reg_def_response: &str, cb: Option<ResponseStringStringCB>) -> ErrorCode {
let get_revoc_reg_def_response = c_str!(get_revoc_reg_def_response);
ErrorCode::from(unsafe { ledger::indy_parse_get_revoc_reg_def_response(command_handle, get_revoc_reg_def_response.as_ptr(), cb) })
}
pub fn build_revoc_reg_entry_request(submitter_did: &str, revoc_reg_def_id: &str, rev_def_type: &str, value: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_revoc_reg_entry_request(command_handle, submitter_did, revoc_reg_def_id, rev_def_type, value, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_revoc_reg_entry_request(command_handle: IndyHandle, submitter_did: &str, revoc_reg_def_id: &str, rev_def_type: &str, value: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did = c_str!(submitter_did);
let revoc_reg_def_id = c_str!(revoc_reg_def_id);
let rev_def_type = c_str!(rev_def_type);
let value = c_str!(value);
ErrorCode::from(unsafe { ledger::indy_build_revoc_reg_entry_request(command_handle, submitter_did.as_ptr(), revoc_reg_def_id.as_ptr(), rev_def_type.as_ptr(), value.as_ptr(), cb) })
}
pub fn build_get_revoc_reg_request(submitter_did: Option<&str>, revoc_reg_def_id: &str, timestamp: i64) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_get_revoc_reg_request(command_handle, submitter_did, revoc_reg_def_id, timestamp, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_get_revoc_reg_request(command_handle: IndyHandle, submitter_did: Option<&str>, revoc_reg_def_id: &str, timestamp: i64, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did_str = opt_c_str!(submitter_did);
let revoc_reg_def_id = c_str!(revoc_reg_def_id);
ErrorCode::from(unsafe { ledger::indy_build_get_revoc_reg_request(command_handle, opt_c_ptr!(submitter_did, submitter_did_str), revoc_reg_def_id.as_ptr(), timestamp, cb) })
}
pub fn parse_get_revoc_reg_response(get_revoc_reg_response: &str) -> Box<Future<Item=(String, String, u64), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string_string_u64();
let err = _parse_get_revoc_reg_response(command_handle, get_revoc_reg_response, cb);
ResultHandler::str_str_u64(command_handle, err, receiver)
}
fn _parse_get_revoc_reg_response(command_handle: IndyHandle, get_revoc_reg_response: &str, cb: Option<ResponseStringStringU64CB>) -> ErrorCode {
let get_revoc_reg_response = c_str!(get_revoc_reg_response);
ErrorCode::from(unsafe { ledger::indy_parse_get_revoc_reg_response(command_handle,get_revoc_reg_response.as_ptr(), cb) })
}
pub fn build_get_revoc_reg_delta_request(submitter_did: Option<&str>, revoc_reg_def_id: &str, from: i64, to: i64) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _build_get_revoc_reg_delta_request(command_handle, submitter_did, revoc_reg_def_id, from, to, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _build_get_revoc_reg_delta_request(command_handle: IndyHandle, submitter_did: Option<&str>, revoc_reg_def_id: &str, from: i64, to: i64, cb: Option<ResponseStringCB>) -> ErrorCode {
let submitter_did_str = opt_c_str!(submitter_did);
let revoc_reg_def_id = c_str!(revoc_reg_def_id);
ErrorCode::from(unsafe { ledger::indy_build_get_revoc_reg_delta_request(command_handle, opt_c_ptr!(submitter_did, submitter_did_str), revoc_reg_def_id.as_ptr(), from, to, cb) })
}
pub fn parse_get_revoc_reg_delta_response(get_revoc_reg_delta_response: &str) -> Box<Future<Item=(String, String, u64), Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string_string_u64();
let err = _parse_get_revoc_reg_delta_response(command_handle, get_revoc_reg_delta_response, cb);
ResultHandler::str_str_u64(command_handle, err, receiver)
}
fn _parse_get_revoc_reg_delta_response(command_handle: IndyHandle, get_revoc_reg_delta_response: &str, cb: Option<ResponseStringStringU64CB>) -> ErrorCode {
let get_revoc_reg_delta_response = c_str!(get_revoc_reg_delta_response);
ErrorCode::from(unsafe { ledger::indy_parse_get_revoc_reg_delta_response(command_handle,get_revoc_reg_delta_response.as_ptr(), cb) })
}
pub fn get_response_metadata(response: &str) -> Box<Future<Item=String, Error=IndyError>> {
let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string();
let err = _get_response_metadata(command_handle, response, cb);
ResultHandler::str(command_handle, err, receiver)
}
fn _get_response_metadata(command_handle: IndyHandle, response: &str, cb: Option<ResponseStringCB>) -> ErrorCode {
let response = c_str!(response);
ErrorCode::from(unsafe { ledger::indy_get_response_metadata(command_handle,response.as_ptr(), cb) })
}