Struct OfflineClient

Source

pub struct OfflineClient<B, W, S, K> {
    pub name: String,
    /* private fields */
}

Expand description

A client to interact with Ark Server

§Example


struct MyBlockchain {}

struct MyWallet {}

struct InMemoryDb {}
// Initialize the client with a static keypair
async fn init_client_with_keypair() -> Result<Client<MyBlockchain, MyWallet, InMemorySwapStorage, ark_client::StaticKeyProvider>, ark_client::Error> {
    // Create a keypair for signing transactions
    let secp = bitcoin::key::Secp256k1::new();
    let secret_key = SecretKey::from_str("your_private_key_here").unwrap();
    let keypair = Keypair::from_secret_key(&secp, &secret_key);

    // Initialize blockchain and wallet implementations
    let blockchain = Arc::new(MyBlockchain::new("https://esplora.example.com"));
    let wallet = Arc::new(MyWallet {});
    let timeout = Duration::from_secs(30);

    // Create the offline client (backward compatible method)
    let offline_client = OfflineClient::<MyBlockchain, MyWallet, InMemorySwapStorage, StaticKeyProvider>::new_with_keypair(
        "my-ark-client".to_string(),
        keypair,
        blockchain,
        wallet,
        "https://ark-server.example.com".to_string(),
        Arc::new(InMemorySwapStorage::default()),
        "http://boltz.example.com".to_string(),
        timeout
    );

    // Connect to the Ark server and get server info
    let client = offline_client.connect().await?;

    Ok(client)
}

// Initialize the client with a BIP32 HD wallet
async fn init_client_with_bip32() -> Result<Client<MyBlockchain, MyWallet, InMemorySwapStorage, ark_client::Bip32KeyProvider>, ark_client::Error> {
    // Create a BIP32 master key and derivation path
    let master_key = Xpriv::from_str("xprv...").unwrap();
    let derivation_path = DerivationPath::from_str("m/84'/0'/0'/0/0").unwrap();

    let key_provider = Arc::new(ark_client::Bip32KeyProvider::new(master_key, derivation_path));

    // Initialize blockchain and wallet implementations
    let blockchain = Arc::new(MyBlockchain::new("https://esplora.example.com"));
    let wallet = Arc::new(MyWallet {});
    let timeout = Duration::from_secs(30);

    // Create the offline client with BIP32 key provider
    let offline_client = OfflineClient::new(
        "my-ark-client".to_string(),
        key_provider,
        blockchain,
        wallet,
        "https://ark-server.example.com".to_string(),
        Arc::new(InMemorySwapStorage::default()),
        "http://boltz.example.com".to_string(),
        timeout
    );

    // Connect to the Ark server and get server info
    let client = offline_client.connect().await?;

    Ok(client)
}

Fields§

§name: String

Implementations§

Source §

impl<B, W, S, K> OfflineClient<B, W, S, K>
where B: Blockchain, W: BoardingWallet + OnchainWallet, S: SwapStorage + 'static, K: KeyProvider,

Source

pub fn new( name: String, key_provider: Arc<K>, blockchain: Arc, wallet: Arc<W>, ark_server_url: String, swap_storage: Arc<S>, boltz_url: String, timeout: Duration, ) -> Self

Create a new offline client with a generic key provider

§Arguments

name - Client identifier
key_provider - Implementation of KeyProvider trait (StaticKeyProvider, Bip32KeyProvider, etc.)
blockchain - Blockchain interface implementation
wallet - Wallet implementation
ark_server_url - URL of the Ark server
swap_storage - Storage implementation for swap data
boltz_url - URL of the Boltz server
timeout - Timeout duration for network operations