Get started with Kotlin

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

Android: API 24+ (Android 7.0), Kotlin 1.9+
JVM: Linux x86-64 with glibc 2.34+, JDK 17+, Kotlin 1.9+

Getting started

Install the SDK

Add the GitLab Maven registry and the Bark dependency to your Gradle project.

Android
JVM

In your root settings.gradle.kts:

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        maven { url = uri("https://gitlab.com/api/v4/projects/78057981/packages/maven") }
    }
}

In your module build.gradle.kts:

dependencies {
    implementation("tech.second.bark:bark-android:0.25.0+bark-0.7.1")
}

In AndroidManifest.xml, give your app internet access:

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

In your build.gradle.kts:

repositories {
    mavenCentral()
    maven { url = uri("https://gitlab.com/api/v4/projects/78057981/packages/maven") }
}

dependencies {
    implementation("tech.second.bark:bark-jvm:0.25.0+bark-0.7.1")
    // Provides runBlocking for the sample program
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.1")
}

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.

Android
JVM

Add this code to your app. WalletHolder opens the wallet once per app process and gives every caller the same instance:

import android.content.Context
import java.io.File
import kotlinx.coroutines.NonCancellable
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.withContext
import uniffi.bark.Config
import uniffi.bark.Network
import uniffi.bark.Wallet
import uniffi.bark.WalletOpenArgs
import uniffi.bark.generateMnemonic

object WalletHolder {
    private val mutex = Mutex()
    private var wallet: Wallet? = null

    // Opens the wallet on the first call and returns the same instance afterwards
    suspend fun get(context: Context): Wallet = mutex.withLock {
        // Finish opening even if Android destroys the calling activity, for example on rotation
        wallet ?: withContext(NonCancellable) {
            openWallet(context).also { wallet = it }
        }
    }
}

private suspend fun openWallet(context: Context): Wallet {
    // Signet tests only: don't store a real mnemonic in an unencrypted file
    val mnemonicFile = File(context.filesDir, "bark-mnemonic")
    val mnemonic = if (mnemonicFile.exists()) {
        mnemonicFile.readText()
    } else {
        generateMnemonic().also { mnemonicFile.writeText(it) }
    }

    // Configure the signet endpoints
    val config = Config(
        serverAddress = "https://ark.signet.2nd.dev",
        serverAccessToken = null,
        esploraAddress = "https://esplora.signet.2nd.dev",
        bitcoindAddress = null,
        bitcoindCookiefile = null,
        bitcoindUser = null,
        bitcoindPass = null,
        vtxoRefreshExpiryThreshold = null,
        vtxoExitMargin = null,
        htlcRecvClaimDelta = null,
        fallbackFeeRate = null,
        roundTxRequiredConfirmations = null,
        daemonSyncIntervalSecs = null,
        offboardRequiredConfirmations = null,
        daemonManualSync = null,
        lightningReceiveClaimRetries = null,
        userAgent = null,
        vtxoKeyGapLimit = null,
    )

    val datadir = File(context.filesDir, "bark").path

    // Create the wallet in datadir, or reopen it on later launches
    return Wallet.open(
        Network.SIGNET,
        mnemonic,
        config,
        WalletOpenArgs(datadir = datadir, onchain = null),
    )
}

Get the wallet from a coroutine, for example in your activity:

lifecycleScope.launch {
    val wallet = WalletHolder.get(applicationContext)
}

Save this program as src/main/kotlin/Main.kt:

import java.io.File
import kotlinx.coroutines.runBlocking
import uniffi.bark.Config
import uniffi.bark.Network
import uniffi.bark.Wallet
import uniffi.bark.WalletOpenArgs
import uniffi.bark.generateMnemonic

fun main() = runBlocking {
    // Signet tests only: don't store a real mnemonic in an unencrypted file
    val mnemonicFile = File("bark-mnemonic")
    val mnemonic = if (mnemonicFile.exists()) {
        mnemonicFile.readText()
    } else {
        generateMnemonic().also { mnemonicFile.writeText(it) }
    }

    // Configure the signet endpoints
    val config = Config(
        serverAddress = "https://ark.signet.2nd.dev",
        serverAccessToken = null,
        esploraAddress = "https://esplora.signet.2nd.dev",
        bitcoindAddress = null,
        bitcoindCookiefile = null,
        bitcoindUser = null,
        bitcoindPass = null,
        vtxoRefreshExpiryThreshold = null,
        vtxoExitMargin = null,
        htlcRecvClaimDelta = null,
        fallbackFeeRate = null,
        roundTxRequiredConfirmations = null,
        daemonSyncIntervalSecs = null,
        offboardRequiredConfirmations = null,
        daemonManualSync = null,
        lightningReceiveClaimRetries = null,
        userAgent = null,
        vtxoKeyGapLimit = null,
    )

    // Create the wallet in datadir, or reopen it on later launches
    val wallet = Wallet.open(
        Network.SIGNET,
        mnemonic,
        config,
        WalletOpenArgs(datadir = "bark-data", onchain = null),
    )
}

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() on the JVM, or after WalletHolder.get() in your coroutine on Android:

val address = wallet.newAddress()
println("Ark address: $address")

Run the JVM program or your Android app to print the address. On Android, println() output appears in Logcat. 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:

wallet.sync()

val balance = wallet.balance()
println("Spendable: ${balance.spendableSats} sats")

Balance amounts are ULong values.Run the program or app again. It reopens the same wallet and prints your spendable balance in sats.

Documentation

Bark SDK

Barkd

Run an Ark server

Get started with Kotlin

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