Client Methods

let inbox_id = client.inbox_id();
println!("Inbox ID: {}", inbox_id);

let installation_id = client.installation_public_key();

let identity = client.identity();
if identity.is_ready() {
    println!("Identity is registered");
}

let signature_request = /* obtain signed request */;
client.register_identity(signature_request).await?;

let state = client.inbox_state(true).await?;
for installation in state.installation_ids() {
    println!("Installation: {}", hex::encode(installation));
}

let inbox_ids = vec!["inbox_1", "inbox_2"];
let states = client.inbox_addresses(true, inbox_ids).await?;

let conn = client.db();
let identifier = Identifier::Address("0x...".to_string());
if let Some(inbox_id) = client.find_inbox_id_from_identifier(&conn, identifier).await? {
    println!("Found inbox: {}", inbox_id);
}

let conn = DbConnection::new(client.db());
let sequence_id = client.inbox_sequence_id(&conn)?;

let counts = client.fetch_inbox_updates_count(true, vec!["inbox_1"]).await?;

let count = client.fetch_own_inbox_updates_count(true).await?;
println!("Total updates: {}", count);

if let Some(kind) = client.inbox_creation_signature_kind("inbox_1", true).await? {
    println!("Created with: {:?}", kind);
}

let group = client.create_group(None, None)?;

let members = vec!["inbox_1", "inbox_2"];
let group = client.create_group_with_members(&members, None, None).await?;

let identifiers = vec![
    Identifier::Address("0x123...".to_string()),
    Identifier::Address("0x456...".to_string()),
];
let group = client.create_group_with_identifiers(&identifiers, None, None).await?;

let dm = client.find_or_create_dm("target_inbox_id", None).await?;

let identifier = Identifier::Address("0x...".to_string());
let dm = client.find_or_create_dm_by_identity(identifier, None).await?;

let group = client.group(&group_id)?;

let group = client.stitched_group(&group_id)?;

let dm = client.dm_group_from_target_inbox("target_inbox".to_string())?;

let args = GroupQueryArgs {
    limit: Some(10),
    conversation_type: Some(ConversationType::Group),
    ..Default::default()
};
let groups = client.find_groups(args)?;

let conversations = client.list_conversations(GroupQueryArgs::default())?;
for item in conversations {
    if let Some(msg) = item.last_message {
        println!("Last message: {:?}", msg);
    }
}

let duplicates = client.find_duplicate_dms_for_group(&group_id)?;

if let Some(settings) = client.group_disappearing_settings(&group_id)? {
    println!("Messages disappear after: {} seconds", settings.duration_seconds);
}

let message = client.message(message_id)?;

let decoded = client.message_v2(message_id)?;
println!("Decoded content: {:?}", decoded.content);

let deleted = client.delete_message(message_id)?;
if deleted > 0 {
    println!("Message deleted");
}

let new_groups = client.sync_welcomes().await?;
println!("Joined {} new groups", new_groups.len());

let groups = client.find_groups(GroupQueryArgs::default())?;
let summary = client.sync_all_groups(groups).await?;
println!("Synced {}/{} groups", summary.num_synced, summary.num_eligible);

let summary = client.sync_all_welcomes_and_groups(None).await?;

let summary = client.sync_all_welcomes_and_device_sync_groups().await?;

client.wait_for_sync_worker_init().await;

use xmtp_db::consent_record::{ConsentState, ConsentType, StoredConsentRecord};

let record = StoredConsentRecord {
    entity_type: ConsentType::InboxId,
    entity: "target_inbox".to_string(),
    state: ConsentState::Allowed,
};
client.set_consent_states(&[record]).await?;

let state = client.get_consent_state(
    ConsentType::InboxId,
    "target_inbox".to_string()
).await?;

let identifiers = vec![
    Identifier::Address("0x123...".to_string()),
];
let results = client.can_message(&identifiers).await?;
for (ident, can_msg) in results {
    println!("{}: {}", ident, can_msg);
}

let installation_ids = vec![installation_id_bytes];
let key_packages = client.get_key_packages_for_installation_ids(installation_ids).await?;

let conn = DbConnection::new(client.db());
let inbox_id = client.validate_credential_against_network(
    &conn,
    &credential_bytes,
    installation_key,
).await?;

client.queue_key_rotation().await?;

client.rotate_and_upload_key_package().await?;

let conn = client.db();

client.release_db_connection()?;

client.reconnect_db()?;

let identity_service = client.identity_updates();

let store = client.mls_store();

let verifier = client.scw_verifier();

let version = client.version_info();

let sync_client = client.device_sync_client();

if client.device_sync_worker_enabled() {
    println!("Device sync is active");
}

let stats = client.api_stats();
println!("Total API calls: {}", stats.total());

let stats = client.identity_api_stats();

client.clear_stats();

if let Some(metrics) = client.sync_metrics() {
    println!("Worker metrics: {:?}", metrics);
}