Bitcoin software overview

Bitcoin nodes

• Full nodes: These nodes store the entire blockchain and validate all transactions and blocks. They provide a high level of security and are essential for the network's decentralization.
  • Archival nodes: A subset of full nodes, archival nodes retain all blockchain data, making them valuable for historical analysis and debugging.
  
  • Pruned nodes: Pruned nodes save disk space by keeping only a portion of the blockchain, eliminating older data that is no longer needed for validation.
  

Bitcoin Core

• Usability: It can be utilized via a Command Line Interface (CLI) and a graphical user interface (GUI).
• Open-source nature: The code is open-source, allowing developers to contribute and scrutinize its workings.
• Language: Written in C++ with tests in Python, ensuring robust performance and reliability.

Exploring bitcoin core

• Compiling the codebase to create an executable version. bitcoin github access to doc/build-*.md for instructions.

./autogen.sh
./configure
make # use "-j N" for N parallel jobs
make install # optional

• Running tests to ensure everything functions correctly. Instructions can be found here

make check

#individual tests can be run directly calling the test script e.g:
test/functional/feature_rbf.py

#run all possible tests
test/functional/test_runner.py

• Creating and executing a test in Python to validate specific functionality. The file example.py is a heavily commented example of a test case that uses both the RPC and P2P interfaces.

Alternative node implementations

• Bitcoin knots: It offers more advanced features than Bitcoin core, taking more space and memory.
• LibBitcoin: A flexible and modular implementation.
• btcd: Written in Go, it offers different design philosophies.

Bitcoin wallets and security

Types of Bitcoin wallets

1. Custodian vs. non-custodian:
   • Custodian wallets: Managed by third parties, offering convenience but requiring trust in the custodian.
   • Non-custodian wallets: Controlled by users, providing higher security and privacy.
2. Desktop vs. mobile:
   • Desktop wallets: Typically more feature-rich and secure.
   • Mobile wallets: Offer convenience and portability.
3. On-chain vs. lightning:
   • On-chain wallets: Interact directly with the Bitcoin blockchain.
   • Lightning wallets: Facilitate faster and cheaper transactions off-chain.
4. Cold wallets vs. hot wallets:
   • Cold wallets: Not connected to the internet, providing superior security against hacks.
   • Hot wallets: Connected to the internet, offering more accessibility but less security.

Cold wallet security

Watch-only wallets

Basic functions of a Bitcoin wallet

1. Receive Bitcoin: Generate addresses and monitor for incoming transactions.
2. Send Bitcoin: Create and broadcast transactions to the network.
3. Display balance: Show the current balance of the wallet.

Role of Bitcoin wallets

• Bitcoin wallets act as keychains, holding and generating cryptographic keys.

• They monitor the blockchain for incoming transactions.

• Create transactions by selecting unspent transaction outputs (UTXOs), setting inputs and outputs, and optimizing for privacy and fees.

Reusability of wallet logic

Bitcoin Development Kit (BDK) and technical concepts

Overview of BDK

Other Bitcoin libraries

Key technical concepts

1. Descriptors: Descriptors describe how to derive Bitcoin scripts and addresses from keys, allowing for more flexible and powerful wallet functionalities.
2. PSBT (Partially Signed Bitcoin Transactions): PSBT is a format for transactions that require multiple signatures, facilitating collaborative transactions and enhanced security.
3. Rust syntax: Key concepts in Rust, such as Option for null safety and the Result type for error handling, are integral to understanding and using BDK effectively.

Creating and managing transactions

1. Build transactions: Specify recipients, amounts, and fees.
2. Sign transactions: Use PSBT to gather signatures.
3. Broadcast transactions: Send finalized transactions to the network.

Example workflow in BDK

• Set up wallet: Initialize a wallet with descriptors.

use bdk::{Wallet, SyncOptions};
use bdk::database::MemoryDatabase;
use bdk::blockchain::ElectrumBlockchain;
use bdk::electrum_client::Client;
use bdk::bitcoin;

fn main() -> Result<(), bdk::Error> {
  let wallet = Wallet::new(
    "tr(tprv8ZgxMBicQKsPf6WJ1Rr8Zmdsr6MaACS5K3tHw3QDQmFbkEsdnG3zAZzhjEgEtetL1jwZ5VAL85UaaFzUpAZPrS7aGkQ3GdM75xPu4sUxSiF/*)",
    None,
    bitcoin::Network::Testnet,
    MemoryDatabase::default(),
  )?;

  Ok(())
}

• Generate addresses: Create new addresses to receive Bitcoin from a testnet faucet.

//import AddressIndex outside the main function
use bdk::wallet::AddressIndex;

  //Function to add isnide main function
  let address = wallet.get_address(AddressIndex::New)?;

• Check balance: Monitor the wallet's balance, first by connecting to electrum, syncing wallet and getting the balance from the wallet.

    //connect to Electrum server and save the blockchain
    let client = Client::new("ssl://electrum.blockstream.info:60002")?;
    let blockchain = ElectrumBlockchain::from(client);

    //sync wallet to the blockchain received
    wallet.sync(&blockchain, SyncOptions::default())?;

    //get the balance from your wallet
    let balance = wallet.get_balance()?;
    println!("This is your wallet balance: {}", balance);

• Build, sign, and broadcast transactions: Construct and finalize transactions, then broadcast them to the network.

//Add to the imports
use bdk::bitcoin::Address;
use bdk::{SignOptions};
use std::str::FromStr;
use bdk::blockchain::Blockchain;

    //build a transaction psbt
    let mut builder = wallet.build_tx();
    let recipient_address = Address::from_str("tb1qlj64u6fqutr0xue85kl55fx0gt4m4urun25p7q").unwrap();

    builder
        .drain_wallet()
        .drain_to(recipient_address.script_pubkey())
        .fee_rate(FeeRate::from_sat_per_vb(2.0))
        .enable_rbf();
    let (mut psbt, tx_details) = builder.finish()?;
    println!("This is our psbt: {}", psbt);
    println!("These are the details of the tx: {:?}", tx_details);

    //Sign the PSBT
    let finalized = wallet.sign(&mut psbt, SignOptions::default())?;
    println!("Is my PSBT Signed? {}", finalized);
    println!("This is my PSBT finalized: {}", psbt);


    let tx = psbt.extract_tx();
    let tx_id = tx.txid();
    println!("this is my Bitcoin tx: {}", bitcoin::consensus::encode::serialize_hex(&tx));
    println!("this is mny tx id: {}", tx_id);

    //Broadcast the transaction
    blockchain.broadcast(&tx)?;

Print TXID and broadcast transaction

BDK utility and privacy considerations

Programming languages

BDK dependencies