state test runs

state/execution_test.go

@@ -80,7 +80,7 @@ func TestBeginBlockAbsentValidators(t *testing.T) {
 		require.Nil(t, err, tc.desc)
 
 		// -> app must receive an index of the absent validator
-		assert.Equal(t, tc.expectedAbsentValidators, app.AbsentValidators, tc.desc)
+		assert.Equal(t, tc.expectedAbsentValidators, app.Validators, tc.desc)
 	}
 }
 
@@ -110,10 +110,10 @@ func TestBeginBlockByzantineValidators(t *testing.T) {
 		expectedByzantineValidators []abci.Evidence
 	}{
 		{"none byzantine", []types.Evidence{}, []abci.Evidence{}},
-		{"one byzantine", []types.Evidence{ev1}, []abci.Evidence{{ev1.Address(), ev1.Height()}}},
+		{"one byzantine", []types.Evidence{ev1}, []abci.Evidence{types.TM2PB.Evidence(ev1)}},
 		{"multiple byzantine", []types.Evidence{ev1, ev2}, []abci.Evidence{
-			{ev1.Address(), ev1.Height()},
-			{ev2.Address(), ev2.Height()}}},
+			types.TM2PB.Evidence(ev1),
+			types.TM2PB.Evidence(ev1)}},
 	}
 
 	for _, tc := range testCases {
@@ -162,7 +162,7 @@ var _ abci.Application = (*testApp)(nil)
 type testApp struct {
 	abci.BaseApplication
 
-	AbsentValidators    []int32
+	Validators          []abci.SigningValidator
 	ByzantineValidators []abci.Evidence
 }
 
@@ -175,7 +175,7 @@ func (app *testApp) Info(req abci.RequestInfo) (resInfo abci.ResponseInfo) {
 }
 
 func (app *testApp) BeginBlock(req abci.RequestBeginBlock) abci.ResponseBeginBlock {
-	app.AbsentValidators = req.AbsentValidators
+	app.Validators = req.Validators
 	app.ByzantineValidators = req.ByzantineValidators
 	return abci.ResponseBeginBlock{}
 }

state/state_test.go

@@ -78,10 +78,7 @@ func TestABCIResponsesSaveLoad1(t *testing.T) {
 	abciResponses.DeliverTx[0] = &abci.ResponseDeliverTx{Data: []byte("foo"), Tags: nil}
 	abciResponses.DeliverTx[1] = &abci.ResponseDeliverTx{Data: []byte("bar"), Log: "ok", Tags: nil}
 	abciResponses.EndBlock = &abci.ResponseEndBlock{ValidatorUpdates: []abci.Validator{
-		{
-			PubKey: crypto.GenPrivKeyEd25519().PubKey().Bytes(),
-			Power:  10,
-		},
+		types.TM2PB.ValidatorFromPubKeyAndPower(crypto.GenPrivKeyEd25519().PubKey(), 10),
 	}}
 
 	saveABCIResponses(stateDB, block.Height, abciResponses)
@@ -435,8 +432,8 @@ func makeHeaderPartsResponsesValPubKeyChange(state State, height int64,
 	if !bytes.Equal(pubkey.Bytes(), val.PubKey.Bytes()) {
 		abciResponses.EndBlock = &abci.ResponseEndBlock{
 			ValidatorUpdates: []abci.Validator{
-				{val.PubKey.Bytes(), 0},
-				{pubkey.Bytes(), 10},
+				types.TM2PB.ValidatorFromPubKeyAndPower(val.PubKey, 0),
+				types.TM2PB.ValidatorFromPubKeyAndPower(pubkey, 10),
 			},
 		}
 	}
@@ -457,7 +454,7 @@ func makeHeaderPartsResponsesValPowerChange(state State, height int64,
 	if val.VotingPower != power {
 		abciResponses.EndBlock = &abci.ResponseEndBlock{
 			ValidatorUpdates: []abci.Validator{
-				{val.PubKey.Bytes(), power},
+				types.TM2PB.ValidatorFromPubKeyAndPower(val.PubKey, power),
 			},
 		}
 	}

types/protobuf.go

@@ -4,18 +4,18 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/tendermint/abci/types"
+	abci "github.com/tendermint/abci/types"
 	crypto "github.com/tendermint/go-crypto"
 )
 
-// TM2PB is used for converting Tendermint types to protobuf types.
+// TM2PB is used for converting Tendermint abci to protobuf abci.
 // UNSTABLE
 var TM2PB = tm2pb{}
 
 type tm2pb struct{}
 
-func (tm2pb) Header(header *Header) types.Header {
-	return types.Header{
+func (tm2pb) Header(header *Header) abci.Header {
+	return abci.Header{
 		ChainID:       header.ChainID,
 		Height:        header.Height,
 		Time:          header.Time.Unix(),
@@ -25,22 +25,22 @@ func (tm2pb) Header(header *Header) types.Header {
 	}
 }
 
-func (tm2pb) Validator(val *Validator) types.Validator {
-	return types.Validator{
+func (tm2pb) Validator(val *Validator) abci.Validator {
+	return abci.Validator{
 		PubKey: TM2PB.PubKey(val.PubKey),
 		Power:  val.VotingPower,
 	}
 }
 
-func (tm2pb) PubKey(pubKey crypto.PubKey) types.PubKey {
+func (tm2pb) PubKey(pubKey crypto.PubKey) abci.PubKey {
 	switch pk := pubKey.(type) {
 	case crypto.PubKeyEd25519:
-		return types.PubKey{
+		return abci.PubKey{
 			Type: "ed25519",
 			Data: pk[:],
 		}
 	case crypto.PubKeySecp256k1:
-		return types.PubKey{
+		return abci.PubKey{
 			Type: "secp256k1",
 			Data: pk[:],
 		}
@@ -49,42 +49,70 @@ func (tm2pb) PubKey(pubKey crypto.PubKey) types.PubKey {
 	}
 }
 
-func (tm2pb) Validators(vals *ValidatorSet) []types.Validator {
-	validators := make([]types.Validator, len(vals.Validators))
+func (tm2pb) Validators(vals *ValidatorSet) []abci.Validator {
+	validators := make([]abci.Validator, len(vals.Validators))
 	for i, val := range vals.Validators {
 		validators[i] = TM2PB.Validator(val)
 	}
 	return validators
 }
 
-func (tm2pb) ConsensusParams(params *ConsensusParams) *types.ConsensusParams {
-	return &types.ConsensusParams{
-		BlockSize: &types.BlockSize{
+func (tm2pb) ConsensusParams(params *ConsensusParams) *abci.ConsensusParams {
+	return &abci.ConsensusParams{
+		BlockSize: &abci.BlockSize{
 
 			MaxBytes: int32(params.BlockSize.MaxBytes),
 			MaxTxs:   int32(params.BlockSize.MaxTxs),
 			MaxGas:   params.BlockSize.MaxGas,
 		},
-		TxSize: &types.TxSize{
+		TxSize: &abci.TxSize{
 			MaxBytes: int32(params.TxSize.MaxBytes),
 			MaxGas:   params.TxSize.MaxGas,
 		},
-		BlockGossip: &types.BlockGossip{
+		BlockGossip: &abci.BlockGossip{
 			BlockPartSizeBytes: int32(params.BlockGossip.BlockPartSizeBytes),
 		},
 	}
 }
 
+func (tm2pb) Evidence(ev_ Evidence) abci.Evidence {
+	switch ev := ev_.(type) {
+	case *DuplicateVoteEvidence:
+		return abci.Evidence{
+			Type: "duplicate/vote",
+			Validator: abci.Validator{
+				Address: ev.Address(),
+				// TODO
+			},
+			Height: ev.Height(),
+			//	Time:             ev.Time(),
+			//	TotalVotingPower: 10,
+		}
+	default:
+		panic(fmt.Sprintf("Unknown evidence type: %v %v", ev_, reflect.TypeOf(ev_)))
+	}
+
+}
+
+func (tm2pb) ValidatorFromPubKeyAndPower(pubkey crypto.PubKey, power int64) abci.Validator {
+	pubkeyABCI := TM2PB.PubKey(pubkey)
+	return abci.Validator{
+		Address: pubkey.Address(),
+		PubKey:  pubkeyABCI,
+		Power:   power,
+	}
+}
+
 //----------------------------------------------------------------------------
 
-// PB2TM is used for converting protobuf types to Tendermint types.
+// PB2TM is used for converting protobuf abci to Tendermint abci.
 // UNSTABLE
 var PB2TM = pb2tm{}
 
 type pb2tm struct{}
 
 // TODO: validate key lengths ...
-func (pb2tm) PubKey(pubKey types.PubKey) (crypto.PubKey, error) {
+func (pb2tm) PubKey(pubKey abci.PubKey) (crypto.PubKey, error) {
 	switch pubKey.Type {
 	case "ed25519":
 		var pk crypto.PubKeyEd25519