User Request
│
├─ Go wallet development?
│  └─ Route to: go-sdk docs
│
├─ TypeScript/React wallet?
│  └─ Route to: wallet (PWA) docs
│
├─ Lightning/swap integration?
│  └─ Route to: fulmine docs
│
├─ Protocol concepts (VTXO, rounds)?
│  └─ Route to: ark-docs + arkd
│
└─ Quick operation lookup?
   └─ Handle directly with inline reference

go get github.com/arkade-os/go-sdk
import arksdk "github.com/arkade-os/go-sdk"

// Create storage (in-memory for testing)
storeSvc, err := store.NewStore(store.Config{
    ConfigStoreType: types.InMemoryStore,
})
if err != nil {
    return err
}

// Create client
client, err := arksdk.NewArkClient(storeSvc)
if err != nil {
    return err
}

// Initialize new wallet
err = client.Init(ctx, arksdk.InitArgs{
    WalletType: arksdk.SingleKeyWallet,
    ClientType: arksdk.GrpcClient,
    ServerUrl:  "localhost:7070",
    Password:   "your_password",
})

// Load wallet from storage
err = client.Load(ctx, arksdk.LoadArgs{
    ClientType: arksdk.GrpcClient,
    Password:   "your_password",
})

// Unlock wallet
err = client.Unlock(ctx, password)
defer client.Lock(ctx)

// Get receive addresses (offchain + boarding)
// Returns 4 values: (onchainAddr, offchainAddr, boardingAddr, err)
_, offchainAddr, boardingAddr, err := client.Receive(ctx)

// Check balance
balance, err := client.Balance(ctx)
// balance.OnchainBalance.SpendableAmount - onchain sats
// balance.OffchainBalance.Total - offchain sats (VTXOs)

// Send offchain payment
receivers := []types.Receiver{{To: recipientAddr, Amount: amount}}
txid, err := client.SendOffChain(ctx, false, receivers)

// Collaborative exit (redeem to onchain)
txid, err := client.CollaborativeExit(ctx, onchainAddr, amount, false)

// Settle VTXOs (participate in round)
txid, err := client.Settle(ctx)

// In-Memory (testing only)
store.Config{
    ConfigStoreType:  types.InMemoryStore,
    AppDataStoreType: types.KVStore,
}

// File-based (persistent)
store.Config{
    ConfigStoreType:  types.FileStore,
    AppDataStoreType: types.KVStore,
    BaseDir:          "/path/to/wallet/data",
}

// SQL-based (SQLite)
// Requires sqlc-generated code

// Enable during init
client.Init(ctx, arksdk.InitArgs{
    // ...
    WithTransactionFeed: true,
})

// Listen for events
txsChan := client.GetTransactionEventChannel(ctx)
go func() {
    for txEvent := range txsChan {
        for _, tx := range txEvent.Txs {
            log.Printf("tx %s type: %s, amount: %d",
                tx.TransactionKey.String(), tx.Type, tx.Amount)
        }
    }
}()

npm install @arkade-os/sdk
# or
pnpm add @arkade-os/sdk

import { ArkClient, InMemoryStore } from '@arkade-os/sdk';

// Create storage
const store = new InMemoryStore();

// Create client
const client = new ArkClient(store);

// Initialize new wallet
await client.init({
  serverUrl: 'https://ark.example.com',
  password: 'your_password',
});

// Unlock wallet
await client.unlock(password);

// Get receive addresses
const { offchainAddress, boardingAddress } = await client.receive();

// Check balance
const balance = await client.balance();
// balance.offchain, balance.onchain

// Send offchain
const txid = await client.sendOffchain({
  address: recipientAddr,
  amount: 10000, // sats
});

// Collaborative exit
const txid = await client.collaborativeExit({
  address: onchainAddr,
  amount: 10000,
});

// Settle VTXOs
await client.settle();

// WalletProvider pattern
import { WalletProvider, useWallet } from '@arkade-os/sdk/react';

function App() {
  return (
    <WalletProvider serverUrl="https://ark.example.com">
      <WalletScreen />
    </WalletProvider>
  );
}

function WalletScreen() {
  const { client, isUnlocked, balance } = useWallet();

  const handleSend = async () => {
    await client.sendOffchain({ address, amount });
  };

  return (
    <div>
      <p>Balance: {balance?.offchain} sats</p>
      <button onClick={handleSend}>Send</button>
    </div>
  );
}

// In-Memory (testing)
import { InMemoryStore } from '@arkade-os/sdk';
const store = new InMemoryStore();

// IndexedDB (PWA/browser)
import { IndexedDBStore } from '@arkade-os/sdk';
const store = new IndexedDBStore('arkade-wallet');

// File (Node.js)
import { FileStore } from '@arkade-os/sdk';
const store = new FileStore('/path/to/data');

1. BOARDING (onchain → offchain)
   User sends BTC to boarding address
   → Transaction confirms
   → arkd creates VTXO in next round
   → User now has offchain balance

2. SENDING (offchain transfer)
   User creates payment to another Ark address
   → Payment is instant (pre-confirmed)
   → Settles in next round

3. RECEIVING
   User provides offchain address
   → Sender creates payment
   → Receiver sees pending balance
   → Confirms after round settlement

4. SETTLING (round participation)
   User participates in settlement round
   → Old VTXOs are consumed
   → New VTXOs are created
   → Expiry extended by round_lifetime

5. REDEMPTION (offchain → onchain)
   User requests collaborative exit
   → arkd creates onchain output
   → User receives onchain BTC
   → VTXOs are consumed

// Go SDK - gRPC client is default
client.Init(ctx, arksdk.InitArgs{
    ClientType: arksdk.GrpcClient,
    ServerUrl:  "localhost:7070",
})

// Go SDK - REST client
client.Init(ctx, arksdk.InitArgs{
    ClientType: arksdk.RestClient,
    ServerUrl:  "http://localhost:7070",
})

// Go SDK - generate mnemonic
mnemonic, err := bip39.NewMnemonic(entropy)

// Go SDK - restore from mnemonic
seed := bip39.NewSeed(mnemonic, "")
masterKey, err := hdkeychain.NewMaster(seed, &chaincfg.MainNetParams)

// TypeScript SDK
import { generateMnemonic, mnemonicToSeed } from '@scure/bip39';

const mnemonic = generateMnemonic();
const seed = await mnemonicToSeed(mnemonic);

// Offchain address (Ark payments)
offchainAddr, boardingAddr, err := client.Receive(ctx)
// offchainAddr: ark1...

// Boarding address (onchain → offchain)
// boardingAddr: bcrt1p... (Taproot)

func main() {
    ctx := context.Background()
    storeSvc, _ := store.NewStore(store.Config{
        ConfigStoreType:  types.FileStore,
        AppDataStoreType: types.KVStore,
    })
    client, _ := arksdk.NewArkClient(storeSvc)

    // Check if wallet exists
    if client.IsLoaded() {
        client.Load(ctx, arksdk.LoadArgs{Password: password})
    } else {
        client.Init(ctx, arksdk.InitArgs{
            ServerUrl: "localhost:7070",
            Password:  password,
        })
    }

    client.Unlock(ctx, password)
    defer client.Lock(ctx)

    // Use wallet...
    balance, _ := client.Balance(ctx)
    fmt.Printf("Balance: %d sats\n", balance.OffchainBalance.Total)
}

// Multiple wallets/connections
clients := make([]arksdk.ArkClient, numClients)
for i := 0; i < numClients; i++ {
    storeSvc, _ := store.NewStore(store.Config{
        ConfigStoreType:  types.FileStore,
        AppDataStoreType: types.KVStore,
        BaseDir:          fmt.Sprintf("/data/wallet_%d", i),
    })
    clients[i], _ = arksdk.NewArkClient(storeSvc)
}

// Watch for incoming payments
client.Init(ctx, arksdk.InitArgs{
    WithTransactionFeed: true,
    // ...
})

txsChan := client.GetTransactionEventChannel(ctx)
go func() {
    for txEvent := range txsChan {
        for _, tx := range txEvent.Txs {
            if tx.Type == "received" {
                notifyUser(tx.Amount)
            }
        }
    }
}()

cd ${GO_SDK_REPO}/example/alice_to_bob
go run alice_to_bob.go

cd ${WALLET_REPO}
pnpm install
pnpm run start
# Access at http://localhost:3002

cd ${FULMINE_REPO}
make run
# Access at http://localhost:7001

// Verify server is running
curl http://localhost:7070/v1/info

// Check ServerUrl format
ServerUrl: "localhost:7070"     // gRPC (no protocol)
ServerUrl: "http://localhost:7070" // REST (with protocol)

// Check if wallet exists before loading
if client.IsLoaded() {
    client.Load(ctx, args)
} else {
    client.Init(ctx, args)
}

// Settle regularly to renew VTXOs
client.Settle(ctx)
// VTXOs have ~30 day expiry by default

// Check both offchain and onchain
balance, _ := client.Balance(ctx)
// balance.OffchainBalance.Total - Ark VTXOs
// balance.OnchainBalance.SpendableAmount - Pending boarding