You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
175 lines
4.7 KiB
175 lines
4.7 KiB
package types
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/sha256"
|
|
"errors"
|
|
"fmt"
|
|
|
|
abci "github.com/tendermint/tendermint/abci/types"
|
|
"github.com/tendermint/tendermint/crypto/merkle"
|
|
"github.com/tendermint/tendermint/crypto/tmhash"
|
|
tmbytes "github.com/tendermint/tendermint/libs/bytes"
|
|
tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
|
|
)
|
|
|
|
// Tx is an arbitrary byte array.
|
|
// NOTE: Tx has no types at this level, so when wire encoded it's just length-prefixed.
|
|
// Might we want types here ?
|
|
type Tx []byte
|
|
|
|
// Key produces a fixed-length key for use in indexing.
|
|
func (tx Tx) Key() TxKey { return sha256.Sum256(tx) }
|
|
|
|
// Hash computes the TMHASH hash of the wire encoded transaction.
|
|
func (tx Tx) Hash() []byte { return tmhash.Sum(tx) }
|
|
|
|
// String returns the hex-encoded transaction as a string.
|
|
func (tx Tx) String() string { return fmt.Sprintf("Tx{%X}", []byte(tx)) }
|
|
|
|
// Txs is a slice of Tx.
|
|
type Txs []Tx
|
|
|
|
// Hash returns the Merkle root hash of the transaction hashes.
|
|
// i.e. the leaves of the tree are the hashes of the txs.
|
|
func (txs Txs) Hash() []byte {
|
|
// These allocations will be removed once Txs is switched to [][]byte,
|
|
// ref #2603. This is because golang does not allow type casting slices without unsafe
|
|
txBzs := make([][]byte, len(txs))
|
|
for i := 0; i < len(txs); i++ {
|
|
txBzs[i] = txs[i].Hash()
|
|
}
|
|
return merkle.HashFromByteSlices(txBzs)
|
|
}
|
|
|
|
// Index returns the index of this transaction in the list, or -1 if not found
|
|
func (txs Txs) Index(tx Tx) int {
|
|
for i := range txs {
|
|
if bytes.Equal(txs[i], tx) {
|
|
return i
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
|
|
// IndexByHash returns the index of this transaction hash in the list, or -1 if not found
|
|
func (txs Txs) IndexByHash(hash []byte) int {
|
|
for i := range txs {
|
|
if bytes.Equal(txs[i].Hash(), hash) {
|
|
return i
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
|
|
// ToSliceOfBytes converts a Txs to slice of byte slices.
|
|
//
|
|
// NOTE: This method should become obsolete once Txs is switched to [][]byte.
|
|
// ref: #2603
|
|
// TODO This function is to disappear when TxRecord is introduced
|
|
func (txs Txs) ToSliceOfBytes() [][]byte {
|
|
txBzs := make([][]byte, len(txs))
|
|
for i := 0; i < len(txs); i++ {
|
|
txBzs[i] = txs[i]
|
|
}
|
|
return txBzs
|
|
}
|
|
|
|
// ToTxs converts a raw slice of byte slices into a Txs type.
|
|
// TODO This function is to disappear when TxRecord is introduced
|
|
func ToTxs(txs [][]byte) Txs {
|
|
txBzs := make(Txs, len(txs))
|
|
for i := 0; i < len(txs); i++ {
|
|
txBzs[i] = txs[i]
|
|
}
|
|
return txBzs
|
|
}
|
|
|
|
// TxRecordsToTxs converts from the abci Tx type to the the Txs type.
|
|
func TxRecordsToTxs(trs []*abci.TxRecord) Txs {
|
|
txs := make([]Tx, len(trs))
|
|
for i, tr := range trs {
|
|
txs[i] = Tx(tr.Tx)
|
|
}
|
|
return txs
|
|
}
|
|
|
|
// TxsToTxRecords converts from a list of Txs to a list of TxRecords. All of the
|
|
// resulting TxRecords are returned with the status TxRecord_UNMODIFIED.
|
|
func TxsToTxRecords(txs []Tx) []*abci.TxRecord {
|
|
trs := make([]*abci.TxRecord, len(txs))
|
|
for i, tx := range txs {
|
|
trs[i] = &abci.TxRecord{
|
|
Action: abci.TxRecord_UNMODIFIED,
|
|
Tx: tx,
|
|
}
|
|
}
|
|
return trs
|
|
}
|
|
|
|
// TxProof represents a Merkle proof of the presence of a transaction in the Merkle tree.
|
|
type TxProof struct {
|
|
RootHash tmbytes.HexBytes `json:"root_hash"`
|
|
Data Tx `json:"data"`
|
|
Proof merkle.Proof `json:"proof"`
|
|
}
|
|
|
|
// Leaf returns the hash(tx), which is the leaf in the merkle tree which this proof refers to.
|
|
func (tp TxProof) Leaf() []byte {
|
|
return tp.Data.Hash()
|
|
}
|
|
|
|
// Validate verifies the proof. It returns nil if the RootHash matches the dataHash argument,
|
|
// and if the proof is internally consistent. Otherwise, it returns a sensible error.
|
|
func (tp TxProof) Validate(dataHash []byte) error {
|
|
if !bytes.Equal(dataHash, tp.RootHash) {
|
|
return errors.New("proof matches different data hash")
|
|
}
|
|
if tp.Proof.Index < 0 {
|
|
return errors.New("proof index cannot be negative")
|
|
}
|
|
if tp.Proof.Total <= 0 {
|
|
return errors.New("proof total must be positive")
|
|
}
|
|
valid := tp.Proof.Verify(tp.RootHash, tp.Leaf())
|
|
if valid != nil {
|
|
return errors.New("proof is not internally consistent")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (tp TxProof) ToProto() tmproto.TxProof {
|
|
|
|
pbProof := tp.Proof.ToProto()
|
|
|
|
pbtp := tmproto.TxProof{
|
|
RootHash: tp.RootHash,
|
|
Data: tp.Data,
|
|
Proof: pbProof,
|
|
}
|
|
|
|
return pbtp
|
|
}
|
|
func TxProofFromProto(pb tmproto.TxProof) (TxProof, error) {
|
|
|
|
pbProof, err := merkle.ProofFromProto(pb.Proof)
|
|
if err != nil {
|
|
return TxProof{}, err
|
|
}
|
|
|
|
pbtp := TxProof{
|
|
RootHash: pb.RootHash,
|
|
Data: pb.Data,
|
|
Proof: *pbProof,
|
|
}
|
|
|
|
return pbtp, nil
|
|
}
|
|
|
|
// ComputeProtoSizeForTxs wraps the transactions in tmproto.Data{} and calculates the size.
|
|
// https://developers.google.com/protocol-buffers/docs/encoding
|
|
func ComputeProtoSizeForTxs(txs []Tx) int64 {
|
|
data := Data{Txs: txs}
|
|
pdData := data.ToProto()
|
|
return int64(pdData.Size())
|
|
}
|