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
95 lines
3.3 KiB
Go
95 lines
3.3 KiB
Go
// Copyright (c) 2015-2016 The btcsuite developers
|
|
// Use of this source code is governed by an ISC
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Provides functions for sorting tx inputs and outputs according to BIP 69
|
|
// (https://github.com/bitcoin/bips/blob/master/bip-0069.mediawiki)
|
|
|
|
package txsort
|
|
|
|
import (
|
|
"bytes"
|
|
"sort"
|
|
|
|
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
|
"github.com/btcsuite/btcd/wire"
|
|
)
|
|
|
|
// InPlaceSort modifies the passed transaction inputs and outputs to be sorted
|
|
// based on BIP 69.
|
|
//
|
|
// WARNING: This function must NOT be called with published transactions since
|
|
// it will mutate the transaction if it's not already sorted. This can cause
|
|
// issues if you mutate a tx in a block, for example, which would invalidate the
|
|
// block. It could also cause cached hashes, such as in a btcutil.Tx to become
|
|
// invalidated.
|
|
//
|
|
// The function should only be used if the caller is creating the transaction or
|
|
// is otherwise 100% positive mutating will not cause adverse affects due to
|
|
// other dependencies.
|
|
func InPlaceSort(tx *wire.MsgTx) {
|
|
sort.Sort(sortableInputSlice(tx.TxIn))
|
|
sort.Sort(sortableOutputSlice(tx.TxOut))
|
|
}
|
|
|
|
// Sort returns a new transaction with the inputs and outputs sorted based on
|
|
// BIP 69. The passed transaction is not modified and the new transaction
|
|
// might have a different hash if any sorting was done.
|
|
func Sort(tx *wire.MsgTx) *wire.MsgTx {
|
|
txCopy := tx.Copy()
|
|
sort.Sort(sortableInputSlice(txCopy.TxIn))
|
|
sort.Sort(sortableOutputSlice(txCopy.TxOut))
|
|
return txCopy
|
|
}
|
|
|
|
// IsSorted checks whether tx has inputs and outputs sorted according to BIP
|
|
// 69.
|
|
func IsSorted(tx *wire.MsgTx) bool {
|
|
if !sort.IsSorted(sortableInputSlice(tx.TxIn)) {
|
|
return false
|
|
}
|
|
if !sort.IsSorted(sortableOutputSlice(tx.TxOut)) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
type sortableInputSlice []*wire.TxIn
|
|
type sortableOutputSlice []*wire.TxOut
|
|
|
|
// For SortableInputSlice and SortableOutputSlice, three functions are needed
|
|
// to make it sortable with sort.Sort() -- Len, Less, and Swap
|
|
// Len and Swap are trivial. Less is BIP 69 specific.
|
|
func (s sortableInputSlice) Len() int { return len(s) }
|
|
func (s sortableOutputSlice) Len() int { return len(s) }
|
|
func (s sortableOutputSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
|
|
func (s sortableInputSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
|
|
|
|
// Input comparison function.
|
|
// First sort based on input hash (reversed / rpc-style), then index.
|
|
func (s sortableInputSlice) Less(i, j int) bool {
|
|
// Input hashes are the same, so compare the index.
|
|
ihash := s[i].PreviousOutPoint.Hash
|
|
jhash := s[j].PreviousOutPoint.Hash
|
|
if ihash == jhash {
|
|
return s[i].PreviousOutPoint.Index < s[j].PreviousOutPoint.Index
|
|
}
|
|
|
|
// At this point, the hashes are not equal, so reverse them to
|
|
// big-endian and return the result of the comparison.
|
|
const hashSize = chainhash.HashSize
|
|
for b := 0; b < hashSize/2; b++ {
|
|
ihash[b], ihash[hashSize-1-b] = ihash[hashSize-1-b], ihash[b]
|
|
jhash[b], jhash[hashSize-1-b] = jhash[hashSize-1-b], jhash[b]
|
|
}
|
|
return bytes.Compare(ihash[:], jhash[:]) == -1
|
|
}
|
|
|
|
// Output comparison function.
|
|
// First sort based on amount (smallest first), then PkScript.
|
|
func (s sortableOutputSlice) Less(i, j int) bool {
|
|
if s[i].Value == s[j].Value {
|
|
return bytes.Compare(s[i].PkScript, s[j].PkScript) < 0
|
|
}
|
|
return s[i].Value < s[j].Value
|
|
}
|