Get started with Rust

Use this prompt to get started quickly.

These examples connect to signet so you can test for free. To go live, point the same configuration at Second’s mainnet endpoints from Connection details and select the mainnet network.

Prerequisites

The latest stable Rust with Cargo
protoc, the Protocol Buffers compiler

Install protoc for your platform:

macOS
Debian and Ubuntu
Windows

brew install protobuf

sudo apt install protobuf-compiler

Download protoc-<version>-win64.zip from the protobuf releases and extract it. Then add its bin folder to your PATH, or set the PROTOC environment variable to the full path of protoc.exe.

Getting started

Install the SDK

In your project directory, run:

cargo add bark-wallet

Then add Tokio and anyhow:

cargo add tokio --features full
cargo add anyhow

Import bitcoin and bip39 types from Bark’s re-exports, bark::ark::bitcoin and bark::bip39, instead of adding those crates.

Create a wallet

Generate a BIP39 mnemonic, configure the signet endpoints, and open the wallet in a data directory. Wallet::open() creates the wallet on the first launch and reopens it on later ones.

src/main.rs

use std::path::PathBuf;

use bark::ark::bitcoin::Network;
use bark::bip39::Mnemonic;
use bark::{Config, OpenWalletArgs, Wallet, WalletSeed};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let network = Network::Signet;

    // Signet tests only: don't store a real mnemonic in an unencrypted file
    let mnemonic_path = PathBuf::from("bark-mnemonic");
    let mnemonic: Mnemonic = if mnemonic_path.exists() {
        let words = tokio::fs::read_to_string(&mnemonic_path).await?;
        words.trim().parse()?
    } else {
        let mnemonic = Mnemonic::generate(12)?;
        tokio::fs::write(&mnemonic_path, mnemonic.to_string()).await?;
        mnemonic
    };

    // Configure the signet endpoints
    let config = Config {
        server_address: "https://ark.signet.2nd.dev".into(),
        esplora_address: Some("https://esplora.signet.2nd.dev".into()),
        ..Config::network_default(network)
    };

    let datadir = PathBuf::from("bark");

    // Create the wallet in datadir, or reopen it on later launches
    let wallet = Wallet::open(
        network,
        WalletSeed::new_from_mnemonic(network, &mnemonic),
        config,
        OpenWalletArgs {
            datadir: Some(datadir),
            ..Default::default()
        },
    )
    .await?;

    Ok(())
}

The sample code stores the mnemonic in an unencrypted file so that the next launch reopens the same wallet. That is acceptable for signet tests only. In a production app, store the mnemonic in your platform’s secure storage. Also set up continuous wallet data backups, so users can restore their wallet without the Ark server’s cooperation.

Get a receiving address

Generate an Ark address to receive bitcoin. Add these lines at the end of main, before Ok(()):

let address = wallet.new_address().await?;
println!("Ark address: {address}");

Run cargo run to print the address. Send some signet sats to this address using the faucet.

Check your balance

Bark syncs the wallet in the background while it’s open. Call sync() when you need an up-to-date balance right away.Add these lines after the address lines, before Ok(()):

wallet.sync().await;

let balance = wallet.balance().await?;
println!("Spendable: {} sats", balance.spendable.to_sat());

Balance amounts are Amount values from bark::ark::bitcoin.Run cargo run again. The program reopens the same wallet and prints your spendable balance in sats.

Documentation

Bark SDK

Barkd

Run an Ark server

Get started with Rust

Prerequisites

Getting started

Next steps

API reference

How Ark works

​Prerequisites

​Getting started

​Next steps

API reference

How Ark works

Prerequisites

Getting started

Next steps