22c91fa80a
This updates all code in the main package and subpackages to make use of the new chainhash package since the old wire.ShaHash type and functions have been removed in favor of the abstracted package. Also, since this required API changes anyways and the hash algorithm is no longer tied specifically to SHA, all other functions throughout the code base which had "Sha" in their name have been changed to Hash so they are not incorrectly implying the hash algorithm. The following is an overview of the changes: - Update all references to wire.ShaHash to the new chainhash.Hash type - Rename the following functions and update all references: - Block.Sha -> Hash - Block.TxSha -> TxHash - Tx.Sha -> Hash - bloom.Filter.AddShaHash -> AddHash - Rename all variables that included sha in their name to include hash instead - Add license headers to coinset package files
93 lines
2.6 KiB
Go
93 lines
2.6 KiB
Go
// Copyright (c) 2013-2016 The btcsuite developers
|
|
// Use of this source code is governed by an ISC
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package btcutil
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
|
|
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
|
"github.com/btcsuite/btcd/wire"
|
|
)
|
|
|
|
// TxIndexUnknown is the value returned for a transaction index that is unknown.
|
|
// This is typically because the transaction has not been inserted into a block
|
|
// yet.
|
|
const TxIndexUnknown = -1
|
|
|
|
// Tx defines a bitcoin transaction that provides easier and more efficient
|
|
// manipulation of raw transactions. It also memoizes the hash for the
|
|
// transaction on its first access so subsequent accesses don't have to repeat
|
|
// the relatively expensive hashing operations.
|
|
type Tx struct {
|
|
msgTx *wire.MsgTx // Underlying MsgTx
|
|
txHash *chainhash.Hash // Cached transaction hash
|
|
txIndex int // Position within a block or TxIndexUnknown
|
|
}
|
|
|
|
// MsgTx returns the underlying wire.MsgTx for the transaction.
|
|
func (t *Tx) MsgTx() *wire.MsgTx {
|
|
// Return the cached transaction.
|
|
return t.msgTx
|
|
}
|
|
|
|
// Hash returns the hash of the transaction. This is equivalent to
|
|
// calling TxHash on the underlying wire.MsgTx, however it caches the
|
|
// result so subsequent calls are more efficient.
|
|
func (t *Tx) Hash() *chainhash.Hash {
|
|
// Return the cached hash if it has already been generated.
|
|
if t.txHash != nil {
|
|
return t.txHash
|
|
}
|
|
|
|
// Cache the hash and return it.
|
|
hash := t.msgTx.TxHash()
|
|
t.txHash = &hash
|
|
return &hash
|
|
}
|
|
|
|
// Index returns the saved index of the transaction within a block. This value
|
|
// will be TxIndexUnknown if it hasn't already explicitly been set.
|
|
func (t *Tx) Index() int {
|
|
return t.txIndex
|
|
}
|
|
|
|
// SetIndex sets the index of the transaction in within a block.
|
|
func (t *Tx) SetIndex(index int) {
|
|
t.txIndex = index
|
|
}
|
|
|
|
// NewTx returns a new instance of a bitcoin transaction given an underlying
|
|
// wire.MsgTx. See Tx.
|
|
func NewTx(msgTx *wire.MsgTx) *Tx {
|
|
return &Tx{
|
|
msgTx: msgTx,
|
|
txIndex: TxIndexUnknown,
|
|
}
|
|
}
|
|
|
|
// NewTxFromBytes returns a new instance of a bitcoin transaction given the
|
|
// serialized bytes. See Tx.
|
|
func NewTxFromBytes(serializedTx []byte) (*Tx, error) {
|
|
br := bytes.NewReader(serializedTx)
|
|
return NewTxFromReader(br)
|
|
}
|
|
|
|
// NewTxFromReader returns a new instance of a bitcoin transaction given a
|
|
// Reader to deserialize the transaction. See Tx.
|
|
func NewTxFromReader(r io.Reader) (*Tx, error) {
|
|
// Deserialize the bytes into a MsgTx.
|
|
var msgTx wire.MsgTx
|
|
err := msgTx.Deserialize(r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
t := Tx{
|
|
msgTx: &msgTx,
|
|
txIndex: TxIndexUnknown,
|
|
}
|
|
return &t, nil
|
|
}
|