ClientBuilder

pub struct ClientBuilder<ApiClient, S, Db = xmtp_db::DefaultStore> {
    pub(crate) api_client: Option<ApiClient>,
    pub(crate) identity: Option<Identity>,
    pub(crate) store: Option<Db>,
    pub(crate) identity_strategy: IdentityStrategy,
    pub(crate) scw_verifier: Option<Box<dyn SmartContractSignatureVerifier>>,
    pub(crate) device_sync_worker_mode: DeviceSyncMode,
    pub(crate) fork_recovery_opts: Option<ForkRecoveryOpts>,
    pub(crate) version_info: VersionInfo,
    pub(crate) allow_offline: bool,
    pub(crate) disable_commit_log_worker: bool,
    pub(crate) mls_storage: Option<S>,
    pub(crate) sync_api_client: Option<ApiClient>,
    pub(crate) cursor_store: Option<Arc<dyn CursorStore>>,
    pub(crate) disable_workers: bool,
}

let builder = Client::builder(identity_strategy);

let builder = ClientBuilder::<(), ()>::new(identity_strategy);

builder.api_clients(grpc_client.clone(), grpc_client.clone())

let store = EncryptedMessageStore::new(db)?;
builder.store(store)

builder.default_mls_store()?

builder.with_scw_verifier(my_verifier)

builder.with_remote_verifier()?

builder.identity(existing_identity)

builder.device_sync_worker_mode(DeviceSyncMode::Disabled)

builder.with_device_sync_worker_mode(Some(DeviceSyncMode::Enabled))

builder.fork_recovery_opts(ForkRecoveryOpts {
    enable_recovery_requests: ForkRecoveryPolicy::All,
    groups_to_request_recovery: vec![],
    disable_recovery_responses: false,
    worker_interval_ns: None,
})

builder.version(VersionInfo::default())

builder.maybe_version(Some(version_info))

builder.with_allow_offline(Some(true))

builder.with_disable_workers(false)

builder.cursor_store(Arc::new(SqliteCursorStore::new(db)))

builder.enable_api_debug_wrapper()?

builder.enable_api_stats()?

let client = builder.build().await?;

let client = builder.build_offline()?;

pub enum ClientBuilderError {
    AddressValidation(IdentifierValidationError),
    MissingParameter { parameter: &'static str },
    ClientError(crate::client::ClientError),
    StorageError(StorageError),
    Identity(crate::identity::IdentityError),
    WrappedApiError(xmtp_api::ApiError),
    GroupError(Box<crate::groups::GroupError>),
    DeviceSync(Box<crate::worker::device_sync::DeviceSyncError>),
    OfflineBuildFailed,
}

use xmtp_mls::{
    Client, builder::DeviceSyncMode,
    identity::IdentityStrategy,
};
use xmtp_db::{EncryptedMessageStore, NativeDb};
use xmtp_id::associations::Identifier;

// Set up database
let db = NativeDb::builder().persistent("./db.sqlite").build()?;
let store = EncryptedMessageStore::new(db)?;

// Create API clients
let api_client = XmtpApiClient::create(...)?;

// Define identity
let inbox_id = "inbox_123";
let identifier = Identifier::Address("0x...".to_string());
let identity_strategy = IdentityStrategy::new(
    inbox_id.to_string(),
    identifier,
    1, // nonce
    None, // legacy_identity
);

// Build client
let client = Client::builder(identity_strategy)
    .api_clients(api_client.clone(), api_client.clone())
    .store(store)
    .default_mls_store()?
    .with_remote_verifier()?
    .device_sync_worker_mode(DeviceSyncMode::Enabled)
    .enable_api_stats()?
    .build()
    .await?;