Bitcoin Core works fine as a wallet (and I personally use it). Although
it doesn't implement BIP39, it does implement BIP32 and many other
standards, including some significant improvements over other wallets
(such as descriptors and HWI support ). It's also the easiest way to
take advantage of the additional verification and privacy advantages of
running a full node.
- Move "don't need to rely on third parties" to the top of the list
- Add the privacy benefit of a full node
- Clarify that running a full node only makes the network more robust if
you use it to verify your own wallet transactions
- Update resource requirements to their 2023 figures (and mention that
they may increase in the future).
- Be more precise about the minimal data a node needs, e.g. disk space
requirements with pruning enabled and bandwidth in blocks-only mode.
- Mention bandwidth alternatives, like Blockstream Satellite
- Drop text about running on a VPS, since that's not useful to the
network and not sure for anyone using a wallet.
- Add just a few words so users know what the "d" in bitcoind and the
"Unix" in build-unix.md stand for.
- Since the last update to this text, there are instructions for many
more platforms available, so rewrite final sentence to alert users to
them.
- Previous text said Bitcoin (Core) was "completed" before the Nakamoto
paper was written, but Nakamoto sent unfinished code to Hal Finney and
others after the paper was published but prior to the public software
release, suggesting Bitcoin wasn't completed at that time. This also
ignores the two updates (at least) which Nakamoto made to the Bitcoin
paper after the network was started. It also seems much more likely
to me that parts of the code and the paper were written in tandem.
Update text to say "mostly completed" and "published".
- Drop word "authoritative" from the description of Bitcoin Core as a
reference implementation. There's no authority here.
- Change problematic "full network node" language; see edits to previous
chapters.
Previous text didn't explain how including a transaction in a block
gave it security. We add a short explanation here, knowing that we'll
go into more detail in the mining chapter.
This takes up the same amount of space and is (I think) just as easy to
understand, but avoids the indirection of a metaphorical example and
some of the confusions it can create, e.g. that mining is a race to
complete a puzzle rather than a memoryless lottery.
We also remove a later desciption of PoW which is now redundant.
This advice may have been somewhat accurate when the first edition of
this book was published and opt-in replace-by-fee wasn't available, but
that's no longer the case. And now, especially, with default
replace-by-fee on the probable horizon, there's even less safety in
accepting unconfirmed transactions as final without some type of
secondary protection.
- Alice can send her transaction to software that will forward it to a
node for her. This is very common today.
- Previous text used the term "flooding" but the more common phrase for
this particular propagation technique is "gossiping".
Per the updated infobox in CH01, we stop using the name "clients" for
full nodes; they're peers. We also clarify that miners commit effort to
blocks rather than necessary prove them valid.
Introduce the UTXO term as it is one of the most essential concepts to
understanding how Bitcoin works and is widely used in other Bitcoin
technical documentation.
Previous text said that wallets can construct tranactions offline. Add
clarification that this requires the wallet to already know what inputs
it controls.
- Update text to refer to new illustration
- Introduce the term "change output" in addition to existing term
"change address"
- Add information about the privacy advantages of unique change
addresses
- Previous illustration was cut-off, both in the source and the print
edition. We update the illustration to not only correct that but also
provide more accuracy:
- Instead of showing input values, the illustration now shows input
references to prevouts.
- Instead of using BTC denomination, it use satoshis
- Instead of putting tx fees in the output category, it shows them
outside the transaction since they're an implicit value
- The source for the new illustration is provided as a comment to
make future editing easier
- The text is updated to refer to the new illustration appropriately.
- Text now mentions the implicit input value
- We describe that we use satoshi values because that's what's in the
protocol
Before earlier edits, the second edition text for this chapter was about
buying a cup of coffee. The edits changed it to a laptop. The risk
profile of a cup of coffee and a laptop are different, making some parts
of the text problematic, e.g. Bob accepting payment without waiting for
confirmation.
This update replaces the example with Alice buying a premium podcast
episode, which has a very low risk profile.
Existing text claimed that Alice's unconfirmed transaction completed the
payment to Bob, but Bob would be wise to wait for a $750 transaction to
confirm.
I think this is a problem resulting from a previous edit to the
second-edition text where the example was changed from a cup of coffee
at a cafe to a laptop. A cup of coffee is cheap and has no resale
value, so the chance of fraud is small; a laptop is expensive and has
significant resale value, making fraud a greater risk.
The payment request language is confusing because BIP70 payment requests
look a lot like the URI used here but this is not a BIP70 payment
request (and BIP70 is dead, so we need not describe it).
Instead, update the text to use the more generic word "invoice", which
has the advantage of also being simpler English.
Existing text used "bitcoin" as both the singular and plural unit, which
was not an uncommon practice when the first edition was written.
However, my edits to the first chapter and this update adopt the
practice of using the same pluralization rules used for other
currencies, like the dollar, plus most numbered things in general.
This produces more natural text.
Reference: https://www.chicagomanualofstyle.org/qanda/data/faq/topics/Numbers/faq0058.html
Replace older block explorers with modern alternatives and warn readers
that looking up info on explorers may disclose their interest to third
parties.
Users operating a full node don't need to trust anyone else for certain
guarantees about the system, although they do need at least one honest
peer to obtain some other guarantees. Clarify this in the text by
revising text about text and emergent properties.
Original text claimed that there is no association between a user's
identity and their addresses prior to using that address in most
wallets, but many lightweight wallets send even their not-yet-used
addresses to remote servers to scan for incoming payments. This is
often done over IPv4 or IPv6, which creates a link between the user's
connection and their addresses. Update text by simply dropping this
claim.
SPV verification doesn't require connecting to a full node over the P2P
network. Many clients connect to specially designed tranasctions
servers (e.g. an Electrum server) which provides them with transactions,
SPV proofs, and headers--and provide relay for outgoing transactions.
Update text to remove claims about direct P2P connection.
David A. Harding