From ef6c01960f9f58a235f82b4ea649eb65b87291cb Mon Sep 17 00:00:00 2001 From: Dave Collins Date: Tue, 28 May 2013 17:32:35 -0500 Subject: [PATCH] Initial implementation. --- LICENSE | 13 ++ README.md | 51 +++++ block.go | 226 +++++++++++++++++++++ block_test.go | 487 ++++++++++++++++++++++++++++++++++++++++++++++ cov_report.sh | 17 ++ doc.go | 15 ++ test_coverage.txt | 16 ++ 7 files changed, 825 insertions(+) create mode 100644 LICENSE create mode 100644 block.go create mode 100644 block_test.go create mode 100644 cov_report.sh create mode 100644 doc.go create mode 100644 test_coverage.txt diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..0d760cb --- /dev/null +++ b/LICENSE @@ -0,0 +1,13 @@ +Copyright (c) 2013 Conformal Systems LLC. + +Permission to use, copy, modify, and distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md index 761ef82..71cd0c5 100644 --- a/README.md +++ b/README.md @@ -2,3 +2,54 @@ btcutil ======= Package btcutil provides bitcoin-specific convenience functions and types. +The test coverage is currently ~76%, however it will improved to 100% in the +near future. See `test_coverage.txt` for the gocov coverage report. +Alternatively, if you are running a POSIX OS, you can run the `cov_report.sh` +script for a real-time report. Package btcutil is licensed under the liberal +ISC license. + +This package was developed for btcd, an alternative full-node implementation of +bitcoin which is under active development by Conformal. Although it was +primarily written for btcd, this package has intentionally been designed so it +can be used as a standalone package for any projects needing the functionality +provided. + +## Documentation + +Full `go doc` style documentation for the project can be viewed online without +installing this package by using the GoDoc site here: +http://godoc.org/github.com/conformal/btcutil + +You can also view the documentation locally once the package is installed with +the `godoc` tool by running `godoc -http=":6060"` and pointing your browser to +http://localhost:6060/pkg/github.com/conformal/btcutil + +## Installation + +```bash +$ go get github.com/conformal/btcutil +``` + +## GPG Verification Key + +All official release tags are signed by Conformal so users can ensure the code +has not been tampered with and is coming from Conformal. To verify the +signature perform the following: + +- Download the public key from the Conformal website at + https://opensource.conformal.com/GIT-GPG-KEY-conformal.txt + +- Import the public key into your GPG keyring: + ```bash + gpg --import GIT-GPG-KEY-conformal.txt + ``` + +- Verify the release tag with the following command where `TAG_NAME` is a + placeholder for the specific tag: + ```bash + git tag -v TAG_NAME + ``` + +## License + +Package btcutil is licensed under the liberal ISC License. diff --git a/block.go b/block.go new file mode 100644 index 0000000..e857d18 --- /dev/null +++ b/block.go @@ -0,0 +1,226 @@ +// Copyright (c) 2013 Conformal Systems LLC. +// Use of this source code is governed by an ISC +// license that can be found in the LICENSE file. + +package btcutil + +import ( + "bytes" + "fmt" + "github.com/conformal/btcwire" +) + +// OutOfRangeError describes an error due to accessing an element that is out +// of range. +type OutOfRangeError string + +// BlockHeightUnknown is the value returned for a block height that is unknown. +// This is typically because the block has not been inserted into the main chain +// yet. +const BlockHeightUnknown = int64(-1) + +// Error satisfies the error interface and prints human-readable errors. +func (e OutOfRangeError) Error() string { + return string(e) +} + +// Block defines a bitcoin block that provides easier and more efficient +// manipulation of raw wire protocol blocks. It also memoizes hashes for the +// block and its transactions on their first access so subsequent accesses don't +// have to repeat the relatively expensive hashing operations. +type Block struct { + msgBlock *btcwire.MsgBlock // Underlying MsgBlock + rawBlock []byte // Raw wire encoded bytes for the block + protocolVersion uint32 // Protocol version used to encode rawBlock + blockSha *btcwire.ShaHash // Cached block hash + blockHeight int64 // Height in the main block chain + txShas []*btcwire.ShaHash // Cached transaction hashes + txShasGenerated bool // ALL transaction hashes generated +} + +// MsgBlock returns the underlying btcwire.MsgBlock for the Block. +func (b *Block) MsgBlock() *btcwire.MsgBlock { + // Return the cached block. + return b.msgBlock +} + +// Bytes returns the raw wire protocol encoded bytes for the Block and the +// protocol version used to encode it. This is equivalent to calling BtcEncode +// on the underlying btcwire.MsgBlock, however it caches the result so +// subsequent calls are more efficient. +func (b *Block) Bytes() ([]byte, uint32, error) { + // Return the cached raw block bytes and associated protocol version if + // it has already been generated. + if len(b.rawBlock) != 0 { + return b.rawBlock, b.protocolVersion, nil + } + + // Encode the MsgBlock into raw block bytes. + var w bytes.Buffer + err := b.msgBlock.BtcEncode(&w, b.protocolVersion) + if err != nil { + return nil, 0, err + } + rawBlock := w.Bytes() + + // Cache the encoded bytes and return them. + b.rawBlock = rawBlock + return rawBlock, b.protocolVersion, nil +} + +// Sha returns the block identifier hash for the Block. This is equivalent to +// calling BlockSha on the underlying btcwire.MsgBlock, however it caches the +// result so subsequent calls are more efficient. +func (b *Block) Sha() (*btcwire.ShaHash, error) { + // Return the cached block hash if it has already been generated. + if b.blockSha != nil { + return b.blockSha, nil + } + + // Generate the block hash. Ignore the error since BlockSha can't + // currently fail. + sha, _ := b.msgBlock.BlockSha(b.protocolVersion) + + // Cache the block hash and return it. + b.blockSha = &sha + return &sha, nil +} + +// TxSha returns the hash for the requested transaction number in the Block. +// The supplied index is 0 based. That is to say, the first transaction is the +// block is txNum 0. This is equivalent to calling TxSha on the underlying +// btcwire.MsgTx, however it caches the result so subsequent calls are more +// efficient. +func (b *Block) TxSha(txNum int) (*btcwire.ShaHash, error) { + // Ensure the requested transaction is in range. + numTx := b.msgBlock.Header.TxnCount + if txNum < 0 || uint64(txNum) > numTx { + str := fmt.Sprintf("transaction index %d is out of range - max %d", + txNum, numTx-1) + return nil, OutOfRangeError(str) + } + + // Generate slice to hold all of the transaction hashes if needed. + if len(b.txShas) == 0 { + b.txShas = make([]*btcwire.ShaHash, numTx) + } + + // Return the cached hash if it has already been generated. + if b.txShas[txNum] != nil { + return b.txShas[txNum], nil + } + + // Generate the hash for the transaction. Ignore the error since TxSha + // can't currently fail. + sha, _ := b.msgBlock.Transactions[txNum].TxSha(b.protocolVersion) + + // Cache the transaction hash and return it. + b.txShas[txNum] = &sha + return &sha, nil +} + +// TxShas returns a slice of hashes for all transactions in the Block. This is +// equivalent to calling TxSha on each underlying btcwire.MsgTx, however it +// caches the result so subsequent calls are more efficient. +func (b *Block) TxShas() ([]*btcwire.ShaHash, error) { + // Return cached hashes if they have ALL already been generated. This + // flag is necessary because the transaction hashes are lazily generated + // in a sparse fashion. + if b.txShasGenerated { + return b.txShas, nil + } + + // Generate slice to hold all of the transaction hashes if needed. + if len(b.txShas) == 0 { + b.txShas = make([]*btcwire.ShaHash, b.msgBlock.Header.TxnCount) + } + + // Generate and cache the transaction hashes for all that haven't already + // been done. + for i, hash := range b.txShas { + if hash == nil { + // Ignore the error since TxSha can't currently fail. + sha, _ := b.msgBlock.Transactions[i].TxSha(b.protocolVersion) + b.txShas[i] = &sha + } + } + + b.txShasGenerated = true + return b.txShas, nil +} + +// ProtocolVersion returns the protocol version that was used to create the +// underlying btcwire.MsgBlock. +func (b *Block) ProtocolVersion() uint32 { + return b.protocolVersion +} + +// TxLoc() returns the offsets and lengths of each transaction in a raw block. +// It is used to allow fast indexing into the +func (b *Block) TxLoc() (txlocD []btcwire.TxLoc, err error) { + rawMsg, pver, err := b.Bytes() + if err != nil { + return + } + rbuf := bytes.NewBuffer(rawMsg) + + var mblock btcwire.MsgBlock + txloc, err := mblock.BtcDecodeTxLoc(rbuf, pver) + if err != nil { + return + } + return txloc, err +} + +// Height returns the saved height of the block in the blockchain. This value +// will be BlockHeightUnknown if it hasn't already explicitly been set. +func (b *Block) Height() int64 { + return b.blockHeight +} + +// SetHeight sets the height of the block in the blockchain. +func (b *Block) SetHeight(height int64) { + b.blockHeight = height +} + +// NewBlock returns a new instance of a bitcoin block given an underlying +// btcwire.MsgBlock and protocol version. See Block. +func NewBlock(msgBlock *btcwire.MsgBlock, pver uint32) *Block { + return &Block{ + msgBlock: msgBlock, + protocolVersion: pver, + blockHeight: BlockHeightUnknown, + } +} + +// NewBlockFromBytes returns a new instance of a bitcoin block given the +// raw wire encoded bytes and protocol version used to encode those bytes. +// See Block. +func NewBlockFromBytes(rawBlock []byte, pver uint32) (*Block, error) { + // Decode the raw block bytes into a MsgBlock. + var msgBlock btcwire.MsgBlock + br := bytes.NewBuffer(rawBlock) + err := msgBlock.BtcDecode(br, pver) + if err != nil { + return nil, err + } + + b := Block{ + msgBlock: &msgBlock, + rawBlock: rawBlock, + protocolVersion: pver, + blockHeight: BlockHeightUnknown, + } + return &b, nil +} + +// NewBlockFromBlockAndBytes returns a new instance of a bitcoin block given +// an underlying btcwire.MsgBlock, protocol version and raw Block. See Block. +func NewBlockFromBlockAndBytes(msgBlock *btcwire.MsgBlock, rawBlock []byte, pver uint32) *Block { + return &Block{ + msgBlock: msgBlock, + rawBlock: rawBlock, + protocolVersion: pver, + blockHeight: BlockHeightUnknown, + } +} diff --git a/block_test.go b/block_test.go new file mode 100644 index 0000000..52daa21 --- /dev/null +++ b/block_test.go @@ -0,0 +1,487 @@ +// Copyright (c) 2013 Conformal Systems LLC. +// Use of this source code is governed by an ISC +// license that can be found in the LICENSE file. + +package btcutil_test + +import ( + "bytes" + "github.com/conformal/btcutil" + "github.com/conformal/btcwire" + "github.com/davecgh/go-spew/spew" + "reflect" + "testing" + "time" +) + +// TestBlock tests the API for Block. +func TestBlock(t *testing.T) { + pver := btcwire.ProtocolVersion + b := btcutil.NewBlock(&Block100000, pver) + + // Ensure we get the same data back out. + if gotPver := b.ProtocolVersion(); gotPver != pver { + t.Errorf("ProtocolVersion: wrong protocol version - got %v, want %v", + gotPver, pver) + } + if msgBlock := b.MsgBlock(); !reflect.DeepEqual(msgBlock, &Block100000) { + t.Errorf("MsgBlock: mismatched MsgBlock - got %v, want %v", + spew.Sdump(msgBlock), spew.Sdump(&Block100000)) + } + + // Ensure block height set and get work properly. + wantHeight := int64(100000) + b.SetHeight(wantHeight) + if gotHeight := b.Height(); gotHeight != wantHeight { + t.Errorf("Height: mismatched height - got %v, want %v", + gotHeight, wantHeight) + } + + // Hash for block 100,000. + wantShaStr := "3ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506" + wantSha, err := btcwire.NewShaHashFromStr(wantShaStr) + if err != nil { + t.Errorf("NewShaHashFromStr: %v", err) + } + + // Request the sha multiple times to test generation and caching. + for i := 0; i < 2; i++ { + sha, err := b.Sha() + if err != nil { + t.Errorf("Sha: %v", err) + continue + } + if !sha.IsEqual(wantSha) { + t.Errorf("Sha #%d mismatched sha - got %v, want %v", i, + sha, wantSha) + } + } + + // Shas for the transactions in Block100000. + wantTxShas := []string{ + "8c14f0db3df150123e6f3dbbf30f8b955a8249b62ac1d1ff16284aefa3d06d87", + "fff2525b8931402dd09222c50775608f75787bd2b87e56995a7bdd30f79702c4", + "6359f0868171b1d194cbee1af2f16ea598ae8fad666d9b012c8ed2b79a236ec4", + "e9a66845e05d5abc0ad04ec80f774a7e585c6e8db975962d069a522137b80c1d", + } + + // Request sha for all transactions one at a time. + for i, txSha := range wantTxShas { + wantSha, err := btcwire.NewShaHashFromStr(txSha) + if err != nil { + t.Errorf("NewShaHashFromStr: %v", err) + } + + // Request the sha multiple times to test generation and caching. + for j := 0; j < 2; j++ { + sha, err := b.TxSha(i) + if err != nil { + t.Errorf("TxSha: %v", err) + continue + } + if !sha.IsEqual(wantSha) { + t.Errorf("TxSha #%d mismatched sha - got %v, "+ + "want %v", j, sha, wantSha) + continue + } + } + } + + // Create a new block to nuke all cached data. + b = btcutil.NewBlock(&Block100000, pver) + + // Request slice of all transaction shas multiple times to test + // generation and caching. + for i := 0; i < 2; i++ { + txShas, err := b.TxShas() + if err != nil { + t.Errorf("TxShas: %v", err) + continue + } + + // Ensure we get the expected number of transaction shas. + if len(txShas) != len(wantTxShas) { + t.Errorf("TxShas #%d mismatched number of shas -"+ + "got %d, want %d", i, len(txShas), + len(wantTxShas)) + continue + } + + // Ensure all of the shas match. + for j, txSha := range wantTxShas { + wantSha, err := btcwire.NewShaHashFromStr(txSha) + if err != nil { + t.Errorf("NewShaHashFromStr: %v", err) + } + + if !txShas[j].IsEqual(wantSha) { + t.Errorf("TxShas #%d mismatched shas - "+ + "got %v, want %v", j, + spew.Sdump(txShas), + spew.Sdump(wantTxShas)) + continue + } + } + } + + // Encode the test block to bytes. + var block100000Buf bytes.Buffer + err = Block100000.BtcEncode(&block100000Buf, pver) + if err != nil { + t.Errorf("BtcEncode: %v", err) + } + block100000Bytes := block100000Buf.Bytes() + + // Request raw bytes multiple times to test generation and caching. + for i := 0; i < 2; i++ { + rawBytes, tmpPver, err := b.Bytes() + if err != nil { + t.Errorf("Bytes: %v", err) + continue + } + if !bytes.Equal(rawBytes, block100000Bytes) { + t.Errorf("Bytes #%d wrong bytes - got %v, want %v", i, + spew.Sdump(rawBytes), + spew.Sdump(block100000Bytes)) + continue + } + if tmpPver != pver { + t.Errorf("Bytes #%d wrong protocol version - "+ + "got %v, want %v", i, spew.Sdump(rawBytes), + spew.Sdump(block100000Bytes)) + continue + + } + } +} + +// TestNewBlockFromBytes tests creation of a Block from raw bytes. +func TestNewBlockFromBytes(t *testing.T) { + // Encode the test block to bytes. + pver := btcwire.ProtocolVersion + var block100000Buf bytes.Buffer + err := Block100000.BtcEncode(&block100000Buf, pver) + if err != nil { + t.Errorf("BtcEncode: %v", err) + } + block100000Bytes := block100000Buf.Bytes() + + // Create a new block from the encoded bytes. + b, err := btcutil.NewBlockFromBytes(block100000Bytes, pver) + if err != nil { + t.Errorf("NewBlockFromBytes: %v", err) + return + } + + // Ensure we get the same data back out. + rawBytes, tmpPver, err := b.Bytes() + if err != nil { + t.Errorf("Bytes: %v", err) + return + } + if !bytes.Equal(rawBytes, block100000Bytes) { + t.Errorf("Bytes: wrong bytes - got %v, want %v", + spew.Sdump(rawBytes), + spew.Sdump(block100000Bytes)) + } + if tmpPver != pver { + t.Errorf("Bytes: wrong protocol version - got %v, want %v", + tmpPver, pver) + } + + // Ensure the generated MsgBlock is correct. + if msgBlock := b.MsgBlock(); !reflect.DeepEqual(msgBlock, &Block100000) { + t.Errorf("MsgBlock: mismatched MsgBlock - got %v, want %v", + spew.Sdump(msgBlock), spew.Sdump(&Block100000)) + } +} + +// TestNewBlockFromBlockAndBytes tests creation of a Block from a MsgBlock and +// raw bytes. +func TestNewBlockFromBlockAndBytes(t *testing.T) { + // Encode the test block to bytes. + pver := btcwire.ProtocolVersion + var block100000Buf bytes.Buffer + err := Block100000.BtcEncode(&block100000Buf, pver) + if err != nil { + t.Errorf("BtcEncode: %v", err) + } + block100000Bytes := block100000Buf.Bytes() + + // Create a new block from the encoded bytes. + b := btcutil.NewBlockFromBlockAndBytes(&Block100000, + block100000Bytes, pver) + + // Ensure we get the same data back out. + rawBytes, tmpPver, err := b.Bytes() + if err != nil { + t.Errorf("Bytes: %v", err) + return + } + if !bytes.Equal(rawBytes, block100000Bytes) { + t.Errorf("Bytes: wrong bytes - got %v, want %v", + spew.Sdump(rawBytes), + spew.Sdump(block100000Bytes)) + } + if tmpPver != pver { + t.Errorf("Bytes: wrong protocol version - got %v, want %v", + tmpPver, pver) + } + if msgBlock := b.MsgBlock(); !reflect.DeepEqual(msgBlock, &Block100000) { + t.Errorf("MsgBlock: mismatched MsgBlock - got %v, want %v", + spew.Sdump(msgBlock), spew.Sdump(&Block100000)) + } +} + +// Block100000 defines block 100,000 of the block chain. It is used to +// test Block operations. +var Block100000 btcwire.MsgBlock = btcwire.MsgBlock{ + Header: btcwire.BlockHeader{ + Version: 1, + PrevBlock: btcwire.ShaHash([32]byte{ // Make go vet happy. + 0x50, 0x12, 0x01, 0x19, 0x17, 0x2a, 0x61, 0x04, + 0x21, 0xa6, 0xc3, 0x01, 0x1d, 0xd3, 0x30, 0xd9, + 0xdf, 0x07, 0xb6, 0x36, 0x16, 0xc2, 0xcc, 0x1f, + 0x1c, 0xd0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, + }), // 000000000002d01c1fccc21636b607dfd930d31d01c3a62104612a1719011250 + MerkleRoot: btcwire.ShaHash([32]byte{ // Make go vet happy. + 0x66, 0x57, 0xa9, 0x25, 0x2a, 0xac, 0xd5, 0xc0, + 0xb2, 0x94, 0x09, 0x96, 0xec, 0xff, 0x95, 0x22, + 0x28, 0xc3, 0x06, 0x7c, 0xc3, 0x8d, 0x48, 0x85, + 0xef, 0xb5, 0xa4, 0xac, 0x42, 0x47, 0xe9, 0xf3, + }), // f3e94742aca4b5ef85488dc37c06c3282295ffec960994b2c0d5ac2a25a95766 + Timestamp: time.Unix(1293623863, 0), // 2010-12-29 11:57:43 +0000 UTC + Bits: 0x1b04864c, // 453281356 + Nonce: 0x10572b0f, // 274148111 + TxnCount: 4, + }, + Transactions: []*btcwire.MsgTx{ + &btcwire.MsgTx{ + Version: 1, + TxIn: []*btcwire.TxIn{ + &btcwire.TxIn{ + PreviousOutpoint: btcwire.OutPoint{ + Hash: btcwire.ShaHash{}, + Index: 0xffffffff, + }, + SignatureScript: []byte{ + 0x04, 0x4c, 0x86, 0x04, 0x1b, 0x02, 0x06, 0x02, + }, + Sequence: 0xffffffff, + }, + }, + TxOut: []*btcwire.TxOut{ + &btcwire.TxOut{ + Value: 0x12a05f200, // 5000000000 + PkScript: []byte{ + 0x41, // OP_DATA_65 + 0x04, 0x1b, 0x0e, 0x8c, 0x25, 0x67, 0xc1, 0x25, + 0x36, 0xaa, 0x13, 0x35, 0x7b, 0x79, 0xa0, 0x73, + 0xdc, 0x44, 0x44, 0xac, 0xb8, 0x3c, 0x4e, 0xc7, + 0xa0, 0xe2, 0xf9, 0x9d, 0xd7, 0x45, 0x75, 0x16, + 0xc5, 0x81, 0x72, 0x42, 0xda, 0x79, 0x69, 0x24, + 0xca, 0x4e, 0x99, 0x94, 0x7d, 0x08, 0x7f, 0xed, + 0xf9, 0xce, 0x46, 0x7c, 0xb9, 0xf7, 0xc6, 0x28, + 0x70, 0x78, 0xf8, 0x01, 0xdf, 0x27, 0x6f, 0xdf, + 0x84, // 65-byte signature + 0xac, // OP_CHECKSIG + }, + }, + }, + LockTime: 0, + }, + &btcwire.MsgTx{ + Version: 1, + TxIn: []*btcwire.TxIn{ + &btcwire.TxIn{ + PreviousOutpoint: btcwire.OutPoint{ + Hash: btcwire.ShaHash([32]byte{ // Make go vet happy. + 0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60, + 0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac, + 0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07, + 0x79, 0xac, 0x88, 0xfd, 0xf3, 0x57, 0xa1, 0x87, + }), // 87a157f3fd88ac7907c05fc55e271dc4acdc5605d187d646604ca8c0e9382e03 + Index: 0, + }, + SignatureScript: []byte{ + 0x49, // OP_DATA_73 + 0x30, 0x46, 0x02, 0x21, 0x00, 0xc3, 0x52, 0xd3, + 0xdd, 0x99, 0x3a, 0x98, 0x1b, 0xeb, 0xa4, 0xa6, + 0x3a, 0xd1, 0x5c, 0x20, 0x92, 0x75, 0xca, 0x94, + 0x70, 0xab, 0xfc, 0xd5, 0x7d, 0xa9, 0x3b, 0x58, + 0xe4, 0xeb, 0x5d, 0xce, 0x82, 0x02, 0x21, 0x00, + 0x84, 0x07, 0x92, 0xbc, 0x1f, 0x45, 0x60, 0x62, + 0x81, 0x9f, 0x15, 0xd3, 0x3e, 0xe7, 0x05, 0x5c, + 0xf7, 0xb5, 0xee, 0x1a, 0xf1, 0xeb, 0xcc, 0x60, + 0x28, 0xd9, 0xcd, 0xb1, 0xc3, 0xaf, 0x77, 0x48, + 0x01, // 73-byte signature + 0x41, // OP_DATA_65 + 0x04, 0xf4, 0x6d, 0xb5, 0xe9, 0xd6, 0x1a, 0x9d, + 0xc2, 0x7b, 0x8d, 0x64, 0xad, 0x23, 0xe7, 0x38, + 0x3a, 0x4e, 0x6c, 0xa1, 0x64, 0x59, 0x3c, 0x25, + 0x27, 0xc0, 0x38, 0xc0, 0x85, 0x7e, 0xb6, 0x7e, + 0xe8, 0xe8, 0x25, 0xdc, 0xa6, 0x50, 0x46, 0xb8, + 0x2c, 0x93, 0x31, 0x58, 0x6c, 0x82, 0xe0, 0xfd, + 0x1f, 0x63, 0x3f, 0x25, 0xf8, 0x7c, 0x16, 0x1b, + 0xc6, 0xf8, 0xa6, 0x30, 0x12, 0x1d, 0xf2, 0xb3, + 0xd3, // 65-byte pubkey + }, + Sequence: 0xffffffff, + }, + }, + TxOut: []*btcwire.TxOut{ + &btcwire.TxOut{ + Value: 0x2123e300, // 556000000 + PkScript: []byte{ + 0x76, // OP_DUP + 0xa9, // OP_HASH160 + 0x14, // OP_DATA_20 + 0xc3, 0x98, 0xef, 0xa9, 0xc3, 0x92, 0xba, 0x60, + 0x13, 0xc5, 0xe0, 0x4e, 0xe7, 0x29, 0x75, 0x5e, + 0xf7, 0xf5, 0x8b, 0x32, + 0x88, // OP_EQUALVERIFY + 0xac, // OP_CHECKSIG + }, + }, + &btcwire.TxOut{ + Value: 0x108e20f00, // 4444000000 + PkScript: []byte{ + 0x76, // OP_DUP + 0xa9, // OP_HASH160 + 0x14, // OP_DATA_20 + 0x94, 0x8c, 0x76, 0x5a, 0x69, 0x14, 0xd4, 0x3f, + 0x2a, 0x7a, 0xc1, 0x77, 0xda, 0x2c, 0x2f, 0x6b, + 0x52, 0xde, 0x3d, 0x7c, + 0x88, // OP_EQUALVERIFY + 0xac, // OP_CHECKSIG + }, + }, + }, + LockTime: 0, + }, + &btcwire.MsgTx{ + Version: 1, + TxIn: []*btcwire.TxIn{ + &btcwire.TxIn{ + PreviousOutpoint: btcwire.OutPoint{ + Hash: btcwire.ShaHash([32]byte{ // Make go vet happy. + 0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d, + 0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27, + 0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65, + 0xe4, 0x1c, 0x61, 0xd0, 0x78, 0x29, 0x4e, 0xcf, + }), // cf4e2978d0611ce46592e02d7e7daf8627a316ab69759a9f3df109a7f2bf3ec3 + Index: 1, + }, + SignatureScript: []byte{ + 0x47, // OP_DATA_71 + 0x30, 0x44, 0x02, 0x20, 0x03, 0x2d, 0x30, 0xdf, + 0x5e, 0xe6, 0xf5, 0x7f, 0xa4, 0x6c, 0xdd, 0xb5, + 0xeb, 0x8d, 0x0d, 0x9f, 0xe8, 0xde, 0x6b, 0x34, + 0x2d, 0x27, 0x94, 0x2a, 0xe9, 0x0a, 0x32, 0x31, + 0xe0, 0xba, 0x33, 0x3e, 0x02, 0x20, 0x3d, 0xee, + 0xe8, 0x06, 0x0f, 0xdc, 0x70, 0x23, 0x0a, 0x7f, + 0x5b, 0x4a, 0xd7, 0xd7, 0xbc, 0x3e, 0x62, 0x8c, + 0xbe, 0x21, 0x9a, 0x88, 0x6b, 0x84, 0x26, 0x9e, + 0xae, 0xb8, 0x1e, 0x26, 0xb4, 0xfe, 0x01, + 0x41, // OP_DATA_65 + 0x04, 0xae, 0x31, 0xc3, 0x1b, 0xf9, 0x12, 0x78, + 0xd9, 0x9b, 0x83, 0x77, 0xa3, 0x5b, 0xbc, 0xe5, + 0xb2, 0x7d, 0x9f, 0xff, 0x15, 0x45, 0x68, 0x39, + 0xe9, 0x19, 0x45, 0x3f, 0xc7, 0xb3, 0xf7, 0x21, + 0xf0, 0xba, 0x40, 0x3f, 0xf9, 0x6c, 0x9d, 0xee, + 0xb6, 0x80, 0xe5, 0xfd, 0x34, 0x1c, 0x0f, 0xc3, + 0xa7, 0xb9, 0x0d, 0xa4, 0x63, 0x1e, 0xe3, 0x95, + 0x60, 0x63, 0x9d, 0xb4, 0x62, 0xe9, 0xcb, 0x85, + 0x0f, // 65-byte pubkey + }, + Sequence: 0xffffffff, + }, + }, + TxOut: []*btcwire.TxOut{ + &btcwire.TxOut{ + Value: 0xf4240, // 1000000 + PkScript: []byte{ + 0x76, // OP_DUP + 0xa9, // OP_HASH160 + 0x14, // OP_DATA_20 + 0xb0, 0xdc, 0xbf, 0x97, 0xea, 0xbf, 0x44, 0x04, + 0xe3, 0x1d, 0x95, 0x24, 0x77, 0xce, 0x82, 0x2d, + 0xad, 0xbe, 0x7e, 0x10, + 0x88, // OP_EQUALVERIFY + 0xac, // OP_CHECKSIG + }, + }, + &btcwire.TxOut{ + Value: 0x11d260c0, // 299000000 + PkScript: []byte{ + 0x76, // OP_DUP + 0xa9, // OP_HASH160 + 0x14, // OP_DATA_20 + 0x6b, 0x12, 0x81, 0xee, 0xc2, 0x5a, 0xb4, 0xe1, + 0xe0, 0x79, 0x3f, 0xf4, 0xe0, 0x8a, 0xb1, 0xab, + 0xb3, 0x40, 0x9c, 0xd9, + 0x88, // OP_EQUALVERIFY + 0xac, // OP_CHECKSIG + }, + }, + }, + LockTime: 0, + }, + &btcwire.MsgTx{ + Version: 1, + TxIn: []*btcwire.TxIn{ + &btcwire.TxIn{ + PreviousOutpoint: btcwire.OutPoint{ + Hash: btcwire.ShaHash([32]byte{ // Make go vet happy. + 0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73, + 0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac, + 0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90, + 0x9b, 0xa1, 0xc4, 0x3d, 0xed, 0x5f, 0x51, 0xf4, + }), // f4515fed3dc4a19b90a317b9840c243bac26114cf637522373a7d486b372600b + Index: 0, + }, + SignatureScript: []byte{ + 0x49, // OP_DATA_73 + 0x30, 0x46, 0x02, 0x21, 0x00, 0xbb, 0x1a, 0xd2, + 0x6d, 0xf9, 0x30, 0xa5, 0x1c, 0xce, 0x11, 0x0c, + 0xf4, 0x4f, 0x7a, 0x48, 0xc3, 0xc5, 0x61, 0xfd, + 0x97, 0x75, 0x00, 0xb1, 0xae, 0x5d, 0x6b, 0x6f, + 0xd1, 0x3d, 0x0b, 0x3f, 0x4a, 0x02, 0x21, 0x00, + 0xc5, 0xb4, 0x29, 0x51, 0xac, 0xed, 0xff, 0x14, + 0xab, 0xba, 0x27, 0x36, 0xfd, 0x57, 0x4b, 0xdb, + 0x46, 0x5f, 0x3e, 0x6f, 0x8d, 0xa1, 0x2e, 0x2c, + 0x53, 0x03, 0x95, 0x4a, 0xca, 0x7f, 0x78, 0xf3, + 0x01, // 73-byte signature + 0x41, // OP_DATA_65 + 0x04, 0xa7, 0x13, 0x5b, 0xfe, 0x82, 0x4c, 0x97, + 0xec, 0xc0, 0x1e, 0xc7, 0xd7, 0xe3, 0x36, 0x18, + 0x5c, 0x81, 0xe2, 0xaa, 0x2c, 0x41, 0xab, 0x17, + 0x54, 0x07, 0xc0, 0x94, 0x84, 0xce, 0x96, 0x94, + 0xb4, 0x49, 0x53, 0xfc, 0xb7, 0x51, 0x20, 0x65, + 0x64, 0xa9, 0xc2, 0x4d, 0xd0, 0x94, 0xd4, 0x2f, + 0xdb, 0xfd, 0xd5, 0xaa, 0xd3, 0xe0, 0x63, 0xce, + 0x6a, 0xf4, 0xcf, 0xaa, 0xea, 0x4e, 0xa1, 0x4f, + 0xbb, // 65-byte pubkey + }, + Sequence: 0xffffffff, + }, + }, + TxOut: []*btcwire.TxOut{ + &btcwire.TxOut{ + Value: 0xf4240, // 1000000 + PkScript: []byte{ + 0x76, // OP_DUP + 0xa9, // OP_HASH160 + 0x14, // OP_DATA_20 + 0x39, 0xaa, 0x3d, 0x56, 0x9e, 0x06, 0xa1, 0xd7, + 0x92, 0x6d, 0xc4, 0xbe, 0x11, 0x93, 0xc9, 0x9b, + 0xf2, 0xeb, 0x9e, 0xe0, + 0x88, // OP_EQUALVERIFY + 0xac, // OP_CHECKSIG + }, + }, + }, + LockTime: 0, + }, + }, +} diff --git a/cov_report.sh b/cov_report.sh new file mode 100644 index 0000000..307f05b --- /dev/null +++ b/cov_report.sh @@ -0,0 +1,17 @@ +#!/bin/sh + +# This script uses gocov to generate a test coverage report. +# The gocov tool my be obtained with the following command: +# go get github.com/axw/gocov/gocov +# +# It will be installed to $GOPATH/bin, so ensure that location is in your $PATH. + +# Check for gocov. +type gocov >/dev/null 2>&1 +if [ $? -ne 0 ]; then + echo >&2 "This script requires the gocov tool." + echo >&2 "You may obtain it with the following command:" + echo >&2 "go get github.com/axw/gocov/gocov" + exit 1 +fi +gocov test | gocov report diff --git a/doc.go b/doc.go new file mode 100644 index 0000000..0902935 --- /dev/null +++ b/doc.go @@ -0,0 +1,15 @@ +// Copyright (c) 2013 Conformal Systems LLC. +// Use of this source code is governed by an ISC +// license that can be found in the LICENSE file. + +/* +Package btcutil provides bitcoin-specific convenience functions and types. + +Block Overview + +A Block defines a bitcoin block that provides easier and more efficient +manipulation of raw wire protocol blocks. It also memoizes hashes for the +block and its transactions on their first access so subsequent accesses don't +have to repeat the relatively expensive hashing operations. +*/ +package btcutil diff --git a/test_coverage.txt b/test_coverage.txt new file mode 100644 index 0000000..dad4595 --- /dev/null +++ b/test_coverage.txt @@ -0,0 +1,16 @@ + +github.com/conformal/btcutil/block.go Block.TxShas 100.00% (10/10) +github.com/conformal/btcutil/block.go Block.Sha 100.00% (5/5) +github.com/conformal/btcutil/block.go NewBlockFromBlockAndBytes 100.00% (1/1) +github.com/conformal/btcutil/block.go Block.MsgBlock 100.00% (1/1) +github.com/conformal/btcutil/block.go Block.ProtocolVersion 100.00% (1/1) +github.com/conformal/btcutil/block.go Block.Height 100.00% (1/1) +github.com/conformal/btcutil/block.go Block.SetHeight 100.00% (1/1) +github.com/conformal/btcutil/block.go NewBlock 100.00% (1/1) +github.com/conformal/btcutil/block.go Block.Bytes 88.89% (8/9) +github.com/conformal/btcutil/block.go NewBlockFromBytes 85.71% (6/7) +github.com/conformal/btcutil/block.go Block.TxSha 81.82% (9/11) +github.com/conformal/btcutil/block.go Block.TxLoc 0.00% (0/9) +github.com/conformal/btcutil/block.go OutOfRangeError.Error 0.00% (0/1) +github.com/conformal/btcutil ------------------------- 75.86% (44/58) +