In a recent post on bitcointalk, I stated that focusing solely on the forking risk created by alternative implementations is a red herring because, while there is certainly risk involved, it is merely a symptom of a more fundamental issue that all implementations, including Bitcoin Core itself, suffer. This statement seems to have confused a few people, so, in this blog post, I’d like to delve a little deeper into why this is the case, identify what the real underlying issue is, and offer a potential solution.
First, let’s establish a few baseline facts that, to my knowledge, everyone agrees with:
- Every fully-validating node on the network must follow the exact same consensus rules or a fork will occur
- The consensus rules are complex and contain various non-intuitive corner cases, some of which probably still have not been identified
- Chain forks can be abused to create double spends and generally wreak havoc
- Every new version of Bitcoin Core carries some level of forking risk (if there is any doubt about this, see the March 2013 fork that already happened)
- Alternative implementations carry some level of forking risk
Today is a good day! Btcd, our alternative, full-node Bitcoin client written in Go, has now officially entered Beta (Release Notes). To our knowledge, btcd is the most complete alternative full-node daemon available. We have made it a priority to be as close of a drop-in alternative to Bitcoin Core as possible while making several improvements along the way.
Have you been looking for a robust and easy to use way to interface with Bitcoin through the JSON-RPC API? We’ve got you covered!
We’re excited to announce btcrpcclient, a new Websocket-enabled Bitcoin JSON-RPC client package written in Go. This package allows you to quickly create robust Bitcoin RPC clients in just a few minutes.
Major Features of the btcrpcclient Package
- Supports Websockets (btcd and btcwallet) and HTTP POST mode (Bitcoin Core)
- Provides callback and registration functions for btcd and btcwallet notifications
- Supports btcd and btcwallet extensions
- Translates to and from high-level statically-typed Go types
- Offers a synchronous (blocking) and asynchronous (non-blocking) API
- When running in Websockets mode (the default):
- Provides automatic reconnect handling (can be disabled if desired)
- Outstanding commands are automatically reissued on reconnect
- Registered notifications are automatically re-registered on reconnect
- Back-off support on reconnect attempts
We are pleased to announce that btcd, our full-node bitcoind (bitcoin core) alternative written in Go, now has support for the getwork RPC which allows it to function with cgminer!
We have extensively tested the code on testnet. The following is a sampling of the latest blocks we’ve generated on testnet using btcd + cgminer: 226713 226830 227228 227390 227393.
If you are simply interested in learning how to configure btcd to work with cgminer, you can view the setup instructions on the btcd wiki, however if you’re interested to learn about some of the nuts and bolts that make it all work, read on.
Isn’t getwork deprecated?
Before I dig into some of the details, I would like to touch on a topic that I’m sure some astute readers will undoubtedly be asking, which is “Why implement getwork when it has been deprecated in favor of getblocktemplate (BIP0022 and BIP0023)?”
There are a few reasons why we chose to implement it first:
- Supporting getwork was a lot less time consuming than getblocktemplate proposals and software such as cgminer still functions properly with getwork. This means we were able to release support for mining more quickly by supporting getwork first.
- The bulk of the work involved was the code to create and manipulate block templates which is used by both getwork and getblocktemplate. Thus it helps pave the way to supporting getblocktemplate proposals while allowing getwork to function in the mean time.
- The current reference implementation (bitcoin core) still supports getwork. Even though it will likely be removed in the next version, one of the goals of btcd is to be a drop-in alternative that can be used with existing infrastructures.
We are pleased to announce that btcd, our full-node bitcoind alternative written in Go, is finally ready for public testing!
The installation instructions and source code can be found on github at:
A Brief History
Back in May, we first announced our plans to release btcd. A week later we released our first core package from btcd, btcwire, and announced our plans to continue releasing the component packages of btcd in a staggered fashion.
Over the next month, we released btcjson, btcdb, and btcscript. Then in mid-July we released btcchain at which time we announced btcd was next. At that point, btcd had most of the core bits and we figured we’d be releasing it within a few weeks. Well, as you have no doubt noticed, it is now 10 weeks later…
As all of you following our blog are aware, we have previously released several bitcoin-related packages (btcwire, btcjson, btcutil, btcdb, btcec, and btcscript) on our way towards the full release of btcd.
We are happy to announce our next package from btcd. The package is named btcchain and it implements the bitcoin block handling and chain selection rules. The code can be reviewed on github here:
Overall Package Design
The bitcoin block handling and chain selection rules are an integral, and quite likely the most important, part of bitcoin. Unfortunately, at the time of this writing, these rules are also largely undocumented and had to be ascertained from the bitcoind source code. At its core, bitcoin is a distributed consensus of which blocks are valid and which ones will comprise the main block chain (public ledger) that ultimately determines accepted transactions, so it is extremely important that fully validating nodes agree on all rules.
Following up on our previous releases (btcwire, btcjson, btcutil, and btcdb) we are happy to announce btcscript, the script package from btcd:
btcscript provides code and data structures to parse and execute bitcoin scripts. The scripting system bitcoin uses is a stack-based, FORTH-like language. It is not turing complete by design (as adding a full turing complete language opens up all sorts of potential complications and problems), but it still provides a fair amount of power.
Previously, we released btcwire and btcjson and we are now releasing btcdb, the database package from btcd:
As of late May 2013, there are over 238,000 blocks in the bitcoin blockchain and over 18 million transactions. This works out to be slightly under 11 GB of data when including transaction metadata. btcdb provides an efficient and relatively simple way to store and access this dataset from Go. Although it was built with btcd in mind, there are certainly other potential uses for it and we have designed the interface with that flexibility in mind. Unlike the other packages we have released, it is likely that there will be some minor interface changes as we continue to develop btcdb.
We recently announced btcd, an alternative full-node implementation of the bitcoin wire protocol and block validation written in Go that is under active development.
btcwire was the first package released, and now we would like to announce the public preview of our second package, btcjson, the JSON-RPC package from btcd:
As was recently announced in a previous blog (here), btcd is an alternative full-node implementation of the bitcoin wire protocol and block validation written in Go that is currently under active development.
We’d now like to announce a public preview of one of the core packages from btcd. The package is named btcwire and it implements the bitcoin wire protocol. The code can be reviewed on github here:
Overall Package Design
At a high level, this package provides support for marshalling and unmarshalling supported bitcoin messages to and from the wire. This package does not deal with the specifics of message handling such as what to do when a message is received. This provides the caller with a high level of flexibility.