From one switch
to a financial network nobody owns.

// A Bitcoin transaction in flight. This is the same byte stream that travels
// from your wallet through the gossip network to the miners.
//
// Step-by-step, every layer of the site is doing its job:
//
//   1. WALLET CREATES TX
//      - allocates a Vec<u8> on the heap   (memory + arrays pages)
//      - fills it with inputs, outputs, scripts
//
//   2. WALLET SIGNS TX
//      - hashes the tx body with SHA-256   (hashing page)
//      - signs that hash with ECDSA / Schnorr
//
//   3. WALLET BROADCASTS TX
//      - opens a TCP socket to a Bitcoin node    (pointers + OS + networking pages)
//      - writes the serialised tx as bytes       (binary page; bytes are bytes)
//      - kernel splits it into IP packets         (networking page)
//
//   4. NODES VALIDATE TX
//      - parse the bytes back into a struct      (variables + arrays page)
//      - verify the signature with hashing       (hashing page)
//      - check inputs against the UTXO set       (hash maps; hashing page)
//      - if valid, gossip it to every peer       (networking page)
//
//   5. MINER INCLUDES TX IN A BLOCK
//      - the mempool is a hash map keyed by txid (hashing page)
//      - the miner picks high-fee txs into a candidate block
//      - hashes the block header repeatedly until a valid nonce is found
//
//   6. BLOCK GOSSIPED ACROSS THE NETWORK
//      - every node verifies the block independently
//      - if everything checks out, the block is added to the chain
//      - your tx now has one "confirmation"
//
// Every layer in here was a previous page on this site.

#include <stdint.h>
#include <string.h>
#include <unistd.h>

/*
 * A Bitcoin transaction in flight. The same byte stream that
 * travels from your wallet through the gossip network to the
 * miners. Each step uses a different page from this site.
 */

/* STEP 1: WALLET CREATES TX
 *   - allocates memory on the heap        (memory page)
 *   - fills with inputs, outputs, scripts */
typedef struct {
    uint8_t  *data;     /* heap-allocated byte array (arrays page) */
    uint32_t  length;
    uint32_t  capacity;
} ByteVec;

/* STEP 2: WALLET SIGNS TX
 *   - hashes the tx body with SHA-256     (hashing page)
 *   - signs the hash with ECDSA / Schnorr */
void sign_transaction(ByteVec *tx, const uint8_t privkey[32],
                      uint8_t sig_out[64]) {
    uint8_t tx_hash[32];
    SHA256(tx->data, tx->length, tx_hash); /* hashing page */
    ecdsa_sign(privkey, tx_hash, sig_out); /* cryptography */
}

/* STEP 3: WALLET BROADCASTS TX
 *   - opens a TCP socket to a node   (OS + networking pages)
 *   - writes serialised tx as bytes  (binary page)
 *   - kernel splits into IP packets  (networking page) */
int broadcast_transaction(const ByteVec *tx, const char *node_ip,
                          uint16_t port) {
    int sock = tcp_connect(node_ip, port); /* OS + pointers */
    if (sock < 0) return -1;

    struct BitcoinMessage msg = {
        .magic        = 0xD9B4BEF9,
        .payload_size = tx->length,
    };
    memcpy(msg.command, "tx\0\0\0\0\0\0\0\0\0\0", 12);
    SHA256d(tx->data, tx->length, msg.checksum); /* hashing page */

    write(sock, &msg, sizeof(msg));              /* networking page */
    write(sock, tx->data, tx->length);
    return sock;
}

/* STEP 4: NODES VALIDATE TX
 *   - parse bytes back into a struct   (variables + arrays page)
 *   - verify signature via hashing     (hashing page)
 *   - check the UTXO set (a hash map)  (hashing page)
 *   - gossip to peers if valid         (networking page)
 *
 * STEP 5: MINER INCLUDES IT IN A BLOCK
 *   - mempool is a hash map txid->tx   (hashing page)
 *   - mines the header until valid     (this page)
 *
 * STEP 6: BLOCK GOSSIPED AND CONFIRMED
 *   - every node verifies independently
 *   - your tx now has one confirmation
 *
 * Every layer in here was a previous page on this site. */

#include <stdint.h>

// What's on the wire between two Bitcoin nodes. Every `bitcoind` and
// `btcd` on the planet sends and receives exactly this:
struct BitcoinMessage {
    uint32_t magic;          // 0xD9B4BEF9 for mainnet
    char     command[12];    // "tx", "block", "inv", "version", ...
    uint32_t payload_size;
    uint32_t checksum;       // first 4 bytes of SHA-256(SHA-256(payload))
    uint8_t  payload[];      // the actual transaction or block bytes
};

// The payload is itself a binary-encoded struct: integers little-endian,
// strings length-prefixed, hashes raw 32-byte blobs. Same idea as every
// protocol in the networking page. The agreement is what makes it work.
//
// Strip the message wrapper: bytes.
// Strip the bytes: bits.
// Strip the bits: voltages on copper, photons on glass.
// All the way down to the transistor.

#include <stdint.h>

// What's on the wire between two Bitcoin nodes. Every `bitcoind` and
// `btcd` on the planet sends and receives exactly this:
struct BitcoinMessage {
    uint32_t magic;          // 0xD9B4BEF9 for mainnet
    char     command[12];    // "tx", "block", "inv", "version", ...
    uint32_t payload_size;
    uint32_t checksum;       // first 4 bytes of SHA-256(SHA-256(payload))
    uint8_t  payload[];      // the actual transaction or block bytes
};

// The payload is itself a binary-encoded struct: integers little-endian,
// strings length-prefixed, hashes raw 32-byte blobs. Same idea as every
// protocol in the networking page. The agreement is what makes it work.
//
// Strip the message wrapper: bytes.
// Strip the bytes: bits.
// Strip the bits: voltages on copper, photons on glass.
// All the way down to the transistor.