Get started with Dart

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

Dart SDK 3.10+, or Flutter 3.38.1+
Rust, installed with rustup
protoc, the Protocol Buffers compiler, on your PATH

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.

Getting started

Install the SDK

In your project directory, run:

Dart
Flutter

dart pub add bark_bitcoin

flutter pub add bark_bitcoin path_provider

On Android, give your app internet access in android/app/src/main/AndroidManifest.xml:

<uses-permission android:name="android.permission.INTERNET" />

On macOS, allow outgoing network connections in both macos/Runner/DebugProfile.entitlements and macos/Runner/Release.entitlements:

<key>com.apple.security.network.client</key>
<true/>

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.

Dart
Flutter

Save this program as bin/main.dart:

import 'dart:io';

import 'package:bark_bitcoin/bark_bitcoin.dart';

Future<void> main() async {
  // Signet tests only: don't store a real mnemonic in an unencrypted file
  final mnemonicFile = File('bark-mnemonic');
  final String mnemonic;
  if (mnemonicFile.existsSync()) {
    mnemonic = mnemonicFile.readAsStringSync();
  } else {
    mnemonic = generateMnemonic();
    mnemonicFile.writeAsStringSync(mnemonic);
  }

  // Configure the signet endpoints
  final config = Config(
    serverAddress: 'https://ark.signet.2nd.dev',
    esploraAddress: 'https://esplora.signet.2nd.dev',
  );

  // Create the wallet in datadir, or reopen it on later launches
  final wallet = await Wallet.open(
    network: Network.signet,
    mnemonicOrSeed: mnemonic,
    config: config,
    args: WalletOpenArgs(datadir: 'bark-data'),
  );
}

In lib/main.dart, replace the import line and main() with this code. main() opens the wallet once, before runApp(), and stores it in wallet for all your widgets to use:

import 'dart:io';

import 'package:bark_bitcoin/bark_bitcoin.dart';
import 'package:flutter/material.dart';
import 'package:path_provider/path_provider.dart';

// Opened once in main(), then shared by all your widgets
late final Wallet wallet;

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  wallet = await openWallet();

  runApp(const MyApp());
}

Future<Wallet> openWallet() async {
  final dir = (await getApplicationSupportDirectory()).path;

  // Signet tests only: don't store a real mnemonic in an unencrypted file
  final mnemonicFile = File('$dir/bark-mnemonic');
  final String mnemonic;
  if (mnemonicFile.existsSync()) {
    mnemonic = mnemonicFile.readAsStringSync();
  } else {
    mnemonic = generateMnemonic();
    mnemonicFile.writeAsStringSync(mnemonic);
  }

  // Configure the signet endpoints
  final config = Config(
    serverAddress: 'https://ark.signet.2nd.dev',
    esploraAddress: 'https://esplora.signet.2nd.dev',
  );

  // Create the wallet in datadir, or reopen it on later launches
  return Wallet.open(
    network: Network.signet,
    mnemonicOrSeed: mnemonic,
    config: config,
    args: WalletOpenArgs(datadir: '$dir/bark-data'),
  );
}

On Android, leave the package line of android/app/src/main/kotlin/.../MainActivity.kt and replace the rest with this code:

import android.content.Context
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.embedding.engine.FlutterEngineCache

class MainActivity : FlutterActivity() {
    // Cache one Flutter engine per process, so main() opens the wallet only once
    override fun provideFlutterEngine(context: Context): FlutterEngine =
        FlutterEngineCache.getInstance().get("main")
            ?: FlutterEngine(context.applicationContext).also {
                FlutterEngineCache.getInstance().put("main", it)
            }
}

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() in Dart. In Flutter, add them to main(), after wallet = await openWallet(); and before runApp():

Dart
Flutter

final address = await wallet.newAddress();
print('Ark address: $address');

Run the program from your project directory:

dart run bin/main.dart

final address = await wallet.newAddress();
debugPrint('Ark address: $address');

Start a device or emulator, then run the app from your project directory:

flutter run

The first run compiles Bark’s Rust core, which can take about 15 minutes. Your terminal then shows the Ark 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 previous ones:

Dart
Flutter

await wallet.sync_();

final balance = await wallet.balance();
print('Spendable: ${balance.spendableSats} sats');

Run dart run bin/main.dart again.

await wallet.sync_();

final balance = await wallet.balance();
debugPrint('Spendable: ${balance.spendableSats} sats');

Press q in the flutter run terminal to stop the app, then run flutter run again.In a production app, call sync_() and balance() from a widget after runApp(), so your first screen doesn’t wait for the sync.

Balance amounts are int values.The second run reopens the same wallet and prints your spendable balance in sats.

Documentation

Bark SDK

Barkd

Run an Ark server

Get started with Dart

Prerequisites

Getting started

Next steps

Source code

How Ark works

​Prerequisites

​Getting started

​Next steps

Source code

How Ark works

Prerequisites

Getting started

Next steps