Get started with Swift

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

iOS 14+ or macOS 14+, with Xcode 15+ (Swift 5.9+)

Getting started

Install the SDK

Xcode
Package.swift

In Xcode, go to File > Add Package Dependencies and enter the package URL:

https://gitlab.com/ark-bitcoin/bark-ffi-bindings.git

For Dependency Rule, select Exact Version and enter 0.25.0. Then add the Bark product to your app target.

Add the minimum platforms and the dependency to your Package.swift:

platforms: [.iOS(.v14), .macOS(.v14)],
dependencies: [
    .package(
        url: "https://gitlab.com/ark-bitcoin/bark-ffi-bindings.git",
        exact: "0.25.0"
    )
]

Then add the Bark product to your target’s dependencies:

.target(
    name: "YourApp",
    dependencies: [
        .product(name: "Bark", package: "bark-ffi-bindings")
    ]
)

In a macOS app, open your app target’s Signing & Capabilities tab. Under App Sandbox, select Outgoing Connections (Client).

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.Run the code from this step and the next two inside an async throws function or a Task, with the import lines at the top of the file.

import Bark
import Foundation

// Store the wallet files in your app's Application Support folder
let appDir = try FileManager.default.url(
    for: .applicationSupportDirectory,
    in: .userDomainMask,
    appropriateFor: nil,
    create: true
).appendingPathComponent(Bundle.main.bundleIdentifier ?? "bark-quickstart")
try FileManager.default.createDirectory(at: appDir, withIntermediateDirectories: true)

// Signet tests only: don't store a real mnemonic in an unencrypted file
let mnemonicFile = appDir.appendingPathComponent("bark-mnemonic")
let mnemonic: String
if FileManager.default.fileExists(atPath: mnemonicFile.path) {
    mnemonic = try String(contentsOf: mnemonicFile, encoding: .utf8)
} else {
    mnemonic = try generateMnemonic()
    try mnemonic.write(to: mnemonicFile, atomically: true, encoding: .utf8)
}

// Configure the signet endpoints. nil leaves a setting at Bark's default.
let config = Config(
    serverAddress: "https://ark.signet.2nd.dev",
    serverAccessToken: nil,
    esploraAddress: "https://esplora.signet.2nd.dev",
    bitcoindAddress: nil,
    bitcoindCookiefile: nil,
    bitcoindUser: nil,
    bitcoindPass: nil,
    vtxoRefreshExpiryThreshold: nil,
    vtxoExitMargin: nil,
    htlcRecvClaimDelta: nil,
    fallbackFeeRate: nil,
    roundTxRequiredConfirmations: nil,
    daemonSyncIntervalSecs: nil,
    offboardRequiredConfirmations: nil,
    daemonManualSync: nil,
    lightningReceiveClaimRetries: nil,
    userAgent: nil,
    vtxoKeyGapLimit: nil
)

let datadir = appDir.appendingPathComponent("bark").path

// Create the wallet in datadir, or reopen it on later launches
let wallet = try await Wallet.open(
    network: .signet,
    mnemonicOrSeed: mnemonic,
    config: config,
    args: WalletOpenArgs(datadir: datadir, onchain: nil)
)

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.

let address = try await wallet.newAddress()
print("Ark address: \(address)")

Run your app to print the address. In Xcode, print() output appears in the console. 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.

try await wallet.sync()

let balance = try await wallet.balance()
print("Spendable: \(balance.spendableSats) sats")

Balance amounts are UInt64 values.Run your 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 Swift

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