Groot | Bring your bitcoin home

Built around you

Self-custody. Take a breath.

Groot turns serious Bitcoin security into three clear habits: choose where every key lives, see exactly what you approve, and practice recovery before you need it.

Explore wallet features →

01Control

Choose where every key lives.

Keep keys on your computer, hardware signers—or a mix. Groot connects them so self-custody feels effortless.

02Clarity

See exactly what you approve.

See the recipient, amount, fee, coins, change, and signatures before bitcoin moves.

03Recovery

Recover beyond Groot.

Practice recovery with standard backups. Restore your wallet with compatible software whenever you need to.

A high alpine ridge rising above cloud at sunrise

Why Groot

Freedom needs a way out.

Standard backups let you recover in another compatible wallet, so your bitcoin never depends on Groot.

A longer tradition

Sovereignty is not a feature.
It is the whole point.

Privacy, ownership, and freedom have always belonged together.

The computer can be used as a tool to liberate and protect people, rather than to control them.

Hal FinneyCypherpunks mailing list, 1992

The entire point … is to not trust any one thing.

Jameson LoppOn multivendor self-custody, 2026

Bitcoin only

Bitcoin only.
Built to last.

For us, our families, our friends, and the Bitcoin network.

// src-tauri/src/proposal.rs
pub fn decode_psbt(encoded: &str)
  -> Result<Psbt, ProposalError> {
  let bytes = BASE64_STANDARD.decode(encoded)?;
  let psbt = Psbt::deserialize(&bytes)?;
  verify_network(&psbt)?;
  verify_outputs(&psbt)?;
  Ok(psbt)
}

// review the transaction, not a summary
let recipient = tx.output[0].script_pubkey.clone();
let fee = wallet.calculate_fee(&tx)?;
let change = identify_change(&tx, &wallet)?;

// src-tauri/src/proposal.rs
pub fn decode_psbt(encoded: &str)
  -> Result<Psbt, ProposalError> {
  let bytes = BASE64_STANDARD.decode(encoded)?;
  let psbt = Psbt::deserialize(&bytes)?;
  verify_network(&psbt)?;
  verify_outputs(&psbt)?;
  Ok(psbt)
}

// review the transaction, not a summary
let recipient = tx.output[0].script_pubkey.clone();
let fee = wallet.calculate_fee(&tx)?;
let change = identify_change(&tx, &wallet)?;

// src-tauri/src/proposal.rs
pub fn decode_psbt(encoded: &str)
  -> Result<Psbt, ProposalError> {
  let bytes = BASE64_STANDARD.decode(encoded)?;
  let psbt = Psbt::deserialize(&bytes)?;
  verify_network(&psbt)?;
  verify_outputs(&psbt)?;
  Ok(psbt)
}

// review the transaction, not a summary
let recipient = tx.output[0].script_pubkey.clone();
let fee = wallet.calculate_fee(&tx)?;
let change = identify_change(&tx, &wallet)?;

// signatures are verified before merge
fn verify_partial_signatures(psbt: &Psbt)
  -> Result<(), SigningError> {
  for input in &psbt.inputs {
    for (key, signature) in &input.partial_sigs {
      verify_signature(key, signature, input)?;
    }
  }
  Ok(())
}

// keys remain inside their boundary
match signer {
  Signer::Hardware(device) => device.sign(psbt),
  Signer::Software(core) => core.sign(psbt),
}

// signatures are verified before merge
fn verify_partial_signatures(psbt: &Psbt)
  -> Result<(), SigningError> {
  for input in &psbt.inputs {
    for (key, signature) in &input.partial_sigs {
      verify_signature(key, signature, input)?;
    }
  }
  Ok(())
}

// keys remain inside their boundary
match signer {
  Signer::Hardware(device) => device.sign(psbt),
  Signer::Software(core) => core.sign(psbt),
}

// signatures are verified before merge
fn verify_partial_signatures(psbt: &Psbt)
  -> Result<(), SigningError> {
  for input in &psbt.inputs {
    for (key, signature) in &input.partial_sigs {
      verify_signature(key, signature, input)?;
    }
  }
  Ok(())
}

// keys remain inside their boundary
match signer {
  Signer::Hardware(device) => device.sign(psbt),
  Signer::Software(core) => core.sign(psbt),
}

// public checks run on every change
$ pnpm validate
✓ format
✓ check
✓ unit tests
✓ browser tests

$ cargo test --locked --all-features
test policy::requires_permanent_label ... ok
test signing::rejects_wrong_network ... ok
test recovery::rebuilds_first_address ... ok

// standard backups, no custody
export_descriptor(wallet)?;
export_labels(wallet)?;
export_recovery_pdf(wallet)?;

// public checks run on every change
$ pnpm validate
✓ format
✓ check
✓ unit tests
✓ browser tests

$ cargo test --locked --all-features
test policy::requires_permanent_label ... ok
test signing::rejects_wrong_network ... ok
test recovery::rebuilds_first_address ... ok

// standard backups, no custody
export_descriptor(wallet)?;
export_labels(wallet)?;
export_recovery_pdf(wallet)?;

// public checks run on every change
$ pnpm validate
✓ format
✓ check
✓ unit tests
✓ browser tests

$ cargo test --locked --all-features
test policy::requires_permanent_label ... ok
test signing::rejects_wrong_network ... ok
test recovery::rebuilds_first_address ... ok

// standard backups, no custody
export_descriptor(wallet)?;
export_labels(wallet)?;
export_recovery_pdf(wallet)?;

Built in the open