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.
 
 
 
 
 
 

300 lines
6.8 KiB

package types
import (
"bytes"
"crypto/sha256"
"errors"
"fmt"
"strings"
"time"
"github.com/tendermint/tendermint/account"
"github.com/tendermint/tendermint/binary"
. "github.com/tendermint/tendermint/common"
"github.com/tendermint/tendermint/config"
"github.com/tendermint/tendermint/merkle"
)
type Block struct {
*Header
*Validation
*Data
}
// Basic validation that doesn't involve state data.
func (b *Block) ValidateBasic(lastBlockHeight uint, lastBlockHash []byte,
lastBlockParts PartSetHeader, lastBlockTime time.Time) error {
if b.Network != config.App().GetString("Network") {
return errors.New("Wrong Block.Header.Network")
}
if b.Height != lastBlockHeight+1 {
return errors.New("Wrong Block.Header.Height")
}
if b.NumTxs != uint(len(b.Data.Txs)) {
return errors.New("Wrong Block.Header.NumTxs")
}
if !bytes.Equal(b.LastBlockHash, lastBlockHash) {
return errors.New("Wrong Block.Header.LastBlockHash")
}
if !b.LastBlockParts.Equals(lastBlockParts) {
return errors.New("Wrong Block.Header.LastBlockParts")
}
/* TODO: Determine bounds
See blockchain/reactor "stopSyncingDurationMinutes"
if !b.Time.After(lastBlockTime) {
return errors.New("Invalid Block.Header.Time")
}
*/
if b.Header.Height != 1 {
if err := b.Validation.ValidateBasic(); err != nil {
return err
}
}
// XXX more validation
return nil
}
// Computes and returns the block hash.
// If the block is incomplete (e.g. missing Header.StateHash)
// then the hash is nil, to prevent the usage of that hash.
func (b *Block) Hash() []byte {
if b.Header == nil || b.Validation == nil || b.Data == nil {
return nil
}
hashHeader := b.Header.Hash()
hashValidation := b.Validation.Hash()
hashData := b.Data.Hash()
// If hashHeader is nil, required fields are missing.
if len(hashHeader) == 0 {
return nil
}
// Merkle hash from subhashes.
hashes := [][]byte{hashHeader, hashValidation, hashData}
return merkle.HashFromHashes(hashes)
}
func (b *Block) MakePartSet() *PartSet {
return NewPartSetFromData(binary.BinaryBytes(b))
}
// Convenience.
// A nil block never hashes to anything.
// Nothing hashes to a nil hash.
func (b *Block) HashesTo(hash []byte) bool {
if len(hash) == 0 {
return false
}
if b == nil {
return false
}
return bytes.Equal(b.Hash(), hash)
}
func (b *Block) String() string {
return b.StringIndented("")
}
func (b *Block) StringIndented(indent string) string {
if b == nil {
return "nil-Block"
}
return fmt.Sprintf(`Block{
%s %v
%s %v
%s %v
%s}#%X`,
indent, b.Header.StringIndented(indent+" "),
indent, b.Validation.StringIndented(indent+" "),
indent, b.Data.StringIndented(indent+" "),
indent, b.Hash())
}
func (b *Block) StringShort() string {
if b == nil {
return "nil-Block"
} else {
return fmt.Sprintf("Block#%X", b.Hash())
}
}
//-----------------------------------------------------------------------------
type Header struct {
Network string
Height uint
Time time.Time
Fees uint64
NumTxs uint
LastBlockHash []byte
LastBlockParts PartSetHeader
StateHash []byte
}
// NOTE: hash is nil if required fields are missing.
func (h *Header) Hash() []byte {
if len(h.StateHash) == 0 {
return nil
}
buf := new(bytes.Buffer)
hasher, n, err := sha256.New(), new(int64), new(error)
binary.WriteBinary(h, buf, n, err)
if *err != nil {
panic(err)
}
hasher.Write(buf.Bytes())
hash := hasher.Sum(nil)
return hash
}
func (h *Header) StringIndented(indent string) string {
if h == nil {
return "nil-Header"
}
return fmt.Sprintf(`Header{
%s Network: %v
%s Height: %v
%s Time: %v
%s Fees: %v
%s NumTxs: %v
%s LastBlockHash: %X
%s LastBlockParts: %v
%s StateHash: %X
%s}#%X`,
indent, h.Network,
indent, h.Height,
indent, h.Time,
indent, h.Fees,
indent, h.NumTxs,
indent, h.LastBlockHash,
indent, h.LastBlockParts,
indent, h.StateHash,
indent, h.Hash())
}
//-----------------------------------------------------------------------------
type Commit struct {
Address []byte
Round uint
Signature account.SignatureEd25519
}
func (commit Commit) IsZero() bool {
return commit.Round == 0 && commit.Signature.IsZero()
}
func (commit Commit) String() string {
return fmt.Sprintf("Commit{A:%X R:%v %X}", commit.Address, commit.Round, Fingerprint(commit.Signature))
}
//-------------------------------------
// NOTE: The Commits are in order of address to preserve the bonded ValidatorSet order.
// Any peer with a block can gossip commits by index with a peer without recalculating the
// active ValidatorSet.
type Validation struct {
Commits []Commit // Commits (or nil) of all active validators in address order.
// Volatile
hash []byte
bitArray BitArray
}
func (v *Validation) ValidateBasic() error {
if len(v.Commits) == 0 {
return errors.New("No commits in validation")
}
lastAddress := []byte{}
for i := 0; i < len(v.Commits); i++ {
commit := v.Commits[i]
if commit.IsZero() {
if len(commit.Address) > 0 {
return errors.New("Zero commits should not have an address")
}
} else {
if len(commit.Address) == 0 {
return errors.New("Nonzero commits should have an address")
}
if len(lastAddress) > 0 && bytes.Compare(lastAddress, commit.Address) != -1 {
return errors.New("Invalid commit order")
}
lastAddress = commit.Address
}
}
return nil
}
func (v *Validation) Hash() []byte {
if v.hash == nil {
bs := make([]interface{}, len(v.Commits))
for i, commit := range v.Commits {
bs[i] = commit
}
v.hash = merkle.HashFromBinaries(bs)
}
return v.hash
}
func (v *Validation) StringIndented(indent string) string {
if v == nil {
return "nil-Validation"
}
commitStrings := make([]string, len(v.Commits))
for i, commit := range v.Commits {
commitStrings[i] = commit.String()
}
return fmt.Sprintf(`Validation{
%s %v
%s}#%X`,
indent, strings.Join(commitStrings, "\n"+indent+" "),
indent, v.hash)
}
func (v *Validation) BitArray() BitArray {
if v.bitArray.IsZero() {
v.bitArray = NewBitArray(uint(len(v.Commits)))
for i, commit := range v.Commits {
v.bitArray.SetIndex(uint(i), !commit.IsZero())
}
}
return v.bitArray
}
//-----------------------------------------------------------------------------
type Data struct {
Txs []Tx
// Volatile
hash []byte
}
func (data *Data) Hash() []byte {
if data.hash == nil {
bs := make([]interface{}, len(data.Txs))
for i, tx := range data.Txs {
bs[i] = tx
}
data.hash = merkle.HashFromBinaries(bs)
}
return data.hash
}
func (data *Data) StringIndented(indent string) string {
if data == nil {
return "nil-Data"
}
txStrings := make([]string, len(data.Txs))
for i, tx := range data.Txs {
txStrings[i] = fmt.Sprintf("Tx:%v", tx)
}
return fmt.Sprintf(`Data{
%s %v
%s}#%X`,
indent, strings.Join(txStrings, "\n"+indent+" "),
indent, data.hash)
}