# FROST DKG Signing Using bdk-cli

## One-Time Setup Steps

### Install the `frost-zcash-tools` repo:

1. Clone the repo:

git clone https://github.com/BlockchainCommons/zcash-frost-tools

2. Check out the `taproot-tweak` branch:

git checkout taproot-tweak

3. Install the tools.

- This installs `frost-client`, `coordinator`, `dkg`, `participant`, `trusted-dealer`, and `frostd`.
- This demo only uses `frostd` and `frost-client`.

cargo install --path frost-client && cargo install --path frostd

### Install `toml-cli`

We will use this to extract the public keys from the TOML files.

cargo install toml-cli

### Install the `sighash-helper` tool

`bdk-cli` does not have a way to extract a transaction sighash in a format suitable for FROST signing, so we need to write a small Rust program that does just that.

cargo new sighash-helper --bin
cd sighash-helper

Open `Cargo.toml` and replace its `[dependencies]` section with:

bdk = { version = "0.30.2", default-features = false, features = ["std"] }

Replace the contents of `src/main.rs` with the following code:

use std::io::{self, Read};
use std::str::FromStr;

use bdk::bitcoin::psbt::PartiallySignedTransaction as Psbt;
use bdk::bitcoin::sighash::{Prevouts, SighashCache, TapSighashType};

fn main() {
    // 1. read the base‑64 PSBT from stdin
    let mut b64 = String::new();
    io::stdin().read_to_string(&mut b64).unwrap();
    let psbt = Psbt::from_str(b64.trim()).expect("valid base64 PSBT");

    // 2. assume exactly one input (enforced by the demo)
    let tx = &psbt.unsigned_tx;

    // 3. clone the single witness_utxo so it lives long enough
    let txout = psbt.inputs[0]
        .witness_utxo
        .as_ref()
        .expect("witness_utxo present")
        .clone();
    let prevouts_arr = [txout];                 // concrete array on the stack
    let prevouts = Prevouts::All(&prevouts_arr);

    // 4. compute Taproot key‑path sighash
    let mut cache = SighashCache::new(tx);
    let msg = cache
        .taproot_key_spend_signature_hash(0, &prevouts, TapSighashType::Default)
        .expect("sighash");

    // 5. print the 32‑byte message as hex
    println!("{:064x}", msg);
}

Build the tool. This should make it available in your `$PATH`.

cargo install --path .
cd ..

### Install the `psbt-sig-attach` tool

bdk‑cli 1.0 doesn’t yet expose a command to “just stick this signature in input 0”, so we’ll use another tiny Rust helper to do the surgery.

cargo new psbt-sig-attach --bin
cd psbt-sig-attach

Open `Cargo.toml` and replace its `[dependencies]` section with:

[dependencies]
bdk    = { version = "0.30.2", default-features = false, features = ["std"] }
base64 = "0.22.1"
hex    = "0.4"
bitcoin = "0.30.2"

Replace the contents of `src/main.rs` with the following code:

use std::io::{self, Read};
use std::str::FromStr;

use bitcoin::{
    psbt::PartiallySignedTransaction as Psbt,
    secp256k1::schnorr::Signature as SchnorrSig,
    sighash::TapSighashType,
    taproot::Signature as TaprootSignature,
};
use hex::FromHex;

fn main() {
    // r||s hex comes as first CLI arg
    let sig_hex = std::env::args()
        .nth(1)
        .expect("usage: psbt-sig-attach <64-byte r||s hex>");
    let sig_vec = Vec::<u8>::from_hex(sig_hex.trim()).expect("hex sig");
    assert_eq!(sig_vec.len(), 64, "need 64-byte Schnorr sig");

    // wrap in TaprootSignature with default sighash flag
    let tap_sig = TaprootSignature {
        sig: SchnorrSig::from_slice(&sig_vec).expect("schnorr sig"),
        hash_ty: TapSighashType::Default,
    };

    // read base-64 PSBT from stdin
    let mut b64 = String::new();
    io::stdin().read_to_string(&mut b64).unwrap();
    let mut psbt = Psbt::from_str(b64.trim()).expect("base64 PSBT");

    // insert signature in input 0
    psbt.inputs[0].tap_key_sig = Some(tap_sig);

    // write updated PSBT as base-64
    println!("{}", psbt.to_string());
}

Build the tool. This should make it available in your `$PATH`.

cargo install --path .
cd ..

### Add an SSL certificate for `frostd`

The instructions below are for macOS. See [the `mkcert` repo](https://github.com/FiloSottile/mkcert) for more information.

Install `mkcert`:

brew install mkcert
│ ...
│ 🍺  /opt/homebrew/Cellar/mkcert/1.4.4: 7 files, 4.0MB
│ ...

Install the local CA:

mkcert -install

│ Created a new local CA 💥
│ Sudo password: <enter login password>
│ The local CA is now installed in the system trust store! ⚡️
│ The local CA is now installed in the Firefox trust store (requires browser restart)! 🦊

Create a certificate signed by the local CA for `frostd` to use running on `localhost`:

mkcert localhost 127.0.0.1 ::1

│ Created a new certificate valid for the following names 📜
│  - "localhost"
│  - "127.0.0.1"
│  - "::1"
│
│ The certificate is at "./localhost+2.pem" and the key at "./localhost+2-key.pem" ✅
│
│ It will expire on 17 November 2027 🗓

### Set Up `bitcoind` regtest node

export BITCOIN_DIR="$HOME/Library/Application Support/Bitcoin"
brew install bitcoin
cat >"$BITCOIN_DIR/bitcoin.conf"<<EOF
regtest=1
server=1
rpcuser=wolf
rpcpassword=topsecret
fallbackfee=0.0001
EOF

## Demo Steps

### Start the Bitcoin node

Start node. Add `-daemon` to run in the background:

bitcoind

The daemon is now listening on 127.0.0.1:18443.

### Set Up the Test Environment

export DEMO_DIR=`pwd`/demo
export REG_DIR="$DEMO_DIR/regular-wallet"
export FROST_DIR="$DEMO_DIR/frost-wallet"
export NETWORK=regtest
export RPC_URL=127.0.0.1:18443         # host:port
export RPC_USER=wolf                    # from bitcoin.conf above
export RPC_PASS=topsecret               # from bitcoin.conf above
export RPC_AUTH="$RPC_USER:$RPC_PASS"   # for bdk-cli
mkdir -p "$DEMO_DIR" "$REG_DIR" "$FROST_DIR"
cd "$DEMO_DIR"

### Set up and fund the regular wallet

#### Create the regular wallet in the test node

Set up the regtest wallet, then generate 101 blocks to mature the block reward and get the node going:

bitcoin-cli -regtest createwallet regtest || \
bitcoin-cli -regtest loadwallet regtest
bitcoin-cli -regtest -generate 101

│ {
│   "name": "regtest"
│ }
│ {
│   "address": "bcrt1qgekrq9j278ua769skqsh6p4n3z06lxjge3zjwf",
│   "blocks": [
│     "3fa077dd4a2aa50c3987c8913117abd4f8b55b3e798221e9756263d647822933",
│     "793159faf43ff756eccc774b5d7343e1303ec5c003b5a9d464ced706b2d9ce25",
│     "29253f081875fd4ebeccb8e15dd6fac3ff83878a5661c76dfdcc52705843bde2",
|     ...
│   ]
│ }

You can delete `$DEMO_DIR` from a previous run to reset the demo environment and start a new demo run. For results consistent with this document, starting with a fresh shell environment and resetting the Bitcoin regtest node is also recommended.

#### Generate a BIP‑86 master key and descriptors

REG_KEY_JSON=$(bdk-cli --network $NETWORK key generate)
REG_XPRV=$(echo "$REG_KEY_JSON" | jq -r '.xprv')
REG_FPRINT=$(echo "$REG_KEY_JSON" | jq -r '.fingerprint')
REG_EXT_DESC="tr([${REG_FPRINT}/86h/1h/0h]${REG_XPRV}/0/*)"
REG_INT_DESC="tr([${REG_FPRINT}/86h/1h/0h]${REG_XPRV}/1/*)"
echo $REG_EXT_DESC
echo $REG_INT_DESC

│ tr([4daeaf7d/86h/1h/0h]tprv8ZgxMBicQKsPfQhfWNRsbPnFZoWvQYvwBvNtUBX4bwwmW5WDhbc17RM7A4VkUrKVYEgB742qRNykBa9KvZh7Qz4bcfBh5u3EyVkHH9DzRJH/0/*)
│ tr([4daeaf7d/86h/1h/0h]tprv8ZgxMBicQKsPfQhfWNRsbPnFZoWvQYvwBvNtUBX4bwwmW5WDhbc17RM7A4VkUrKVYEgB742qRNykBa9KvZh7Qz4bcfBh5u3EyVkHH9DzRJH/1/*)

#### Grab a fresh address from the regular wallet

REG_ADDR=$(bdk-cli \
  --network "$NETWORK" \
  --datadir "$REG_DIR" \
  wallet \
    --client-type rpc \
    --database-type sqlite \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    --ext-descriptor "$REG_EXT_DESC" \
    --int-descriptor "$REG_INT_DESC" \
    new_address | jq -r '.address')
echo "$REG_ADDR"    # should start with bcrt1…

│ bcrt1pkhesty85r3594xasr0t4982h4v385nwcdt45y0jgf3nepmsd5pdsme9jlj

#### Mine a block straight into that address

bitcoin-cli -regtest generatetoaddress 1 "$REG_ADDR"

│ [
│   "2213ba549f53777d53d6897d65bc84613a5a88d2faf7d47a7b406971458a7351"
│ ]

#### Mine 100 more blocks to mature the block reward

bitcoin-cli -regtest -generate 100

│ {
│   "address": "bcrt1q65vljwpfm6ameggyr85ylgz77vddly0s8eex4m",
│   "blocks": [
│     "54015aaaf6d953d3063c2c387d3f55cacfb3dca0022da92a4133411f79e3ab80",
│     "00395c9d7964cb79a0474ee6db0a092fec8423b0c9f9e6fb7ef4dac47e2566ae",
│     "3357c4cef2daf9321551e7a3581cb7abea6b090527775a7982fe580cd94d23d7",
│     ...
│   ]
│ }

#### Let BDK notice its money and verify the balance

bdk-cli \
  --network "$NETWORK" \
  --datadir "$REG_DIR" \
  wallet \
    --client-type rpc \
    --database-type sqlite \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    sync
bdk-cli \
  --network "$NETWORK" \
  --datadir "$REG_DIR" \
  wallet \
    --client-type rpc \
    --database-type sqlite \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    balance

│ {}
│ {
│   "satoshi": {
│     "confirmed": 5000000000,
│     "immature": 0,
│     "trusted_pending": 0,
│     "untrusted_pending": 0
│   }
│ }

The regular wallet now has 5,000,000,000 satoshis (50 BTC) in confirmed balance.

### Create the FROST group

#### Create the FROST client configurations

Use `frost-client` to create each participant’s local config + network identity and then exchange “contact” strings.

On each machine (or each terminal), run:

frost-client init -c alice.toml
frost-client init -c bob.toml
frost-client init -c eve.toml

│ Generating keypair...
│ Writing to config file at alice.toml...
│ Done.
│ WARNING: the config file will contain your private FROST shares in clear. Keep it safe and never share it with anyone. Future versions of this tool might encrypt the config file.
│ Generating keypair...
│ Writing to config file at bob.toml...
│ Done.
│ WARNING: the config file will contain your private FROST shares in clear. Keep it safe and never share it with anyone. Future versions of this tool might encrypt the config file.
│ Generating keypair...
│ Writing to config file at eve.toml...
│ Done.
│ WARNING: the config file will contain your private FROST shares in clear. Keep it safe and never share it with anyone. Future versions of this tool might encrypt the config file.

#### Record the participant's public keys

⚠️ Run this in all the participants' terminals.

ALICE_PUBKEY=`toml get alice.toml 'communication_key.pubkey' | sed 's/"//g'`
BOB_PUBKEY=`toml get bob.toml 'communication_key.pubkey' | sed 's/"//g'`
EVE_PUBKEY=`toml get eve.toml 'communication_key.pubkey' | sed 's/"//g'`
echo $ALICE_PUBKEY
echo $BOB_PUBKEY
echo $EVE_PUBKEY

│ b0fb13901b6eca549f00ef3d69484435362b7b96efdd116b2693706c6d2a6025
│ 2a47a1184bce04239b479851286a025e0705936248d56e43a15b2e88e13ccc51
│ 4aabbfb4ceb393bb9a4bcac181334e07c7fef6ffd5037f8c755d7e2f1b0d0e22

#### Export the client contact strings

ALICE_CONTACT=`frost-client export --name "Alice" -c alice.toml 2>&1 | tail -n 1`
BOB_CONTACT=`frost-client export --name "Bob" -c bob.toml 2>&1 | tail -n 1`
EVE_CONTACT=`frost-client export --name "Eve" -c eve.toml 2>&1 | tail -n 1`
echo $ALICE_CONTACT
echo $BOB_CONTACT
echo $EVE_CONTACT

│ zffrost1qyqq2stvd93k2g9slvfeqxmwef2f7q808455s3p4xc4hh9h0m5gkkf5nwpkx62nqy5j9qg33
│ zffrost1qyqqxsn0vgsz53aprp9uupprndres5fgdgp9upc9jd3y34twgws4kt5guy7vc5g795au2
│ zffrost1qyqqx3tkv5sy42alkn8t8yamnf9u4svpxd8q03l77mla2qml33646l30rvxsugs6rslfs

#### Each client imports the other two clients' contact strings

frost-client import -c alice.toml $BOB_CONTACT
frost-client import -c alice.toml $EVE_CONTACT
frost-client import -c bob.toml $ALICE_CONTACT
frost-client import -c bob.toml $EVE_CONTACT
frost-client import -c eve.toml $ALICE_CONTACT
frost-client import -c eve.toml $BOB_CONTACT

│ Imported this contact:
│ Name: Bob
│ Public Key: d1129058500ee4f1eb9cb13ae5438898ca85214a2461b81025987b84956df754
│ Imported this contact:
│ Name: Eve
│ Public Key: 7ac45af5e45841e4a17533066d22d7132101aa87b16634a545810f426bd36221
│ Imported this contact:
│ Name: Alice
│ Public Key: 22f2f696f4d8074aa842b0ab0465626678ba3e618cc512523608f1b5ce1d8927
│ Imported this contact:
│ Name: Eve
│ Public Key: 7ac45af5e45841e4a17533066d22d7132101aa87b16634a545810f426bd36221
│ Imported this contact:
│ Name: Alice
│ Public Key: 22f2f696f4d8074aa842b0ab0465626678ba3e618cc512523608f1b5ce1d8927
│ Imported this contact:
│ Name: Bob
│ Public Key: d1129058500ee4f1eb9cb13ae5438898ca85214a2461b81025987b84956df754

#### Start the FROST server

frostd \
  --tls-cert localhost+2.pem \
  --tls-key  localhost+2-key.pem

│ 2025-08-08T23:47:22.551822Z  INFO frostd: server running
│ 2025-08-08T23:47:22.559393Z  INFO frostd: starting HTTPS server at 0.0.0.0:2744

#### Start the DKG session

NOTE: If you get the error `Error: user has more than one FROST session active`, you can restart `frostd` to clear its in-memory state. There are more elegant ways to to this but for the demo it's not a concern.

On Alice's terminal:

frost-client dkg \
  -d "Demo DKG: Alice, Bob, Eve" \
  -s https://127.0.0.1:2744 \
  -S $BOB_PUBKEY,$EVE_PUBKEY \
  -t 2 \
  -C "secp256k1-tr" \
  -c alice.toml

│ Logging in...
│ Creating DKG session...
│ Getting session info...
│ Waiting for other participants to send their Round 1 Packages.....

#### Add the second participant

On Bob's terminal:

frost-client dkg \
  -d "Demo DKG: Alice, Bob, Eve" \
  -s https://127.0.0.1:2744 \
  -t 2 \
  -C "secp256k1-tr" \
  -c bob.toml

│ Logging in...
│ Joining DKG session...
│ Getting session info...
│ Waiting for other participants to send their Round 1 Packages.....

#### Add the third participant

On Eve's terminal:

frost-client dkg \
  -d "Demo DKG: Alice, Bob, Eve" \
  -s https://127.0.0.1:2744 \
  -t 2 \
  -C "secp256k1-tr" \
  -c eve.toml

│ Logging in...
│ Joining DKG session...
│ Getting session info...
│ Waiting for other participants to send their Round 1 Packages.....

#### The participants exchange their packets:

Alice

│ Waiting for other participants to send their broadcasted Round 1 Packages....
│ Waiting for other participants to send their Round 2 Packages.....
│ Taproot DKG: storing P in PublicKeyPackage for FROST signing
│   Internal key (P): 3e18b2b17af80180aa3c766a13b27bb0dfd724ad5f16107c54cf38557b1ea1ea
│   Tweaked key (Q):  3c18a30c878fe6ebabf0960952810d0a8130507a1b10c518bf07165049fe790b
│   Group ID will use Q for identification
│ Group created; information written to alice.toml

Bob

│ Waiting for other participants to send their broadcasted Round 1 Packages.....
│ Waiting for other participants to send their Round 2 Packages....
│ Taproot DKG: storing P in PublicKeyPackage for FROST signing
│   Internal key (P): 3e18b2b17af80180aa3c766a13b27bb0dfd724ad5f16107c54cf38557b1ea1ea
│   Tweaked key (Q):  3c18a30c878fe6ebabf0960952810d0a8130507a1b10c518bf07165049fe790b
│   Group ID will use Q for identification
│ Group created; information written to bob.toml

Eve

│ Waiting for other participants to send their broadcasted Round 1 Packages.....
│ Waiting for other participants to send their Round 2 Packages.....
│ Taproot DKG: storing P in PublicKeyPackage for FROST signing
│   Internal key (P): 3e18b2b17af80180aa3c766a13b27bb0dfd724ad5f16107c54cf38557b1ea1ea
│   Tweaked key (Q):  3c18a30c878fe6ebabf0960952810d0a8130507a1b10c518bf07165049fe790b
│   Group ID will use Q for identification
│ Group created; information written to eve.toml

#### Inspect the results of the DKG

⚠️ Run this in all participant terminals:

GROUP_ID=$(grep -oE '^\[group\.[0-9a-f]+' alice.toml | head -1 | sed 's/^\[group\.//')
DESC=$(toml get alice.toml "group.$GROUP_ID.description" | tr -d '"')
CS=$(toml get alice.toml "group.$GROUP_ID.ciphersuite" | tr -d '"')
SRV=$(toml get alice.toml "group.$GROUP_ID.server_url" | tr -d '"')
PUBKEY_PKG=$(toml get alice.toml "group.$GROUP_ID.public_key_package" | tr -d '"')
PX=$(echo $PUBKEY_PKG | tail -c 65)
KEY_PKG=$(toml get alice.toml "group.$GROUP_ID.key_package" | tr -d '"')
echo "group ID:    $GROUP_ID"
echo "description: $DESC"
echo "ciphersuite: $CS"
echo "server_url:  $SRV"
echo "group_id:    $GROUP_ID"
echo "pubkey_pkg:  ${#PUBKEY_PKG} hex chars"
echo "px:          $PX"
echo "key_pkg:     ${#KEY_PKG} hex chars"

│ group ID:    023c18a30c878fe6ebabf0960952810d0a8130507a1b10c518bf07165049fe790b
│ description: Demo DKG: Alice, Bob, Eve
│ ciphersuite: FROST-secp256k1-SHA256-TR-v1
│ server_url:  https://127.0.0.1:2744
│ group_id:    023c18a30c878fe6ebabf0960952810d0a8130507a1b10c518bf07165049fe790b
│ pubkey_pkg:  468 hex chars
│ px:          3e18b2b17af80180aa3c766a13b27bb0dfd724ad5f16107c54cf38557b1ea1ea
│ key_pkg:     272 hex chars

Participants listed under this group:

grep -oE "^\[group\.$GROUP_ID\.participant\.[0-9a-f]+\]" alice.toml \
| sed -E "s/^\[group\.$GROUP_ID\.participant\.([0-9a-f]+)\]/\1/" \
| while read -r ID; do
  PK=$(toml get alice.toml "group.$GROUP_ID.participant.$ID.pubkey" | tr -d '"')
  echo "participant id=$ID pubkey=$PK"
done

│ participant id=28bb139e267a16ea2564d10fcc2f1aa4e9c2f21f9e3c384b9d918596fa1e6d21 pubkey=2a47a1184bce04239b479851286a025e0705936248d56e43a15b2e88e13ccc51
│ participant id=76495f429dc1fdb289fa252e12e4be1521eb7d6bf00ed23d886c55a3b4063019 pubkey=4aabbfb4ceb393bb9a4bcac181334e07c7fef6ffd5037f8c755d7e2f1b0d0e22
│ participant id=875f38aae71ab60455415d46f43e05744accac1a5271ebfe95e6484cacf1730d pubkey=b0fb13901b6eca549f00ef3d69484435362b7b96efdd116b2693706c6d2a6025

### Create and send funds to the FROST wallet

#### Extract the FROST quorum verifying key and compose the watch‑only descriptors

FROST_AGG_KEY=$PX
FROST_EXT_DESC="tr($FROST_AGG_KEY)"
FROST_INT_DESC="tr($FROST_AGG_KEY,pk($FROST_AGG_KEY))"
echo $FROST_AGG_KEY
echo $FROST_EXT_DESC
echo $FROST_INT_DESC

│ 3e18b2b17af80180aa3c766a13b27bb0dfd724ad5f16107c54cf38557b1ea1ea
│ tr(3e18b2b17af80180aa3c766a13b27bb0dfd724ad5f16107c54cf38557b1ea1ea)
│ tr(3e18b2b17af80180aa3c766a13b27bb0dfd724ad5f16107c54cf38557b1ea1ea,pk(3e18b2b17af80180aa3c766a13b27bb0dfd724ad5f16107c54cf38557b1ea1ea))

#### Create the FROST wallet using the descriptors, and ask for its first address

FROST_ADDR=$(bdk-cli \
  --network "$NETWORK" \
  --datadir "$FROST_DIR" \
  wallet \
    --client-type rpc \
    --database-type sqlite \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    --ext-descriptor "$FROST_EXT_DESC" \
    --int-descriptor "$FROST_INT_DESC" \
    new_address | jq -r '.address')
echo "$FROST_ADDR"        # bcrt1…

│ bcrt1p8sv2xry83lnwh2lsjcy49qgdp2qnq5r6rvgv2x9lqut9qj070y9srye47a

#### Fund the FROST address from the regular wallet

Send 100,000,000 satoshis (1 BTC) to the FROST address

# Compose PSBT
AMOUNT=100000000
SEND_PSBT=$(bdk-cli \
  --network "$NETWORK" \
  --datadir "$REG_DIR" \
  wallet \
    --client-type rpc \
    --database-type sqlite \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    --ext-descriptor "$REG_EXT_DESC" \
    --int-descriptor "$REG_INT_DESC" \
    create_tx \
      --to ${FROST_ADDR}:${AMOUNT} \
      --fee_rate 1.5 \
    | jq -r '.psbt')

# Sign PSBT
SIGNED_PSBT=$(bdk-cli \
  --network "$NETWORK" \
  --datadir "$REG_DIR" \
  wallet \
    --client-type rpc \
    --database-type sqlite \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    --ext-descriptor "$REG_EXT_DESC" \
    --int-descriptor "$REG_INT_DESC" \
    sign "$SEND_PSBT" | jq -r '.psbt')

# Broadcast PSBT
TXID=$(bdk-cli \
  --network "$NETWORK" \
  --datadir "$REG_DIR" \
  wallet \
    --client-type rpc \
    --database-type sqlite \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    --ext-descriptor "$REG_EXT_DESC" \
    --int-descriptor "$REG_INT_DESC" \
    broadcast --psbt "$SIGNED_PSBT" | jq -r '.txid')
echo "$TXID"

│ 807d29f634525c562c8c784830159eef9dcf6b3d028c06e86978c6181cb36916

#### Mine a block to confirm the transaction

bitcoin-cli -regtest -generate 1

│ {
│   "address": "bcrt1qzcrkftrmetgcve8cdjnpflgggs24jl5ga8emql",
│   "blocks": [
│     "24cbfc4eb86f3a729edc4270dfdacc20b49cda1cf286ac820a6564288a291281"
│   ]
│ }

#### Refresh the regular wallet and verify the reduced balance

bdk-cli \
  --network "$NETWORK" \
  --datadir "$REG_DIR" \
  wallet \
    --client-type rpc \
    --database-type sqlite \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    sync
bdk-cli \
  --network "$NETWORK" \
  --datadir "$REG_DIR" \
  wallet \
    --client-type rpc \
    --database-type sqlite \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    balance

│ {}
│ {
│   "satoshi": {
│     "confirmed": 4899999845,
│     "immature": 0,
│     "trusted_pending": 0,
│     "untrusted_pending": 0
│   }
│ }

The new balance is 5,000,000,000 (original balance) - 100,000,000 (sent) - 155 (fee) = 4,899,999,845

#### Refresh the FROST wallet and verify the 100,000,000 sat balance

bdk-cli \
  --network "$NETWORK" \
  --datadir "$FROST_DIR" \
  wallet \
    --client-type rpc \
    --database-type sqlite \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    --ext-descriptor "$FROST_EXT_DESC" \
    --int-descriptor "$FROST_INT_DESC" \
    sync
bdk-cli \
  --network "$NETWORK" \
  --datadir "$FROST_DIR" \
  wallet \
    --client-type rpc \
    --database-type sqlite \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    --ext-descriptor "$FROST_EXT_DESC" \
    --int-descriptor "$FROST_INT_DESC" \
    balance

│ {}
│ {
│   "satoshi": {
│     "confirmed": 100000000,
│     "immature": 0,
│     "trusted_pending": 0,
│     "untrusted_pending": 0
│   }
│ }

### Create the unsigned FROST -> Regular transaction

#### Identify the unique UTXO we just received

This optional step guarantees the PSBT has exactly one input, so the later FROST‑signing code (which computes just one sighash) always works. If the FROST wallet owns multiple UTXOs the script aborts with a clear message instead of producing an unsignable PSBT.

# sanity‑check: For the purposes of this demo, the FROST wallet **must** have exactly one UTXO
UNSPENT=$(bdk-cli \
  --network "$NETWORK" \
  --datadir "$FROST_DIR" \
  wallet \
    --client-type rpc \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    --database-type sqlite \
    --ext-descriptor "$FROST_EXT_DESC" \
    --int-descriptor "$FROST_INT_DESC" \
    unspent \
  )
COUNT=$(echo "$UNSPENT" | \
  jq -r 'length')
echo $COUNT
if [ "$COUNT" -ne 1 ]; then
  echo "Demo requires exactly one UTXO in the FROST wallet (found $COUNT)."; exit 1;
fi
FROST_UTXO=$(echo "$UNSPENT" | \
  jq -r '.[0].outpoint')
echo $FROST_UTXO

│ 1
│ 807d29f634525c562c8c784830159eef9dcf6b3d028c06e86978c6181cb36916:0:1

#### Generate a fresh receive address in the regular wallet:

REG_NEW_ADDR=$(bdk-cli \
  --network "$NETWORK" \
  --datadir "$REG_DIR" \
  wallet \
    --client-type rpc \
    --database-type sqlite \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    --ext-descriptor "$REG_EXT_DESC" \
    --int-descriptor "$REG_INT_DESC" \
    new_address | jq -r '.address')
echo "$REG_NEW_ADDR"    # should start with bcrt1…

│ bcrt1p3lpz54pglascakvcv5jz845kkq4cfpdqm5p3ze7fuxzv9cde7m2s42fyu3

#### Build the FROST -> Regular PSBT

- Selects the 100,000,000 sat UTXO the quorum just received,
- Constructs a one‑input / one‑output P2TR transaction,
- Pays 50,000,000 sat (0.5 BTC) to the new regular address, puts any remainder in a change output that still belongs to the FROST descriptor,
- Serializes everything as a base‑64 PSBT ready for signing.

AMOUNT=50000000
UNSIGNED_PSBT=$(bdk-cli \
  --network "$NETWORK" \
  --datadir "$FROST_DIR" \
  wallet \
    --client-type rpc \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    --database-type sqlite \
    --ext-descriptor "$FROST_EXT_DESC" \
    --int-descriptor "$FROST_INT_DESC" \
    create_tx \
      --to ${REG_NEW_ADDR}:${AMOUNT} \
      --fee_rate 1.5 \
      --enable_rbf \
    | jq -r '.psbt')
echo "$UNSIGNED_PSBT" > frost-to-reg.psbt
cat frost-to-reg.psbt

│ cHNidP8BAIkCAAAAARZpsxwYxnhp6AaMAj1rz53vnhUwSHiMLFZcUjT2KX2AAAAAAAD9////AuXv+gIAAAAAIlEgl7/CvG2SldTOfMQLpKWSgLUQtyIlmqLvKuIcgATFkiqA8PoCAAAAACJRII/CKlQo/2GO2ZhlJCPWlrArhIWg3QMRZ8nhhMLhufbVywAAAAABASsA4fUFAAAAACJRIDwYowyHj+brq/CWCVKBDQqBMFB6GxDFGL8HFlBJ/nkLIRY+GLKxevgBgKo8dmoTsnuw39ckrV8WEHxUzzhVex6h6gUAHd22HgEXID4YsrF6+AGAqjx2ahOye7Df1yStXxYQfFTPOFV7HqHqAAEFID4YsrF6+AGAqjx2ahOye7Df1yStXxYQfFTPOFV7HqHqAQYlAMAiID4YsrF6+AGAqjx2ahOye7Df1yStXxYQfFTPOFV7HqHqrCEHPhiysXr4AYCqPHZqE7J7sN/XJK1fFhB8VM84VXseoeolASRA4tTcr6kZllN2LAcRJlMowNT0NZERhuFBf3mQb8QwHd22HgAA

#### Extract the Taproot sighash the quorum must sign

Run the tool to extract the sighash from the PSBT.

⚠️ Run this in all participant terminals:

MSG=`sighash-helper < frost-to-reg.psbt`
echo $MSG       # 64‑hex‑char message (the one FROST signs)

│ 5be7bc3d975086e51f1d9adea282b2a2df38a58551ebcdd6511eae308530c955

### Run the FROST signing ceremony

#### Stop and restart `frostd` to remove old sessions

frostd \
  --tls-cert localhost+2.pem \
  --tls-key  localhost+2-key.pem

#### Start the ceremony with Alice acting as Coordinator

SIGNERS="$ALICE_PUBKEY,$BOB_PUBKEY"
printf '%s\n' "$MSG" | frost-client coordinator \
  --group "$GROUP_ID" \
  -s https://127.0.0.1:2744 \
  -S "$SIGNERS" \
  -m - \
  -o sig.raw \
  -c alice.toml

│ Taproot Option A active: verify shares under P, aggregate_with_tweak to Q (key‑path)
│ The message to be signed (hex encoded)
│ Taproot Option A: verifying shares under P, aggregating with tweak to Q (key‑path)
│ Logging in...
│ Creating signing session...
│ Note: Your key is included in --signers. Run 'frost-client participant' with your own config to contribute your commitments and signature share.
│ Waiting for participants to send their commitments...

│ Sending SigningPackage to participants...
│ Waiting for participants to send their SignatureShares...
│ ......

#### Add Alice as a participant

Alice also needs to act as a participant:

frost-client participant \
  --group "$GROUP_ID" \
  -s https://127.0.0.1:2744 \
  -c alice.toml

│ Taproot Option A active: using standard FROST (no rerandomization), P for challenge
│ Taproot participant: computing challenge with Q via sign_with_tweak (no rerandomization)
│ Logging in...
│ Joining signing session...
│ Sending commitments to coordinator...
│ Waiting for coordinator to send signing package...

#### Add Bob as the other participant

Bob is the other signer:

frost-client participant \
  --group "$GROUP_ID" \
  -s https://127.0.0.1:2744 \
  -c bob.toml

│ Taproot Option A active: using standard FROST (no rerandomization), P for challenge
│ Taproot participant: computing challenge with Q via sign_with_tweak (no rerandomization)
│ Logging in...
│ Joining signing session...
│ Sending commitments to coordinator...
│ Waiting for coordinator to send signing package..

#### Participants consent to the signing

Alice's terminal:

│ Signing package received
│ Message to be signed (hex-encoded):
│ b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
│ Do you want to sign it? (y/n)

y

│ Sending signature share to coordinator...
│ Done

Bob's terminal:

│ Signing package received
│ Message to be signed (hex-encoded):
│ b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
│ Do you want to sign it? (y/n)

y

│ Sending signature share to coordinator...
│ Done

Coordinator terminal:

Taproot Option A: verifying shares under P, aggregating with tweak to Q (key‑path)
Raw signature written to sig.raw

#### Get the Signature

The coordinator has written out the 64-byte signature file:

ls -l sig.raw

-rw-r--r--  1 wolf  staff  64 Jul 30 03:33 sig.raw

Hex‑encode the raw signature so the helper below can accept it

SIG_HEX=$(xxd -p sig.raw | tr -d '\n')
echo $SIG_HEX

│ ccac4c56ffadbc17d87fc268790dfceb893548e91e9e74c9293d228bd2a3c40cbe5022027a1cbba138f2d807b6db385ba2d45dedda29b539be89c884023bac4c

### Attach and send the signed transaction

#### Attach the FROST signature to the PSBT

SIGNED_PSBT=$(cat frost-to-reg.psbt | psbt-sig-attach "$SIG_HEX")
echo "$SIGNED_PSBT" > frost-to-reg.signed.psbt
cat frost-to-reg.signed.psbt

| cHNidP8BAIkCAAAAARZpsxwYxnhp6AaMAj1rz53vnhUwSHiMLFZcUjT2KX2AAAAAAAD9////AuXv+gIAAAAAIlEgl7/CvG2SldTOfMQLpKWSgLUQtyIlmqLvKuIcgATFkiqA8PoCAAAAACJRII/CKlQo/2GO2ZhlJCPWlrArhIWg3QMRZ8nhhMLhufbVywAAAAABASsA4fUFAAAAACJRIDwYowyHj+brq/CWCVKBDQqBMFB6GxDFGL8HFlBJ/nkLARNAzKxMVv+tvBfYf8JoeQ3864k1SOkennTJKT0ii9KjxAy+UCICehy7oTjy2Ae22zhbotRd7doptTm+iciEAjusTCEWPhiysXr4AYCqPHZqE7J7sN/XJK1fFhB8VM84VXseoeoFAB3dth4BFyA+GLKxevgBgKo8dmoTsnuw39ckrV8WEHxUzzhVex6h6gABBSA+GLKxevgBgKo8dmoTsnuw39ckrV8WEHxUzzhVex6h6gEGJQDAIiA+GLKxevgBgKo8dmoTsnuw39ckrV8WEHxUzzhVex6h6qwhBz4YsrF6+AGAqjx2ahOye7Df1yStXxYQfFTPOFV7HqHqJQEkQOLU3K+pGZZTdiwHESZTKMDU9DWREYbhQX95kG/EMB3dth4AAA==

#### Finalize the PSBT

FINAL_PSBT=$(bdk-cli \
  --network "$NETWORK" \
  --datadir "$FROST_DIR" \
  wallet \
    --client-type rpc \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    --database-type sqlite \
    --ext-descriptor "$FROST_EXT_DESC" \
    --int-descriptor "$FROST_INT_DESC" \
    finalize_psbt $(< frost-to-reg.signed.psbt) \
  | jq -r '.psbt')
echo $FINAL_PSBT > frost-to-reg.final.psbt
cat frost-to-reg.final.psbt

│ cHNidP8BAIkCAAAAARZpsxwYxnhp6AaMAj1rz53vnhUwSHiMLFZcUjT2KX2AAAAAAAD9////AuXv+gIAAAAAIlEgl7/CvG2SldTOfMQLpKWSgLUQtyIlmqLvKuIcgATFkiqA8PoCAAAAACJRII/CKlQo/2GO2ZhlJCPWlrArhIWg3QMRZ8nhhMLhufbVywAAAAABASsA4fUFAAAAACJRIDwYowyHj+brq/CWCVKBDQqBMFB6GxDFGL8HFlBJ/nkLAQhCAUDMrExW/628F9h/wmh5DfzriTVI6R6edMkpPSKL0qPEDL5QIgJ6HLuhOPLYB7bbOFui1F3t2im1Ob6JyIQCO6xMAAEFID4YsrF6+AGAqjx2ahOye7Df1yStXxYQfFTPOFV7HqHqAQYlAMAiID4YsrF6+AGAqjx2ahOye7Df1yStXxYQfFTPOFV7HqHqrAAA

#### Broadcast the finalized transaction

TXID=$(bdk-cli \
  --network "$NETWORK" \
  --datadir "$FROST_DIR" \
  wallet \
    --client-type rpc \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    --database-type sqlite \
    --ext-descriptor "$FROST_EXT_DESC" \
    --int-descriptor "$FROST_INT_DESC" \
    broadcast \
      --psbt "$FINAL_PSBT" | \
    jq -r '.txid')
echo $TXID

│ 65c5017da99c6b775e25ab5195d62bc9e0ab1131e1d45f437db43f6de11183f5

#### Confirm the FROST transaction

Now that the FROST transaction has been broadcast, we need to mine a block to confirm it on the regtest blockchain:

bitcoin-cli -regtest -generate 1

│ {
│   "address": "bcrt1qgpp7x8d2as2n8tefdju674j87acj0z4w9paz3r",
│   "blocks": [
│     "1018c8dd8148e732310fb488e80b881012f77348555c5931285bf5fa766ce6f1"
│   ]
│ }

#### Verify the regular wallet received the funds

Now let's sync the regular wallet and verify it received the 50,000,000 satoshis from the FROST transaction:

bdk-cli \
  --network "$NETWORK" \
  --datadir "$REG_DIR" \
  wallet \
    --client-type rpc \
    --database-type sqlite \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    --ext-descriptor "$REG_EXT_DESC" \
    --int-descriptor "$REG_INT_DESC" \
    sync
bdk-cli \
  --network "$NETWORK" \
  --datadir "$REG_DIR" \
  wallet \
    --client-type rpc \
    --database-type sqlite \
    --url "$RPC_URL" \
    -a "$RPC_AUTH" \
    --ext-descriptor "$REG_EXT_DESC" \
    --int-descriptor "$REG_INT_DESC" \
    balance

│ {}
│ {
│   "satoshi": {
│     "confirmed": 4949999845,
│     "immature": 0,
│     "trusted_pending": 0,
│     "untrusted_pending": 0
│   }
│ }

New balance = 4,899,999,845 (old balance) + 50,000,000 (received) = 4,949,999,845

### Summary

The demonstration is now complete! We have successfully:

1. ✅ **Broadcast the FROST transaction** - The multi-signature transaction was created and broadcast to the regtest network
2. ✅ **Confirmed the transaction** - The transaction was mined into a block and now has 1 confirmation
3. ✅ **Verified fund receipt** - The regular wallet's balance increased by exactly 50,000,000 satoshis

The FROST signature scheme has been successfully demonstrated end-to-end, showing how a threshold signature (2-of-3) can be used to spend Bitcoin in a Taproot transaction on the regtest network.