zolfa
/
tendermint


								package state


								import (

									"bytes"

									"fmt"

									"io/ioutil"

									"time"


									"github.com/tendermint/tendermint/types"

								)


								// database keys

								var (

									stateKey = []byte("stateKey")

								)


								//-----------------------------------------------------------------------------


								// State is a short description of the latest committed block of the Tendermint consensus.

								// It keeps all information necessary to validate new blocks,

								// including the last validator set and the consensus params.

								// All fields are exposed so the struct can be easily serialized,

								// but none of them should be mutated directly.

								// Instead, use state.Copy() or state.NextState(...).

								// NOTE: not goroutine-safe.

								type State struct {

									// immutable

									ChainID string


									// LastBlockHeight=0 at genesis (ie. block(H=0) does not exist)

									LastBlockHeight  int64

									LastBlockTotalTx int64

									LastBlockID      types.BlockID

									LastBlockTime    time.Time


									// LastValidators is used to validate block.LastCommit.

									// Validators are persisted to the database separately every time they change,

									// so we can query for historical validator sets.

									// Note that if s.LastBlockHeight causes a valset change,

									// we set s.LastHeightValidatorsChanged = s.LastBlockHeight + 1

									NextValidators              *types.ValidatorSet

									Validators                  *types.ValidatorSet

									LastValidators              *types.ValidatorSet

									LastHeightValidatorsChanged int64


									// Consensus parameters used for validating blocks.

									// Changes returned by EndBlock and updated after Commit.

									ConsensusParams                  types.ConsensusParams

									LastHeightConsensusParamsChanged int64


									// Merkle root of the results from executing prev block

									LastResultsHash []byte


									// the latest AppHash we've received from calling abci.Commit()

									AppHash []byte

								}


								// Copy makes a copy of the State for mutating.

								func (state State) Copy() State {

									return State{

										ChainID: state.ChainID,


										LastBlockHeight:  state.LastBlockHeight,

										LastBlockTotalTx: state.LastBlockTotalTx,

										LastBlockID:      state.LastBlockID,

										LastBlockTime:    state.LastBlockTime,


										NextValidators:              state.NextValidators.Copy(),

										Validators:                  state.Validators.Copy(),

										LastValidators:              state.LastValidators.Copy(),

										LastHeightValidatorsChanged: state.LastHeightValidatorsChanged,


										ConsensusParams:                  state.ConsensusParams,

										LastHeightConsensusParamsChanged: state.LastHeightConsensusParamsChanged,


										AppHash: state.AppHash,


										LastResultsHash: state.LastResultsHash,

									}

								}


								// Equals returns true if the States are identical.

								func (state State) Equals(state2 State) bool {

									sbz, s2bz := state.Bytes(), state2.Bytes()

									return bytes.Equal(sbz, s2bz)

								}


								// Bytes serializes the State using go-amino.

								func (state State) Bytes() []byte {

									return cdc.MustMarshalBinaryBare(state)

								}


								// IsEmpty returns true if the State is equal to the empty State.

								func (state State) IsEmpty() bool {

									return state.Validators == nil // XXX can't compare to Empty

								}


								//------------------------------------------------------------------------

								// Create a block from the latest state


								// MakeBlock builds a block with the given txs and commit from the current state.

								func (state State) MakeBlock(height int64, txs []types.Tx, commit *types.Commit) (*types.Block, *types.PartSet) {

									// Build base block.

									block := types.MakeBlock(height, txs, commit)


									// Fill header with state data.

									block.ChainID = state.ChainID

									block.TotalTxs = state.LastBlockTotalTx + block.NumTxs

									block.LastBlockID = state.LastBlockID

									block.ValidatorsHash = state.Validators.Hash()

									block.NextValidatorsHash = state.NextValidators.Hash()

									block.AppHash = state.AppHash

									block.ConsensusHash = state.ConsensusParams.Hash()

									block.LastResultsHash = state.LastResultsHash


									return block, block.MakePartSet(state.ConsensusParams.BlockGossip.BlockPartSizeBytes)

								}


								//------------------------------------------------------------------------

								// Genesis


								// MakeGenesisStateFromFile reads and unmarshals state from the given

								// file.

								//

								// Used during replay and in tests.

								func MakeGenesisStateFromFile(genDocFile string) (State, error) {

									genDoc, err := MakeGenesisDocFromFile(genDocFile)

									if err != nil {

										return State{}, err

									}

									return MakeGenesisState(genDoc)

								}


								// MakeGenesisDocFromFile reads and unmarshals genesis doc from the given file.

								func MakeGenesisDocFromFile(genDocFile string) (*types.GenesisDoc, error) {

									genDocJSON, err := ioutil.ReadFile(genDocFile)

									if err != nil {

										return nil, fmt.Errorf("Couldn't read GenesisDoc file: %v", err)

									}

									genDoc, err := types.GenesisDocFromJSON(genDocJSON)

									if err != nil {

										return nil, fmt.Errorf("Error reading GenesisDoc: %v", err)

									}

									return genDoc, nil

								}


								// MakeGenesisState creates state from types.GenesisDoc.

								func MakeGenesisState(genDoc *types.GenesisDoc) (State, error) {

									err := genDoc.ValidateAndComplete()

									if err != nil {

										return State{}, fmt.Errorf("Error in genesis file: %v", err)

									}


									// Make validators slice

									validators := make([]*types.Validator, len(genDoc.Validators))

									for i, val := range genDoc.Validators {

										pubKey := val.PubKey

										address := pubKey.Address()


										// Make validator

										validators[i] = &types.Validator{

											Address:     address,

											PubKey:      pubKey,

											VotingPower: val.Power,

										}

									}


									return State{


										ChainID: genDoc.ChainID,


										LastBlockHeight: 0,

										LastBlockID:     types.BlockID{},

										LastBlockTime:   genDoc.GenesisTime,


										NextValidators:              types.NewValidatorSet(validators).CopyIncrementAccum(1),

										Validators:                  types.NewValidatorSet(validators),

										LastValidators:              types.NewValidatorSet(nil),

										LastHeightValidatorsChanged: 1,


										ConsensusParams:                  *genDoc.ConsensusParams,

										LastHeightConsensusParamsChanged: 1,


										AppHash: genDoc.AppHash,

									}, nil

								}