20 November 2026
The BIP process
29 new claims on the topic page
- Anyone may submit a BIP: BIP 3, the document that sets out the BIP process, states that BIPs may be submitted by anyone, provided the content is of high quality.
- As of block 976,761 (20 November 2026), BIP 2, "BIP process, revised", has Status Closed, and its preamble names BIP 3 as its replacement. BIP 2 had itself replaced BIP 1, the original BIP process document.
- Optech Newsletter #382 (28 November 2025) reported a motion on the Bitcoin-Dev mailing list to activate BIP 3 in place of BIP 2. bitcoin/bips pull request #1820, "Process: Activate BIP3", which applies the changes BIP 3 prescribes on activation, was merged on 14 January 2026.
- As of block 976,761 (20 November 2026), BIP 3, "Updated BIP Process", is the process document in force for the bitcoin/bips repository. Its preamble gives Status Deployed and Type Process, and the text says it replaces BIP 2 as the guideline for the BIP process.
- BIP 8 is an alternative to BIP 9 version bits that uses block heights instead of timestamps for start and timeout, and adds a lockinontimeout flag that, when set, requires blocks to signal in the final period so the soft fork locks in by the timeout height.
- BIP 9 specifies version bits: miners signal readiness for a soft fork by setting a bit in the block version, support is tallied each 2,016-block retarget period, and on mainnet a deployment locks in when at least 1,916 blocks (95%) of a period signal before its timeout.
- After a soft fork has activated, Bitcoin Core can replace its version bits deployment with a hardcoded activation height, called a buried deployment (BIP 90). As of Bitcoin Core master on 20 November 2026, CSV is buried at block 419,328 and segwit at block 481,824.
- Whether a wallet or node follows a given BIP depends on that software, not on the BIP. Bitcoin Core, for example, keeps a list of the BIPs it implements in doc/bips.md, and as of its master branch on 20 November 2026 that list includes BIP 32 but not BIP 39, the mnemonic seed phrase standard.
- In BIP 3, the Closed status marks BIPs that are only of historical significance. Closed BIPs are not deleted, and if a Draft BIP appears stalled for a year, anyone may propose that its status be changed to Closed.
- The soft fork combining BIP 68, BIP 112 and BIP 113 (often called CSV) was the first deployed with BIP 9 version bits: Bitcoin Core 0.12.1 signaled it on bit 0 from 1 May 2016, and its rules have been active on mainnet since block 419,328.
- Under BIP 3, any community member may request that a Complete BIP advance to Deployed by showing evidence that the BIP is in active use, and a Deployed BIP is considered final.
- BIP Editors, as BIP 3 describes them, check editorial criteria for a new BIP, such as prior discussion on the Bitcoin Development Mailing List and correct Layer and Type headers, then assign a number and merge. BIP 3 states that editors do not evaluate whether a proposal is likely to be adopted.
- BIP 3 cut the number of BIP status values from nine under BIP 2 to four: Draft, Complete, Deployed and Closed. A BIP in Complete status can only move to Deployed or Closed.
- A BIP's Layer header, when present, names the part of Bitcoin the BIP applies to, using the classification in BIP 123: the Consensus layer, the Peer Services layer, the API/RPC layer and the Applications layer.
- BIP 3 asks authors to present a first sketch of a proposal to the Bitcoin Development Mailing List and to avoid opening a pull request in the bitcoin/bips repository with a BIP draft out of the blue.
- According to BIP 3, the document that sets out the BIP process, no formal or informal decision body governs Bitcoin development or decides whether BIPs are adopted.
- BIP 3 states that BIPs do not define what Bitcoin is, that individual BIPs do not represent Bitcoin community consensus, and that a BIP is a personal recommendation by its authors to the Bitcoin community.
- A BIP number does not mean Bitcoin adopted a proposal. The bitcoin/bips README says publishing a BIP there shows it is in scope and met formal criteria, but not that it is a good idea, has community consensus or is about to be adopted.
- Authors do not choose their own BIP numbers. Under BIP 3, only BIP Editors may assign a number, and a number counts as assigned only after a BIP Editor has announced it publicly in the proposal's pull request to the bitcoin/bips repository.
- Process BIPs follow a different rule for becoming Deployed: under BIP 3, a Process BIP moves from Complete to Deployed when it reaches rough consensus on the Bitcoin Development Mailing List, after its advancement has been open to discussion there for at least one month.
- Under BIP 3, the bitcoin/bips repository does not track sentiment about proposals or their adoption beyond whether a BIP is in active use. BIP 3 encourages individual Bitcoin projects to publish lists of the BIPs they implement.
- Segregated witness (BIP 141) was deployed with BIP 9 version bits on bit 1, released in Bitcoin Core 0.13.1 with a signaling start of 15 November 2016, and its rules have been active on mainnet since block 481,824.
- BIP 3 notes that some BIPs may never be adopted, some may be adopted by one or more Bitcoin clients or related software, and some may end up changing the consensus rules the Bitcoin ecosystem jointly enforces.
- BIP 3 supersedes BIP 2's Standards Track type, used for changes affecting most or all Bitcoin implementations, with the similar Specification type. On BIP 3's activation, Standards Track BIPs and eligible Informational BIPs are assigned the Specification type.
- The Taproot soft fork activated on mainnet at block 709,632 through Speedy Trial, a variation of BIP 9 version bits released in Bitcoin Core 0.21.1, with a lock-in threshold of 1,815 of 2,016 blocks (90%) and a minimum activation height of block 709,632.
- As of Bitcoin Core master on 20 November 2026, GetBlockScriptFlags in src/validation.cpp turns on the P2SH, segwit and Taproot script rules for every block except two listed exceptions, because only one historical mainnet block violated the Taproot rules and one violated P2SH.
- BIP 3 defines three BIP types: a Specification BIP sets technical rules for a new feature or for interoperability between implementations, an Informational BIP describes a design issue or gives guidelines or information, and a Process BIP describes or changes a process surrounding Bitcoin.
- The bitcoin/bips repository README states that acceptance and adoption of a BIP ultimately rest with Bitcoin users, and BIP 3 says that once a BIP is Complete it is up to the Bitcoin community to evaluate, adopt, ignore or reject it.
- A Bitcoin Improvement Proposal (BIP) is an improvement proposal for Bitcoin. BIP 3, the process document, says most BIPs give a concise, self-contained technical description of one new concept, feature or standard.
The fee market and mempool policy
25 new claims on the topic page
- BIP 125 specifies opt-in replace-by-fee: a transaction signals that it may be replaced if any of its inputs has an nSequence value below 0xfffffffe, and BIP 125 caps the transactions a replacement may evict, counting their descendants, at 100.
- Bitcoin Core's wallet has a bumpfee command that replaces an unconfirmed wallet transaction with a new version paying a higher fee, taking the extra fee from change outputs or by adding inputs when necessary.
- Bitcoin Core 31.0, published on 19 April 2026, reimplemented the mempool as a "cluster mempool": it groups connected unconfirmed transactions into clusters, by default at most 64 transactions and 101 kvB each, and drops the earlier ancestor and descendant limits.
- Bitcoin Core's relay policy is a set of rules a node applies, in addition to consensus rules, to unconfirmed transactions before accepting them into its mempool. Policy is local to each node and configurable, and it is not applied to transactions in blocks, so a block can contain transactions a node would not have relayed.
- Bitcoin Core 31.0 removed the CPFP carve-out, which had let one extra small child join a package already at its descendant limit. The release notes say contract protocols needing similar behavior are expected to use TRUC transactions and sibling eviction instead.
- Child pays for parent (CPFP) is a way to speed up a stuck, low fee rate Bitcoin transaction: someone who controls one of its outputs spends that output in a new child transaction with a high fee rate, which encourages miners to include both transactions in a block.
- A Bitcoin transaction's fee is not a separate field: it is the total value of the transaction's inputs minus the total value of its outputs. Bitcoin Core's consensus code computes the fee this way and rejects as invalid a transaction that spends inputs worth less than its outputs.
- CBlockPolicyEstimator, a fee estimator in Bitcoin Core's src/policy/fees/block_policy_estimator.h, estimates the fee rate a transaction needs to be confirmed within a target number of blocks by grouping observed transactions into buckets of similar fee rates and tracking how quickly each bucket confirms.
- Bitcoin fee rates are usually quoted in satoshis per virtual byte (sat/vB). BIP 141 defines a transaction's virtual size as its weight divided by 4, rounded up, so the same fee rate costs a larger transaction more sats in total.
- Bitcoin Core 28.0, published on 2 October 2024, changed the default of the -mempoolfullrbf option from 0 to 1 (Bitcoin Core PR #30493), so nodes running defaults accept replacements of unconfirmed transactions whether or not they signal BIP 125 replaceability.
- Bitcoin Core 29.0 removed the -mempoolfullrbf option (Bitcoin Core PR #30592), making full replace-by-fee the standard behavior. Since then, Bitcoin Core's replacement rules no longer require a transaction to signal BIP 125 replaceability before it can be replaced.
- Bitcoin blocks have limited space: a consensus rule caps each block at 4,000,000 weight units. Because more transactions can be waiting than fit in the next block, users attach fees to compete for inclusion, and transactions paying higher fee rates are generally mined first.
- A mempool (short for memory pool) is the set of valid but unconfirmed transactions that a Bitcoin node holds while they wait to be mined. Each node keeps its own mempool under its own local rules, so there is no single network-wide mempool.
- Bitcoin Core removes a transaction from its mempool if it is still unconfirmed 336 hours (14 days) after entering, by default. The limit is set by the -mempoolexpiry option, so other nodes may keep or drop the same transaction at different times.
- Bitcoin Core limits its mempool to 300 MB of memory by default (the -maxmempool option). When the mempool is full, a node starts rejecting new transactions below a minimum fee rate threshold and evicts low fee rate transactions, so a low-fee transaction can drop out of some nodes' mempools.
- Since Bitcoin Core 30.0, published on 10 October 2025, the default minimum relay fee rate (-minrelaytxfee) and incremental relay fee rate (-incrementalrelayfee) are both 0.1 sat/vB, set in the code as 100 satoshis per 1,000 vB.
- Since Bitcoin Core 28.0, a node that receives a transaction paying too low a fee rate for its mempool can pair it with a child transaction and evaluate both as a package (1-parent-1-child package relay), so a child can pay for a parent that would otherwise be rejected. The release notes call this feature limited and not yet reliable under adversarial conditions.
- Transaction pinning is when an attacker exploits limits in mempool relay policy to stop an incentive-compatible transaction from being accepted or fee-bumped. BIP 431's TRUC rules (also called version 3 transaction relay) were designed to make pinning harder for contract protocols such as Lightning, where parties sign time-sensitive transactions to broadcast later.
- Because relay policy differs from node to node, a transaction one node accepts may not reach miners. The Bitcoin Core 30.0 release notes warn that transactions created with the newly allowed lower fee rates are not guaranteed to propagate or confirm unless the lower defaults are widely adopted across the network.
- Replace-by-fee (RBF) is a node relay policy that lets an unconfirmed Bitcoin transaction be replaced by a different transaction spending at least one of the same inputs and paying a higher fee. A sender can use RBF to speed up a stuck transaction.
- Since Bitcoin Core 31.0, a replacement is accepted only if the mempool's feerate diagram is strictly better afterward, a check performed by the function ImprovesFeerateDiagram, declared in src/policy/rbf.h. The release notes say this eliminates all known cases where replacements left the mempool worse off.
- Under Bitcoin Core's replacement rules, a replacement transaction must pay at least the total absolute fee of the transactions it replaces, plus enough extra to pay for its own size at the incremental relay fee rate: at 0.1 sat/vB, a 500 vB replacement must add at least 50 sats.
- A Bitcoin transaction can stay unconfirmed for a long time when its fee rate is low compared with other transactions waiting to be mined, because transactions paying higher fee rates are generally mined first. Since Bitcoin Core 31.0, its block templates select mempool transactions in order of the fee rate at which they are expected to be mined.
- BIP 431 defines TRUC (Topologically Restricted Until Confirmation) transactions: a transaction with version 3 opts into rules that, while it is unconfirmed, allow at most one unconfirmed parent or child, cap its size at 10,000 vB, and cap a TRUC child of an unconfirmed TRUC parent at 1,000 vB.
- Since Bitcoin Core 28.0, version 3 transactions are standard on all networks, subject to the opt-in TRUC (Topologically Restricted Until Confirmation) policy of BIP 431 (Bitcoin Core PR #29496).
Halvings and the supply schedule
23 new claims on the topic page
- Bitcoin halvings are counted in blocks, not dates: the subsidy halves every 210,000 blocks, which Bitcoin Core's source code describes as occurring approximately every four years.
- Blocks 91,842 and 91,880 contain coinbase transactions identical to earlier ones, which was possible before BIP 30 because early coinbases were easy to duplicate. BIP 30 forbids such duplicates in all blocks except these two, and Bitcoin Core exempts them in IsBIP30Repeat.
- The 50 BTC coinbase outputs of blocks 91,722 and 91,812 can never be spent, because identical coinbases mined later, in blocks 91,842 and 91,880, overwrote them. Bitcoin Core marks them in IsBIP30Unspendable, and gettxoutsetinfo with coinstatsindex reports them in its bip30 total.
- BIP 34 requires each block's height as the first item of its coinbase scriptSig, a rule its stated motivation ties to enforcing block and transaction uniqueness. Bitcoin Core's mainnet parameters set BIP34Height to block 227,931.
- BIP 34 does not rule out every duplicate coinbase: some early coinbases could be replayed in future blocks, so Bitcoin Core enforces BIP 30 checks again from block 1,983,702 on. BIP 54 (consensus cleanup), a proposed soft fork whose BIP status is Complete as of 20 November 2026, specifies that each coinbase's nLockTime equal the block height minus 1.
- A Bitcoin miner pays itself through the block's coinbase transaction, which may claim at most the block subsidy plus the fees of the block's transactions. Nodes reject a block whose coinbase claims more than that total.
- As of block 976,751 (20 November 2026), Bitcoin's block subsidy is 3.125 BTC (312,500,000 sats) per block, the amount set by the fourth halving at block 840,000.
- The amount of bitcoin in existence is not a function of block height alone, because some allowed rewards were never claimed and some issued coins are provably unspendable. A Bitcoin Core node reports the total from its own UTXO set: the gettxoutsetinfo RPC returns total_amount, the total of all unspent outputs.
- A 2026 Cambridge Centre for Alternative Finance report found that transaction fees averaged 0.67% of Bitcoin miner revenue in the 90 days to 4 October 2026, the rest coming from the block subsidy, and that fees had rarely exceeded 5% of miner revenue since 2010.
- Bitcoin's first halving took effect at block 210,000, timestamped 28 November 2012, cutting the block subsidy from 50 BTC to 25 BTC per block.
- Bitcoin's fourth halving took effect at block 840,000, timestamped 20 April 2024, cutting the block subsidy from 6.25 BTC to 3.125 BTC per block.
- The 50 BTC coinbase of Bitcoin's genesis block cannot be spent: Bitcoin Core skips connecting the genesis block's transactions, so that output never enters the UTXO set, and gettxoutsetinfo lists it as unspendable.
- Bitcoin Core's MAX_MONEY constant of 21,000,000 BTC is a sanity check on amounts, not the total money supply: its source comment says the supply in Bitcoin currently happens to be less than 21,000,000 BTC for various reasons.
- Bitcoin's fifth halving is set by the 210,000-block interval to take effect at block 1,050,000, cutting the block subsidy from 3.125 BTC to 1.5625 BTC. As of block 976,751, that height is 73,249 blocks away.
- Bitcoin's second halving took effect at block 420,000, timestamped 9 July 2016, cutting the block subsidy from 25 BTC to 12.5 BTC per block.
- BIP 42 noted that Bitcoin's subsidy code shifted by the halving count, a shift undefined in C++ from 64 on, so the subsidy could repeat its cycle every 64 halvings. Bitcoin Core's GetBlockSubsidy now returns zero from 64 halvings on, keeping the supply finite.
- Bitcoin's block subsidy started at 50 BTC per block: the genesis block was created with a 50 BTC coinbase, and the rules allowed a 50 BTC subsidy for every block up to block 209,999.
- Because Bitcoin's 50 BTC starting subsidy is 5,000,000,000 sats, shifting it right 32 times leaves 1 sat and 33 times leaves 0. The subsidy is therefore 1 sat for blocks 6,720,000 to 6,929,999 and zero from block 6,930,000 on.
- Bitcoin Core computes the block subsidy in GetBlockSubsidy (src/validation.cpp): it divides the height by nSubsidyHalvingInterval, which mainnet sets to 210,000, and shifts 50 BTC, expressed in satoshis, right by that many halvings.
- Bitcoin's third halving took effect at block 630,000, timestamped 11 May 2020, cutting the block subsidy from 12.5 BTC to 6.25 BTC per block.
- If every block claimed its full subsidy, Bitcoin's schedule would issue 2,099,999,997,690,000 sats (20,999,999.9769 BTC) in total, 0.0231 BTC under 21 million, because each halving shifts the subsidy in whole satoshis and drops any half satoshi.
- Bitcoin's consensus rules cap a coinbase's claim at subsidy plus fees but set no minimum, so a miner can claim less. An amount left unclaimed is never paid to anyone, and Bitcoin Core's gettxoutsetinfo reports such amounts under unclaimed_rewards.
- New bitcoin enter circulation only through the block subsidy: a fixed amount the miner of each block may pay itself, on top of the block's transaction fees. Bitcoin's rules cut the subsidy in half every 210,000 blocks, an event called a halving.
Lightning Network
33 new claims on the topic page
- In BOLT 3's anchor commitment format (feature option_anchors, bits 22/23 in BOLT 9), each anchor output on a Lightning commitment transaction is fixed at 330 sats, which BOLT 3 gives as the default dust limit for P2WSH outputs.
- A Lightning recipient can request a payment with an invoice in the BOLT 11 format, a QR-code-ready payment request. On Bitcoin mainnet a BOLT 11 invoice starts with the prefix "lnbc".
- The offers protocol was added to the Lightning specification as BOLT 12 when BOLTs pull request #798 was merged on 24 September 2024, as reported in Optech's newsletter of 4 October 2024.
- The Lightning protocol is specified in the BOLT documents of the lightning/bolts repository, a set of numbered files including BOLT 2 (peer protocol), BOLT 3 (transactions), BOLT 4 (onion routing), BOLT 7 (gossip), BOLT 11 (invoices) and BOLT 12 (offers), as of 20 November 2026.
- A Lightning payment channel is shared between two peers, who move funds between their sides of the channel off-chain by exchanging signatures on an updated transaction, without broadcasting each update to the Bitcoin network.
- In LND, the wallet seed alone recovers only on-chain funds. Recovering funds held in open channels also needs a Static Channel Backup (SCB), which lets the node reconnect to its peers and use the protocol's Data Loss Protection feature so the peers close those channels.
- Channel jamming is a denial-of-service attack on Lightning in which an attacker sends payments that it delays settling, tying up the funds or the pending-payment slots of channels along a route of up to 20 hops so honest payments cannot use them.
- Each Lightning channel update creates new commitment transactions and revokes the old ones: a peer revokes an old commitment by revealing its revocation secret, after which the other peer can claim that commitment's delayed output immediately if it is ever broadcast.
- In a custodial Lightning wallet, a third party controls custody of the funds and the user relies on that party. In a self-custodial (noncustodial) Lightning wallet, the keys are stored locally under the user's control.
- The book Mastering the Lightning Network describes custodial Lightning wallets as the least technically demanding option, and describes control over keys as a principal consideration when choosing a Lightning wallet.
- A Lightning channel opens with an on-chain funding transaction whose channel output, in BOLT 3, pays to a 2-of-2 multisignature script built from the two peers' funding public keys, ordered lexicographically, so it can only be spent with both peers' signatures.
- Lightning nodes learn about public channels and other nodes through gossip messages specified in BOLT 7, which defines three gossip messages for channel and node discovery, including a channel announcement that proves a channel exists between two nodes.
- A Hashed Time Locked Contract (HTLC) is a conditional Lightning payment between two peers, carried as an output of the commitment transaction: the recipient claims it with a signature and the payment preimage, or else the payer reclaims it after a set time.
- BOLT 2 lets a Lightning node accept at most 483 pending payments (HTLCs) from its channel peer, or 114 on zero_fee_commitments channels. Optech's channel jamming topic describes how the 483 limit enables HTLC jamming: an attacker sends 483 small payments and leaves them unsettled, filling the slots while locking little value.
- LND (the Lightning Network Daemon), Core Lightning (previously c-lightning), Eclair (written in Scala) and LDK (the rust-lightning project) are implementations of the Lightning protocol, each developed in its own repository as of 20 November 2026.
- To receive over Lightning, a node needs inbound liquidity: funds on the peer's side of its channels. A channel the node opens and funds by itself typically starts with the balance on the node's own side, so the node can send through that channel before it can receive.
- A BOLT 11 Lightning invoice expires: its optional expiry field gives a time in seconds, and when the field is absent the specification sets the expiry to 3,600 seconds (1 hour).
- Which defense against Lightning channel jamming, if any, will the BOLTs specify? As of 20 November 2026 this is unresolved. Optech records proposals from 2019 to 2026, including upfront fees and local reputation, and reported LND's experimental reputation scoring in October 2026. A merged BOLTs change would settle it.
- A Lightning payment can travel through intermediate nodes using conditional payments locked to a hash. Each hop is paid when the final recipient releases the matching secret, called the payment preimage, which also serves the sender as proof of payment.
- A Lightning payment can be split into several parts sent over different routes and combined by the recipient. BOLT 9 signals this with the basic_mpp feature (bits 16/17), meaning a node can receive basic multi-part payments.
- BOLT 12 offers are longer-lived Lightning payment requests, encoded with the prefix "lno", from which a payer requests a fresh invoice over the Lightning Network itself. BOLT 12 uses blinded paths in place of BOLT 11's payment_secret and payment_metadata.
- Restoring a Lightning node from a copy of its channel database is risky, because the copy may not hold the latest channel state. Broadcasting an old, revoked commitment transaction lets the channel peer claim all of that commitment's outputs with a penalty transaction.
- Lightning payments are routed with onion encryption based on the Sphinx construction, specified in BOLT 4. The onion packet's hop payloads are a fixed 1,300 bytes, and an intermediate node cannot learn which other nodes, besides its predecessor and successor, are on the route.
- A Lightning payment attempt can fail because the sender cannot see how funds are split inside other people's channels. When a channel on the chosen route lacks enough funds on the forwarding side for the amount, that attempt fails.
- Each Lightning node that forwards a payment can charge a routing fee, set per channel as a fixed base fee in millisatoshis plus a proportional fee in millionths of the amount forwarded, as specified in BOLT 7.
- As of 20 November 2026, the lightning/bolts repository holds an extension document, "Simple Taproot Channels", created 20 April 2022, in which the channel's multisignature funding output becomes a single P2TR key formed with MuSig2 key aggregation. It is outside the numbered BOLTs.
- Splicing, specified in BOLT 2, replaces a Lightning channel's funding transaction with a new one, which lets the peers add funds to or remove funds from an open channel without closing it. BOLT 9 assigns it the option_splice feature bits 62/63.
- The splicing protocol was merged into the Lightning specification on 23 March 2026 through BOLTs pull request #1160, "Channel Splicing (feature 62/63)", which replaced the earlier draft in BOLTs pull request #863.
- In BOLT 3, the outputs of a Lightning commitment transaction that return funds to the peer who broadcast it are delayed by to_self_delay blocks, a value the other peer sets in BOLT 2, giving that other peer time to spot a revoked commitment and claim the funds.
- A self-custodial Lightning node must have the Bitcoin blockchain watched, by itself or through a watchtower, for transactions that spend its channels, so it can respond with a penalty transaction if a peer broadcasts an old channel state. A node that is offline during such an attempt, with no watchtower, can lose funds.
- A Lightning watchtower is a service that monitors the Bitcoin blockchain on a user's behalf and broadcasts a penalty transaction if a channel peer publishes an outdated channel state, so the user can go offline for significant amounts of time.
- The Lightning Network is a protocol for fast bitcoin payments over a network of payment channels between pairs of nodes. Payments move off-chain, and Bitcoin transactions are used to open channels and to enforce their balances when the parties do not cooperate.
- As of 20 November 2026, BOLT 9 in the lightning/bolts repository assigns feature bits 40/41 to zero_fee_commitments, a Lightning channel type whose commitment and HTLC transactions pay zero fees, and points to BOLT 3's shared anchor output for it.
Proof of work and difficulty
26 new claims on the topic page
- Each block mined on top of a Bitcoin transaction adds work that anyone trying to reverse it must redo: the Bitcoin whitepaper says an attacker would have to redo the proof of work of that block and every later block, then overtake the honest chain.
- Bitcoin nodes do not let miners pick their own difficulty: Bitcoin Core's ContextualCheckBlockHeader rejects a header as "bad-diffbits" unless its nBits equals the value GetNextWorkRequired computes from the preceding chain.
- As of 20 November 2026, Bitcoin Core PR #35793, "Implement BIP 54 (Consensus Cleanup) without mainnet activation", is open and not merged; its description says the BIP 54 validation rules it implements are only enabled on regtest, with mainnet activation, if any, to be considered separately.
- BIP 54 proposes that the first block of each 2,016-block difficulty period (height divisible by 2,016) must have a timestamp no earlier than 7,200 seconds (two hours) before the timestamp of the block immediately preceding it, which the BIP gives as its fix for the timewarp attack.
- BIP 94 (Testnet 4) adds a timewarp rule: the first block of each difficulty period must not be timestamped more than 600 seconds before the previous block. Bitcoin Core enforces this rule only on testnet4 and regtest; its mainnet parameters set enforce_BIP94 to false.
- At the retarget at block 32,256, mined on 30 December 2009, Bitcoin's nBits changed from 0x1d00ffff (block 32,255) to 0x1d00d86a, raising mining difficulty from 1 to about 1.18.
- A 2018 statistical study of Bitcoin block arrival data (arXiv:1801.07447) reported that block arrivals do not follow the homogeneous Poisson process it says the original Bitcoin paper suggested, and proposed a refined model covering both periods of constant difficulty and how difficulty changes over time.
- Bitcoin Core counts each block's work as 2 to the power 256 divided by (target plus 1), the expected number of hashes needed to meet that target, and sums these values along a chain into nChainWork, the chainwork figure that decides which chain is best.
- Bitcoin limits each difficulty adjustment to a factor of four: Bitcoin Core clamps the measured timespan of a 2,016-block period to between one quarter and four times the two-week target before retargeting, so one retarget can at most quadruple or quarter the target.
- Bitcoin's mainnet difficulty can change only at every 2,016th block, so when total mining power rises or falls between adjustments, blocks arrive faster or slower than 10 minutes on average until the next adjustment.
- A Bitcoin block's hash is the double SHA-256 (SHA-256 applied twice) of its serialized header: Bitcoin Core's CBlockHeader::GetHash writes the header into a HashWriter, whose GetHash computes double SHA-256.
- Bitcoin mining costs real resources: the Bitcoin whitepaper compares issuing new coins through mining to gold miners spending resources, and names computer time and electricity as what Bitcoin miners spend.
- Bitcoin's genesis block (block 0, timestamp 1231006505, 3 January 2009) has nBits 0x1d00ffff, the compact form of mainnet's easiest permitted target, which corresponds to difficulty 1.
- Bitcoin Core's proof-of-work check in src/pow.cpp rejects a block header if the target decoded from its nBits is zero, negative, overflowing or above the network's proof-of-work limit, or if the header hash, read as a 256-bit number, is greater than that target.
- A Bitcoin block header is 80 bytes: Bitcoin Core serializes six fields, nVersion (4 bytes), hashPrevBlock (32 bytes), hashMerkleRoot (32 bytes), nTime (4 bytes), nBits (4 bytes) and nNonce (4 bytes), and proof of work is computed over these 80 bytes only.
- Bitcoin Core rejects a block whose timestamp is not later than the median time past, which is the median of the timestamps of the previous 11 blocks, ending with the new block's parent.
- At commit f498a5a6, Bitcoin Core's GetMinimumTime raises the minimum block template timestamp on all networks to respect both the BIP 94 600-second timewarp limit and the BIP 54 rule that a period's last block is not earlier than its first; the BIP 54 part came from Bitcoin Core PR #35949, merged 7 September 2026.
- Bitcoin Core's mainnet parameters set nMinimumChainWork, a minimum total chain work documented in the code with the comment that the best chain should have at least this much work; at commit f498a5a6 its mainnet value is 0x145ec036acc5ba740052af1a0.
- Bitcoin nodes follow the valid chain with the most accumulated proof of work, not the chain with the most blocks: Bitcoin Core ranks candidate chain tips first by total chain work, so a shorter chain of harder blocks can outrank a longer chain of easier ones.
- A Bitcoin header's 4-byte nBits field encodes the 256-bit target in a compact floating-point-like form: the top byte is an exponent in base 256 and the lower 23 bits are the mantissa, so the target equals mantissa times 256 to the power of (exponent minus 3).
- At each mainnet retarget, Bitcoin Core's CalculateNextWorkRequired multiplies the previous target by the period's measured timespan, first limited to between one quarter and four times two weeks, divides by the two-week target timespan, and caps the result at the proof-of-work limit, so faster periods make the target smaller and mining harder.
- Bitcoin mainnet recalculates its proof-of-work target every 2,016 blocks: Bitcoin Core derives this interval as the target timespan of two weeks (1,209,600 seconds) divided by the target block spacing of 600 seconds.
- Bitcoin Core measures each 2,016-block difficulty period from the timestamp of its own first block to that of its last block, which spans 2,015 block intervals rather than 2,016, so consecutive measurement windows do not overlap. This off-by-one is the property the timewarp attack exploits.
- Bitcoin aims for one block about every 10 minutes on average: the network adjusts how hard mining is so that, as more or less computing power joins, blocks keep arriving at roughly that rate.
- BIP 54 (Consensus Cleanup) states that the timewarp bug lets an attacker with a majority of Bitcoin's hashrate arbitrarily lower mining difficulty by manipulating block timestamps, and that in the worst case the attacker can bring difficulty to its minimum within 38 days.
- Bitcoin mining is a guessing search: miners repeatedly change a number in a candidate block and hash it with SHA-256 until the result is at or below a target, and only a block that meets the target can extend the chain.
Segregated Witness (SegWit)
29 new claims on the topic page
- How much did each 2017 event, including BIP 148 and BIP 91, contribute to SegWit's activation? Bitcoin Optech describes this as remaining "a subject of debate"; the chain records which blocks signaled, but not why their miners chose to signal.
- SegWit's consensus rules have been enforced on the Bitcoin mainnet since block 481,824, mined on 24 August 2017, and Bitcoin Core records that height together with the block's hash in its mainnet parameters.
- BIP 173 states that the Bech32 checksum used by native SegWit addresses guarantees detection of any error affecting at most 4 characters; BIP 350 later described a weakness with inserted or deleted characters, which it says does not affect version 0 addresses because they are restricted to two specific lengths.
- BIP 350 keeps the original Bech32 encoding for SegWit version 0 addresses (P2WPKH and P2WSH) and specifies a modified checksum, Bech32m, for addresses of witness version 1 and later, such as Taproot addresses.
- BIP 143 defines a new signature hash for SegWit version 0 inputs that reduces redundant hashing during verification, avoiding legacy signature hashing's quadratic growth, and that commits to the input amount; Bitcoin Core implements it in SignatureHash for SigVersion::WITNESS_V0.
- BIP 144 specifies how SegWit data travels between nodes: an extended transaction serialization with a zero marker byte and a nonzero flag byte, new getdata types for requesting witness data, and a service bit with which a node signals it can serve witnesses.
- BIP 145 updates the getblocktemplate JSON-RPC call that mining software uses so that block templates support SegWit, including a block weight limit field and a per-transaction weight field.
- SegWit was deployed with BIP 9 version bits on bit 1, with a mainnet signaling window from 15 November 2016 to 15 November 2017: if 95% of blocks in a 2,016-block retarget period signaled, it would lock in, and activate 2,016 blocks later.
- According to Bitcoin Optech's account of the 2017 deployment, BIP 91 locked in and activated first, SegWit's own BIP 9 deployment then locked in and activated, and BIP 148's mandatory signaling expired when SegWit locked in.
- Since SegWit, a Bitcoin block's size limit is expressed in weight units: weight is the block's size without witness data times 3 plus its full size, and a valid block may weigh at most 4,000,000 weight units (BIP 141).
- Bitcoin Core PR #16060, merged on 15 August 2019, replaced SegWit's BIP 9 deployment logic with a hardcoded activation height ("burying" the deployment); as of block 976,753, Bitcoin Core's mainnet parameters carry SegwitHeight = 481824 rather than version-bits parameters for SegWit.
- As of block 976,753, the default for Bitcoin Core's -addresstype wallet option is bech32 (native SegWit); the Bitcoin Core 0.20.0 release notes record the change that made the wallet use bech32 addresses by default when used through RPC and create native SegWit change outputs.
- The SegWit implementation entered Bitcoin Core's master branch through PR #8149, "Segregated witness rebased", a rebased and squashed version of PR #7910, merged on 24 June 2016 and later shipped with mainnet deployment parameters in Bitcoin Core 0.13.1.
- BIP 141 presents SegWit's malleability fix as what allows chains of unconfirmed transactions to be built without trusting the counterparty, a building block it names for payment networks such as the Lightning Network.
- Under BIP 143, each signature on a SegWit version 0 input commits to the amount of the input it signs, which BIP 143 says lets an offline signing device learn that amount from an untrusted source; Bitcoin Optech reported in June 2020 that this proved insufficient against a fee overpayment attack on multi-input transactions.
- The Lightning specification (BOLT 3) requires a channel's funding output to be a SegWit pay-to-witness-script-hash (P2WSH) output locking a 2-of-2 multisignature script of the two parties' funding keys.
- Because a SegWit transaction's signatures sit in the witness, which the txid does not cover, changing how the transaction was signed no longer changes its txid; BIP 141 states this prevents involuntary malleability for any type of script as long as all inputs are signed.
- Native SegWit version 0 addresses on the Bitcoin mainnet use the Bech32 format defined in BIP 173 and start with "bc1q", for example the BIP's sample P2WPKH address bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4; BIP 173 requires encoders to output them in lowercase.
- For a typical transaction with one input and two outputs, Bitcoin Optech calculated in April 2019 that spending a native SegWit (P2WPKH) output takes 141 vbytes against 220 vbytes for a legacy P2PKH output, about 35% less, so the same fee rate in sat/vB costs less in total.
- Taproot (BIP 341) defines rules for SegWit witness version 1: a Taproot output is a native SegWit output with witness version 1 and a 32-byte program, which Bitcoin Core checks in VerifyWitnessProgram.
- Under BIP 141 every transaction has two identifiers: the txid, the double SHA-256 of the serialization without witness data (unchanged from before SegWit), and the wtxid, the double SHA-256 of the serialization that includes the witness.
- In Bitcoin Core's VerifyWitnessProgram, when the SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM flag is set, a spend of a witness program with a not-yet-defined version fails with an error instead of succeeding as it does under consensus rules alone.
- A version 0 witness program with a 20-byte program is a pay-to-witness-public-key-hash (P2WPKH) output and one with a 32-byte program is a pay-to-witness-script-hash (P2WSH) output; Bitcoin Core checks these sizes in VerifyWitnessProgram in src/script/interpreter.cpp.
- BIP 141 defines a transaction's virtual size, measured in vbytes, as its transaction weight divided by 4 and rounded up to the next integer.
- Segregated Witness (SegWit) is a Bitcoin soft fork, activated in 2017, that moves the signature data of a transaction (its "witness") into a separate structure that blocks commit to apart from the transaction data that the transaction ID covers.
- A SegWit block commits to its witness data through a commitment in an output script of its coinbase transaction; Bitcoin Core verifies it in CheckWitnessMalleation in src/validation.cpp and rejects a mismatching block with the reason "bad-witness-merkle-match".
- Under SegWit's weight formula, each byte of non-witness transaction data counts as 4 weight units and each byte of witness data counts as 1; Bitcoin Core names this factor of 4 WITNESS_SCALE_FACTOR.
- In BIP 141, an output script (or P2SH redeem script) made of a 1-byte push opcode from OP_0 to OP_16 followed by a single direct data push of 2 to 40 bytes has a special meaning: the first push is the version byte and the pushed bytes are the witness program.
- BIP 141 reserves witness versions 1 to 16 for future extensions and leaves their programs uninterpreted, so nodes that predate a new version accept its spends; later soft forks can then give a version new rules without breaking older nodes.
Taproot
26 new claims on the topic page
- Taproot activated on Bitcoin mainnet at block 709,632, which was mined on 14 November 2021 with a block timestamp of 05:15:27 UTC.
- On Bitcoin mainnet, a Taproot (P2TR) address starts with "bc1p" and is 62 characters long, and it is encoded with bech32m, the address format BIP 350 defines for SegWit version 1 and later outputs.
- BIP 340 specifies the Schnorr signatures Taproot uses: 64-byte signatures over the secp256k1 curve, verified against 32-byte public keys that encode only the X coordinate of the curve point.
- Since Bitcoin Core PR #23536, merged on 25 March 2022, Bitcoin Core enforces Taproot's script rules on every block where SegWit rules apply, including blocks before 709,632, regardless of the version bits deployment status, with one exception block.
- BIP 342 Tapscript disables OP_CHECKMULTISIG and OP_CHECKMULTISIGVERIFY and adds OP_CHECKSIGADD (opcode 0xba), which checks one signature and adds the result to a running count, so threshold scripts check signatures one at a time.
- In a Taproot script path spend, the last witness element is the control block: 33 bytes plus 32 bytes for each Merkle path node, and Bitcoin Core accepts at most 128 path nodes, which limits a script tree to a depth of 128.
- Bitcoin Core's mainnet parameters exempt block 692,261, mined in July 2021 before Taproot activated, from Taproot script verification, checking it only with the P2SH and SegWit script flags, because that block fails the Taproot rules.
- BIP 341 chooses between the two ways of spending a Taproot output by counting witness elements after removing any annex: exactly one element means a key path spend, and two or more mean a script path spend.
- When a Taproot output is spent with its key path (a signature for the output's public key), the spend does not reveal whether any alternative script conditions existed for that output.
- A Taproot key path spend reveals no script: its witness carries a single Schnorr signature, checked against the 32-byte public key already in the output being spent.
- Taproot locked in during June 2021: Optech Newsletter #153, published on 16 June 2021, reported that signaling miners had locked in the soft fork the previous weekend, about five months before it activated at block 709,632.
- Bitcoin Core PR #19953, which implemented validation of BIP 340, BIP 341 and BIP 342, was merged on 15 October 2020 without any signing or wallet support.
- A Taproot output controlled by several signers through key aggregation, such as MuSig2 (BIP 327), can be spent with one aggregate key and one signature, so on chain it is indistinguishable from a single-signer Taproot output.
- BIP 342 renames opcode numbers 80, 98, 126 to 129, 131 to 134, 137, 138, 141, 142, 149 to 153 and 187 to 254 as OP_SUCCESSx: if a Tapscript contains any of them, validation succeeds without applying the other rules, which BIP 342 describes as a mechanism to upgrade the Script system.
- For a Taproot output with a script tree, the output key is an internal public key tweaked with the tree's Merkle root, and Bitcoin Core checks a script path spend in VerifyTaprootCommitment by recomputing that root and verifying the tweak.
- BIP 340 describes Schnorr signatures as linear, a property that lets several collaborating parties produce one signature that is valid for the sum of their public keys.
- When a Taproot output is spent through one of its committed scripts, only that script is published on chain and the other committed scripts stay hidden, though the spend does show that a script path existed and that the key path was not used.
- Each leaf of a Taproot script tree pairs a script with a leaf version, so later soft forks can introduce new script versions; Tapscript as defined in BIP 342 uses leaf version 0xc0.
- The BIP 341 signature message for Taproot spends is computed in Bitcoin Core by SignatureHashSchnorr in src/script/interpreter.cpp, which hashes it with the BIP 340 tagged hash "TapSighash".
- Taproot was activated with Speedy Trial, a variant of BIP 9 version bits signaling: if 90% of blocks (1,815 of 2,016) in a retarget period signaled on bit 2 between 24 April and 11 August 2021, Taproot would lock in and then activate no earlier than block 709,632.
- Taproot's Speedy Trial activation parameters were added to Bitcoin Core in PR #21686, merged on 15 April 2021, shortly after PR #21377 added Speedy Trial support to the version bits code the same day.
- BIP 342 removes two limits of earlier Bitcoin script for Tapscript: the maximum script size of 10,000 bytes and the limit of 201 non-push opcodes per script.
- The Taproot soft fork consists of three BIPs deployed together: BIP 340 for Schnorr signatures, BIP 341 for the spending rules of SegWit version 1 outputs, and BIP 342 for Tapscript, the script language used inside Taproot.
- As of Bitcoin Core commit f498a5a6 (November 2026), the mainnet MinBIP9WarningHeight is block 711,648, which the code describes as the Taproot activation height plus one miner confirmation window (709,632 plus 2,016 blocks).
- Taproot is a soft fork upgrade to Bitcoin, active since November 2021, that adds a new kind of output whose coins can be spent either with a single signature or by revealing one of several spending conditions committed to in advance.
- BIP 341, the main Taproot specification, states that its aim is to improve the privacy, efficiency and flexibility of Bitcoin's scripting capabilities.
The UTXO model
37 new claims on the topic page
- Address reuse, which Bitcoin Optech also calls output linking, happens when a user receives two or more payments to the same public key or other unique script element; other users can then reasonably assume that the same person received all of those payments.
- Assumeutxo is a way to bootstrap a Bitcoin full node from a snapshot of the UTXO set, postponing verification of old block history: the node uses the snapshot right away and downloads and verifies the older blocks in the background.
- As of block 976,753, Bitcoin Core's master branch hardcodes assumeutxo snapshot hashes for five mainnet heights (840,000, 880,000, 910,000, 935,000 and 965,000) in m_assumeutxo_data, and a node checks that a loaded snapshot matches the compiled value once background validation reaches it.
- Since Bitcoin Core 28.0, the loadtxoutset RPC can be used on mainnet, because that release added assumeutxo parameters for a UTXO set snapshot taken at block 840,000.
- Bitcoin Core's wallet coin control (CCoinControl) has two options about addresses: one avoids partial use of funds sent to a given address, and another forbids spending outputs received at addresses that have already been used.
- BIP 30 forbids a Bitcoin block from containing a transaction whose txid matches an earlier transaction in the same chain that still has unspent outputs, closing a flaw in which a duplicate transaction could overwrite the earlier one's unspent outputs.
- Bitcoin Core treats exactly two mainnet blocks, 91,842 and 91,880, as exceptions to the BIP 30 duplicate-transaction rule, identifying each by both height and block hash in the function IsBIP30Repeat in src/validation.cpp.
- Besides the two BIP 30 exemptions, Bitcoin Core's src/validation.cpp names two earlier mainnet blocks, 91,722 and 91,812, by both height and block hash in a separate function, IsBIP30Unspendable.
- BIP 34 requires each Bitcoin block to put its height as the first item of its coinbase transaction's scriptSig, to enforce block and transaction uniqueness; Bitcoin Core records the mainnet activation height of this rule as block 227,931.
- Bitcoin Core relies on BIP 34 to skip BIP 30 duplicate-transaction lookups only below block 1,983,702, its constant BIP34_IMPLIES_BIP30_LIMIT; from that height on it enforces the BIP 30 check again, because some coinbase transactions from before BIP 34 could otherwise be repeated.
- Bitcoin Core reads and writes the UTXO set through layered views defined around CCoinsView in src/coins.h: CCoinsViewCache keeps an in-memory cache on top of another view, and CCoinsViewDB is backed by the coin database in the node's chainstate directory.
- The Bitcoin white paper defines an electronic coin as a chain of digital signatures: each owner passes the coin on by signing a hash of the previous transaction together with the public key of the next owner.
- Bitcoin Core keeps the full set of unspent outputs in its chainstate database, separate from the stored blocks, so a node can check that the outputs a new transaction spends exist and are unspent without rereading the block history.
- A Bitcoin payment that spends outputs worth more than the amount being paid usually creates two outputs: one for the payee and one, called change, that returns the remainder to the sender, as the Bitcoin white paper describes.
- Bitcoin Core's wallet supports coin control: a user can lock in specific unspent outputs for a transaction, and the wallet then includes those outputs even when its own coin selection would not have chosen them.
- Bitcoin Core represents each unspent output as a Coin, which its source code calls a UTXO entry. A Coin records the height of the block that created the output and a flag marking coinbase outputs, the data the coinbase maturity check reads.
- Outputs of a Bitcoin coinbase transaction, which pays the block reward, cannot be spent until 100 more blocks have been mined. Bitcoin Core enforces this consensus rule with COINBASE_MATURITY set to 100 blocks, checked in Consensus::CheckTxInputs.
- A Bitcoin payment's new outputs enter the shared record when a block includes the transaction. Each later block built on top counts as a further confirmation, because changing the earlier block would mean redoing the proof-of-work of every block after it.
- The consensus cleanup soft fork proposal, as summarized by Bitcoin Optech, includes a rule that would make future coinbase transactions unique without needing BIP 30 checks for those blocks, which would close the duplicate-transaction gap left by early coinbases.
- Bitcoin nodes accept a block only if every transaction in it is valid and spends outputs that are still unspent. Bitcoin Core rejects a transaction whose inputs are missing or already spent, which is how the UTXO model stops the same coins being spent twice.
- Bitcoin Optech notes that output linking through a reused address can happen because a user reuses the address out of ignorance, or because someone deliberately targets the user, as in a dust attack.
- As of block 976,753, Bitcoin Core's default relay policy calls an output dust when spending it would cost more in fees than it is worth at the default dust feerate of 3,000 sats per 1,000 vB, which puts the threshold at 546 sats for a typical non-segwit output and 294 sats for a P2WPKH output.
- A Bitcoin transaction's fee is not written as a separate field: it is the amount by which the total value of its inputs exceeds the total value of its outputs, and Bitcoin Core rejects a transaction whose outputs are worth more than its inputs.
- The Bitcoin white paper notes that multi-input transactions reveal that their inputs were owned by the same owner, so spending several unspent outputs together in one transaction can let observers link payments that were otherwise separate.
- One Bitcoin payment can spend several inputs at once: when no single unspent output in a wallet covers the amount, the wallet's coin selection combines several smaller outputs as inputs to the same transaction.
- The Bitcoin white paper recommends a new key pair for each transaction, as an additional firewall that keeps transactions from being linked to a common owner. Bitcoin Optech groups such methods of limiting output linking under the name reuse avoidance.
- A Bitcoin transaction input names the output it spends by an outpoint: the transaction id of the earlier transaction plus a 32-bit index into that transaction's list of outputs, represented in Bitcoin Core by the COutPoint class.
- A Bitcoin transaction output, the CTxOut class in Bitcoin Core, holds two fields: an amount (nValue) and a locking script (scriptPubKey) whose conditions the input that later spends the output must satisfy.
- A Bitcoin transaction spends coins by taking earlier unspent outputs as its inputs and creating new outputs. Nodes then remove the spent outputs from their record of unspent outputs and add the newly created ones.
- A 2017 academic analysis of the Bitcoin UTXO set states that every unspent output, whatever its type, age, value or length, is stored in every full node, and measures how much of the set is dust and unprofitable outputs.
- Utreexo is a proposed alternative to storing the full UTXO set: a node keeps a hash-based accumulator whose size grows logarithmically with the set, and transactions carry inclusion proofs showing that the outputs they spend are in it.
- As of 20 November 2026, the three Utreexo specifications proposed as BIPs 181, 182 and 183 sit in bitcoin/bips pull request #1923, opened in August 2025 and marked as a draft, describing Utreexo as a consensus-compatible way to verify transactions that needs no soft fork.
- The 2019 Utreexo paper reports that, in simulations of downloading the Bitcoin block chain up to early 2019 with 500 MB of RAM for caching, the inclusion proofs added about 25% to the data otherwise downloaded.
- The Bitcoin UTXO set held 176,948,713 unspent outputs at block 840,000 and 184,821,030 at block 880,000, according to snapshot dumps posted by reviewers of Bitcoin Core's mainnet assumeutxo parameters: growth of about 7.9 million outputs over 40,000 blocks.
- A Bitcoin balance is not a number stored on the chain. The balance of an address is the sum of the unspent outputs locked to it, and a wallet's balance is the total of the unspent outputs it can spend.
- Bitcoin does not keep account balances. It records ownership as unspent transaction outputs (UTXOs): each output is an amount of bitcoin locked to a condition, usually a signature from a particular key, that stays spendable until a later transaction consumes it.
- Since segregated witness (BIP 141), the data that unlocks a Bitcoin output can sit in a separate witness structure that the transaction id does not cover; Bitcoin Core stores it with each input as scriptWitness, beside the older scriptSig.
The BIP index
- BIP 333, BIP324 One-Byte Message Type ID Alias Assignment: added, Draft (index at fdcd802459)
Research runs that finished
- 2026-11-20-seed-halvings-and-supply
23 claims published, 0 revisions, 6 held for the owner's review
- 2026-11-20-seed-utxo-model
37 claims published, 0 revisions, 0 held for the owner's review
- 2026-11-20-seed-proof-of-work
26 claims published, 0 revisions, 5 held for the owner's review
- 2026-11-20-seed-segwit
29 claims published, 0 revisions, 5 held for the owner's review
- 2026-11-20-seed-taproot
26 claims published, 0 revisions, 2 held for the owner's review
- 2026-11-20-seed-lightning
33 claims published, 0 revisions, 0 held for the owner's review
- 2026-11-20-seed-fees-and-mempool
25 claims published, 0 revisions, 12 held for the owner's review
- 2026-11-20-seed-bip-process
29 claims published, 0 revisions, 1 held for the owner's review
- 2026-11-20-seed-self-custody
0 claims published, 0 revisions, 38 held for the owner's review
- 2026-11-20-seed-covenants
0 claims published, 0 revisions, 34 held for the owner's review
- 2026-11-20-reverify
0 claims published, 0 revisions, 0 held for the owner's review