proto: leftover amino (#4986)

config/toml.go

@@ -323,7 +323,7 @@ max_txs_bytes = {{ .Mempool.MaxTxsBytes }}
 cache_size = {{ .Mempool.CacheSize }}
 
 # Maximum size of a single transaction.
-# NOTE: the max size of a tx transmitted over the network is {max_tx_bytes} + {amino overhead}.
+# NOTE: the max size of a tx transmitted over the network is {max_tx_bytes}.
 max_tx_bytes = {{ .Mempool.MaxTxBytes }}
 
 #######################################################

crypto/ed25519/ed25519.go

@@ -18,8 +18,8 @@ import (
 var _ crypto.PrivKey = PrivKey{}
 
 const (
-	PrivKeyAminoName = "tendermint/PrivKeyEd25519"
-	PubKeyAminoName  = "tendermint/PubKeyEd25519"
+	PrivKeyName = "tendermint/PrivKeyEd25519"
+	PubKeyName  = "tendermint/PubKeyEd25519"
 	// PubKeySize is is the size, in bytes, of public keys as used in this package.
 	PubKeySize = 32
 	// PrivateKeySize is the size, in bytes, of private keys as used in this package.
@@ -35,8 +35,8 @@ const (
 )
 
 func init() {
-	tmjson.RegisterType(PubKey{}, PubKeyAminoName)
-	tmjson.RegisterType(PrivKey{}, PrivKeyAminoName)
+	tmjson.RegisterType(PubKey{}, PubKeyName)
+	tmjson.RegisterType(PrivKey{}, PrivKeyName)
 }
 
 // PrivKey implements crypto.PrivKey.

crypto/ed25519/encoding.go

@@ -1,18 +0,0 @@
-package ed25519
-
-import (
-	amino "github.com/tendermint/go-amino"
-	"github.com/tendermint/tendermint/crypto"
-)
-
-var cdc = amino.NewCodec()
-
-func init() {
-	cdc.RegisterInterface((*crypto.PubKey)(nil), nil)
-	cdc.RegisterConcrete(PubKey{},
-		PubKeyAminoName, nil)
-
-	cdc.RegisterInterface((*crypto.PrivKey)(nil), nil)
-	cdc.RegisterConcrete(PrivKey{},
-		PrivKeyAminoName, nil)
-}

crypto/encoding/amino/amino.go

@@ -30,9 +30,9 @@ func init() {
 
 	// TODO: Have amino provide a way to go from concrete struct to route directly.
 	// Its currently a private API
-	nameTable[reflect.TypeOf(ed25519.PubKey{})] = ed25519.PubKeyAminoName
-	nameTable[reflect.TypeOf(sr25519.PubKey{})] = sr25519.PubKeyAminoName
-	nameTable[reflect.TypeOf(secp256k1.PubKey{})] = secp256k1.PubKeyAminoName
+	nameTable[reflect.TypeOf(ed25519.PubKey{})] = ed25519.PubKeyName
+	nameTable[reflect.TypeOf(sr25519.PubKey{})] = sr25519.PubKeyName
+	nameTable[reflect.TypeOf(secp256k1.PubKey{})] = secp256k1.PubKeyName
 }
 
 // PubkeyAminoName returns the amino route of a pubkey
@@ -48,19 +48,19 @@ func RegisterAmino(cdc *amino.Codec) {
 	// These are all written here instead of
 	cdc.RegisterInterface((*crypto.PubKey)(nil), nil)
 	cdc.RegisterConcrete(ed25519.PubKey{},
-		ed25519.PubKeyAminoName, nil)
+		ed25519.PubKeyName, nil)
 	cdc.RegisterConcrete(sr25519.PubKey{},
-		sr25519.PubKeyAminoName, nil)
+		sr25519.PubKeyName, nil)
 	cdc.RegisterConcrete(secp256k1.PubKey{},
-		secp256k1.PubKeyAminoName, nil)
+		secp256k1.PubKeyName, nil)
 
 	cdc.RegisterInterface((*crypto.PrivKey)(nil), nil)
 	cdc.RegisterConcrete(ed25519.PrivKey{},
-		ed25519.PrivKeyAminoName, nil)
+		ed25519.PrivKeyName, nil)
 	cdc.RegisterConcrete(sr25519.PrivKey{},
-		sr25519.PrivKeyAminoName, nil)
+		sr25519.PrivKeyName, nil)
 	cdc.RegisterConcrete(secp256k1.PrivKey{},
-		secp256k1.PrivKeyAminoName, nil)
+		secp256k1.PrivKeyName, nil)
 }
 
 // RegisterKeyType registers an external key type to allow decoding it from bytes

crypto/encoding/amino/encode_test.go

@@ -135,9 +135,9 @@ func TestPubkeyAminoName(t *testing.T) {
 		want  string
 		found bool
 	}{
-		{ed25519.PubKey{}, ed25519.PubKeyAminoName, true},
-		{sr25519.PubKey{}, sr25519.PubKeyAminoName, true},
-		{secp256k1.PubKey{}, secp256k1.PubKeyAminoName, true},
+		{ed25519.PubKey{}, ed25519.PubKeyName, true},
+		{sr25519.PubKey{}, sr25519.PubKeyName, true},
+		{secp256k1.PubKey{}, secp256k1.PubKeyName, true},
 	}
 	for i, tc := range tests {
 		got, found := PubkeyAminoName(cdc, tc.key)
@@ -218,7 +218,7 @@ func TestRegisterKeyType(t *testing.T) {
 	cdc = amino.NewCodec()
 	nameTable = make(map[reflect.Type]string, 3)
 	RegisterAmino(cdc)
-	nameTable[reflect.TypeOf(ed25519.PubKey{})] = ed25519.PubKeyAminoName
-	nameTable[reflect.TypeOf(sr25519.PubKey{})] = sr25519.PubKeyAminoName
-	nameTable[reflect.TypeOf(secp256k1.PubKey{})] = secp256k1.PubKeyAminoName
+	nameTable[reflect.TypeOf(ed25519.PubKey{})] = ed25519.PubKeyName
+	nameTable[reflect.TypeOf(sr25519.PubKey{})] = sr25519.PubKeyName
+	nameTable[reflect.TypeOf(secp256k1.PubKey{})] = secp256k1.PubKeyName
 }

crypto/merkle/codec.go

@@ -1,12 +0,0 @@
-package merkle
-
-import (
-	amino "github.com/tendermint/go-amino"
-)
-
-var cdc *amino.Codec
-
-func init() {
-	cdc = amino.NewCodec()
-	cdc.Seal()
-}

crypto/merkle/compile.sh

@@ -1,6 +0,0 @@
-#! /bin/bash
-
-protoc --gogo_out=. -I $GOPATH/src/ -I . -I $GOPATH/src/github.com/gogo/protobuf/protobuf merkle.proto
-echo "--> adding nolint declarations to protobuf generated files"
-awk '/package merkle/ { print "//nolint: gas"; print; next }1' merkle.pb.go > merkle.pb.go.new
-mv merkle.pb.go.new merkle.pb.go

crypto/merkle/proof.go

@@ -134,6 +134,7 @@ func ProofFromProto(pb *tmmerkle.Proof) (*Proof, error) {
 	if pb == nil {
 		return nil, errors.New("nil proof")
 	}
+
 	sp := new(Proof)
 
 	sp.Total = pb.Total

crypto/merkle/proof_test.go

@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	amino "github.com/tendermint/go-amino"
+	"github.com/stretchr/testify/require"
 	tmmerkle "github.com/tendermint/tendermint/proto/crypto/merkle"
 )
 
@@ -28,21 +28,17 @@ func NewDominoOp(key, input, output string) DominoOp {
 	}
 }
 
-//nolint:unused
-func DominoOpDecoder(pop tmmerkle.ProofOp) (ProofOperator, error) {
-	if pop.Type != ProofOpDomino {
-		panic("unexpected proof op type")
+func (dop DominoOp) ProofOp() tmmerkle.ProofOp {
+	dopb := tmmerkle.DominoOp{
+		Key:    dop.key,
+		Input:  dop.Input,
+		Output: dop.Output,
 	}
-	var op DominoOp // a bit strange as we'll discard this, but it works.
-	err := amino.UnmarshalBinaryLengthPrefixed(pop.Data, &op)
+	bz, err := dopb.Marshal()
 	if err != nil {
-		return nil, fmt.Errorf("decoding ProofOp.Data into ValueOp: %w", err)
+		panic(err)
 	}
-	return NewDominoOp(string(pop.Key), op.Input, op.Output), nil
-}
 
-func (dop DominoOp) ProofOp() tmmerkle.ProofOp {
-	bz := amino.MustMarshalBinaryLengthPrefixed(dop)
 	return tmmerkle.ProofOp{
 		Type: ProofOpDomino,
 		Key:  []byte(dop.key),
@@ -72,8 +68,6 @@ func TestProofOperators(t *testing.T) {
 
 	// ProofRuntime setup
 	// TODO test this somehow.
-	// prt := NewProofRuntime()
-	// prt.RegisterOpDecoder(ProofOpDomino, DominoOpDecoder)
 
 	// ProofOperators setup
 	op1 := NewDominoOp("KEY1", "INPUT1", "INPUT2")
@@ -175,3 +169,31 @@ func TestProofValidateBasic(t *testing.T) {
 		})
 	}
 }
+func TestVoteProtobuf(t *testing.T) {
+
+	_, proofs := ProofsFromByteSlices([][]byte{
+		[]byte("apple"),
+		[]byte("watermelon"),
+		[]byte("kiwi"),
+	})
+	testCases := []struct {
+		testName string
+		v1       *Proof
+		expPass  bool
+	}{
+		{"empty proof", &Proof{}, false},
+		{"failure nil", nil, false},
+		{"success", proofs[0], true},
+	}
+	for _, tc := range testCases {
+		pb := tc.v1.ToProto()
+
+		v, err := ProofFromProto(pb)
+		if tc.expPass {
+			require.NoError(t, err)
+			require.Equal(t, tc.v1, v, tc.testName)
+		} else {
+			require.Error(t, err)
+		}
+	}
+}

crypto/merkle/proof_value.go

@@ -13,8 +13,8 @@ const ProofOpValue = "simple:v"
 // ValueOp takes a key and a single value as argument and
 // produces the root hash.  The corresponding tree structure is
 // the SimpleMap tree.  SimpleMap takes a Hasher, and currently
-// Tendermint uses aminoHasher.  ValueOp should support
-// the hash function as used in aminoHasher.  TODO support
+// Tendermint uses tmhash.  SimpleValueOp should support
+// the hash function as used in tmhash.  TODO support
 // additional hash functions here as options/args to this
 // operator.
 //
@@ -41,16 +41,28 @@ func ValueOpDecoder(pop tmmerkle.ProofOp) (ProofOperator, error) {
 	if pop.Type != ProofOpValue {
 		return nil, fmt.Errorf("unexpected ProofOp.Type; got %v, want %v", pop.Type, ProofOpValue)
 	}
-	var op ValueOp // a bit strange as we'll discard this, but it works.
-	err := cdc.UnmarshalBinaryLengthPrefixed(pop.Data, &op)
+	var pbop tmmerkle.ValueOp // a bit strange as we'll discard this, but it works.
+	err := pbop.Unmarshal(pop.Data)
 	if err != nil {
 		return nil, fmt.Errorf("decoding ProofOp.Data into ValueOp: %w", err)
 	}
-	return NewValueOp(pop.Key, op.Proof), nil
+
+	sp, err := ProofFromProto(pbop.Proof)
+	if err != nil {
+		return nil, err
+	}
+	return NewValueOp(pop.Key, sp), nil
 }
 
 func (op ValueOp) ProofOp() tmmerkle.ProofOp {
-	bz := cdc.MustMarshalBinaryLengthPrefixed(op)
+	pbval := tmmerkle.ValueOp{
+		Key:   op.key,
+		Proof: op.Proof.ToProto(),
+	}
+	bz, err := pbval.Marshal()
+	if err != nil {
+		panic(err)
+	}
 	return tmmerkle.ProofOp{
 		Type: ProofOpValue,
 		Key:  op.key,

crypto/merkle/types.go

@@ -1,9 +1,8 @@
 package merkle
 
 import (
+	"encoding/binary"
 	"io"
-
-	amino "github.com/tendermint/go-amino"
 )
 
 // Tree is a Merkle tree interface.
@@ -29,5 +28,12 @@ type Tree interface {
 
 // Uvarint length prefixed byteslice
 func encodeByteSlice(w io.Writer, bz []byte) (err error) {
-	return amino.EncodeByteSlice(w, bz)
+	var buf [binary.MaxVarintLen64]byte
+	n := binary.PutUvarint(buf[:], uint64(len(bz)))
+	_, err = w.Write(buf[0:n])
+	if err != nil {
+		return
+	}
+	_, err = w.Write(bz)
+	return
 }

crypto/secp256k1/encoding.go

@@ -1,28 +1,15 @@
 package secp256k1
 
 import (
-	amino "github.com/tendermint/go-amino"
-
-	"github.com/tendermint/tendermint/crypto"
 	tmjson "github.com/tendermint/tendermint/libs/json"
 )
 
 const (
-	PrivKeyAminoName = "tendermint/PrivKeySecp256k1"
-	PubKeyAminoName  = "tendermint/PubKeySecp256k1"
+	PrivKeyName = "tendermint/PrivKeySecp256k1"
+	PubKeyName  = "tendermint/PubKeySecp256k1"
 )
 
-var cdc = amino.NewCodec()
-
 func init() {
-	cdc.RegisterInterface((*crypto.PubKey)(nil), nil)
-	cdc.RegisterConcrete(PubKey{},
-		PubKeyAminoName, nil)
-
-	cdc.RegisterInterface((*crypto.PrivKey)(nil), nil)
-	cdc.RegisterConcrete(PrivKey{},
-		PrivKeyAminoName, nil)
-
-	tmjson.RegisterType(PubKey{}, PubKeyAminoName)
-	tmjson.RegisterType(PrivKey{}, PrivKeyAminoName)
+	tmjson.RegisterType(PubKey{}, PubKeyName)
+	tmjson.RegisterType(PrivKey{}, PrivKeyName)
 }

crypto/secp256k1/secp256k1.go

@@ -24,7 +24,7 @@ const (
 // PrivKey implements PrivKey.
 type PrivKey []byte
 
-// Bytes marshalls the private key using amino encoding.
+// Bytes returns the byte representation of the Private Key.
 func (privKey PrivKey) Bytes() []byte {
 	return []byte(privKey)
 }

crypto/sr25519/encoding.go

@@ -1,8 +1,6 @@
 package sr25519
 
 import (
-	"github.com/tendermint/go-amino"
-
 	"github.com/tendermint/tendermint/crypto"
 	tmjson "github.com/tendermint/tendermint/libs/json"
 )
@@ -10,25 +8,16 @@ import (
 var _ crypto.PrivKey = PrivKey{}
 
 const (
-	PrivKeyAminoName = "tendermint/PrivKeySr25519"
-	PubKeyAminoName  = "tendermint/PubKeySr25519"
+	PrivKeyName = "tendermint/PrivKeySr25519"
+	PubKeyName  = "tendermint/PubKeySr25519"
 
 	// SignatureSize is the size of an Edwards25519 signature. Namely the size of a compressed
 	// Sr25519 point, and a field element. Both of which are 32 bytes.
 	SignatureSize = 64
 )
 
-var cdc = amino.NewCodec()
-
 func init() {
-	cdc.RegisterInterface((*crypto.PubKey)(nil), nil)
-	cdc.RegisterConcrete(PubKey{},
-		PubKeyAminoName, nil)
-
-	cdc.RegisterInterface((*crypto.PrivKey)(nil), nil)
-	cdc.RegisterConcrete(PrivKey{},
-		PrivKeyAminoName, nil)
 
-	tmjson.RegisterType(PubKey{}, PubKeyAminoName)
-	tmjson.RegisterType(PrivKey{}, PrivKeyAminoName)
+	tmjson.RegisterType(PubKey{}, PubKeyName)
+	tmjson.RegisterType(PrivKey{}, PrivKeyName)
 }

crypto/sr25519/privkey.go

@@ -16,7 +16,7 @@ const PrivKeySize = 32
 // PrivKeySr25519 implements crypto.PrivKey.
 type PrivKey []byte
 
-// Bytes marshals the privkey using amino encoding.
+// Bytes returns the byte representation of the PrivKey.
 func (privKey PrivKey) Bytes() []byte {
 	return []byte(privKey)
 }

crypto/sr25519/pubkey.go

@@ -26,7 +26,7 @@ func (pubKey PubKey) Address() crypto.Address {
 	return crypto.Address(tmhash.SumTruncated(pubKey[:]))
 }
 
-// Bytes marshals the PubKey using amino encoding.
+// Bytes returns the byte representation of the PubKey.
 func (pubKey PubKey) Bytes() []byte {
 	return []byte(pubKey)
 }

node/node_test.go

@@ -251,7 +251,6 @@ func TestCreateProposalBlock(t *testing.T) {
 	mempool.SetLogger(logger)
 
 	// Make EvidencePool
-	types.RegisterMockEvidencesGlobal() // XXX!
 	evidenceDB := dbm.NewMemDB()
 	blockStore := store.NewBlockStore(dbm.NewMemDB())
 	evidencePool, err := evidence.NewPool(stateDB, evidenceDB, blockStore)

proto/crypto/merkle/types.pb.go

@@ -91,6 +91,120 @@ func (m *Proof) GetAunts() [][]byte {
 	return nil
 }
 
+type ValueOp struct {
+	// Encoded in ProofOp.Key.
+	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	// To encode in ProofOp.Data
+	Proof *Proof `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
+}
+
+func (m *ValueOp) Reset()         { *m = ValueOp{} }
+func (m *ValueOp) String() string { return proto.CompactTextString(m) }
+func (*ValueOp) ProtoMessage()    {}
+func (*ValueOp) Descriptor() ([]byte, []int) {
+	return fileDescriptor_57e39eefdaf7ae96, []int{1}
+}
+func (m *ValueOp) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ValueOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ValueOp.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *ValueOp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ValueOp.Merge(m, src)
+}
+func (m *ValueOp) XXX_Size() int {
+	return m.Size()
+}
+func (m *ValueOp) XXX_DiscardUnknown() {
+	xxx_messageInfo_ValueOp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ValueOp proto.InternalMessageInfo
+
+func (m *ValueOp) GetKey() []byte {
+	if m != nil {
+		return m.Key
+	}
+	return nil
+}
+
+func (m *ValueOp) GetProof() *Proof {
+	if m != nil {
+		return m.Proof
+	}
+	return nil
+}
+
+type DominoOp struct {
+	Key    string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	Input  string `protobuf:"bytes,2,opt,name=input,proto3" json:"input,omitempty"`
+	Output string `protobuf:"bytes,3,opt,name=output,proto3" json:"output,omitempty"`
+}
+
+func (m *DominoOp) Reset()         { *m = DominoOp{} }
+func (m *DominoOp) String() string { return proto.CompactTextString(m) }
+func (*DominoOp) ProtoMessage()    {}
+func (*DominoOp) Descriptor() ([]byte, []int) {
+	return fileDescriptor_57e39eefdaf7ae96, []int{2}
+}
+func (m *DominoOp) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *DominoOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_DominoOp.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *DominoOp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DominoOp.Merge(m, src)
+}
+func (m *DominoOp) XXX_Size() int {
+	return m.Size()
+}
+func (m *DominoOp) XXX_DiscardUnknown() {
+	xxx_messageInfo_DominoOp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DominoOp proto.InternalMessageInfo
+
+func (m *DominoOp) GetKey() string {
+	if m != nil {
+		return m.Key
+	}
+	return ""
+}
+
+func (m *DominoOp) GetInput() string {
+	if m != nil {
+		return m.Input
+	}
+	return ""
+}
+
+func (m *DominoOp) GetOutput() string {
+	if m != nil {
+		return m.Output
+	}
+	return ""
+}
+
 // ProofOp defines an operation used for calculating Merkle root
 // The data could be arbitrary format, providing nessecary data
 // for example neighbouring node hash
@@ -104,7 +218,7 @@ func (m *ProofOp) Reset()         { *m = ProofOp{} }
 func (m *ProofOp) String() string { return proto.CompactTextString(m) }
 func (*ProofOp) ProtoMessage()    {}
 func (*ProofOp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_57e39eefdaf7ae96, []int{1}
+	return fileDescriptor_57e39eefdaf7ae96, []int{3}
 }
 func (m *ProofOp) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -163,7 +277,7 @@ func (m *ProofOps) Reset()         { *m = ProofOps{} }
 func (m *ProofOps) String() string { return proto.CompactTextString(m) }
 func (*ProofOps) ProtoMessage()    {}
 func (*ProofOps) Descriptor() ([]byte, []int) {
-	return fileDescriptor_57e39eefdaf7ae96, []int{2}
+	return fileDescriptor_57e39eefdaf7ae96, []int{4}
 }
 func (m *ProofOps) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -201,6 +315,8 @@ func (m *ProofOps) GetOps() []ProofOp {
 
 func init() {
 	proto.RegisterType((*Proof)(nil), "tendermint.proto.crypto.merkle.Proof")
+	proto.RegisterType((*ValueOp)(nil), "tendermint.proto.crypto.merkle.ValueOp")
+	proto.RegisterType((*DominoOp)(nil), "tendermint.proto.crypto.merkle.DominoOp")
 	proto.RegisterType((*ProofOp)(nil), "tendermint.proto.crypto.merkle.ProofOp")
 	proto.RegisterType((*ProofOps)(nil), "tendermint.proto.crypto.merkle.ProofOps")
 }
@@ -208,26 +324,31 @@ func init() {
 func init() { proto.RegisterFile("proto/crypto/merkle/types.proto", fileDescriptor_57e39eefdaf7ae96) }
 
 var fileDescriptor_57e39eefdaf7ae96 = []byte{
-	// 303 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x51, 0x3f, 0x4b, 0x03, 0x31,
-	0x1c, 0xbd, 0x78, 0xad, 0xb6, 0xb1, 0x83, 0x04, 0x87, 0x43, 0x21, 0x3d, 0x3a, 0xe8, 0x4d, 0x39,
-	0x50, 0x77, 0xa1, 0x2e, 0x82, 0xa0, 0x92, 0xd1, 0xa5, 0xa4, 0xbd, 0xb4, 0x77, 0xb4, 0xbd, 0x84,
-	0xe4, 0x57, 0xf0, 0xbe, 0x85, 0x1f, 0xab, 0x63, 0x47, 0x27, 0x91, 0xf6, 0x8b, 0x48, 0x92, 0x42,
-	0x1d, 0xc4, 0xed, 0xbd, 0x97, 0xf7, 0x87, 0x24, 0xb8, 0xaf, 0x8d, 0x02, 0x95, 0x4f, 0x4c, 0xa3,
-	0x41, 0xe5, 0x4b, 0x69, 0xe6, 0x0b, 0x99, 0x43, 0xa3, 0xa5, 0x65, 0xfe, 0x84, 0x50, 0x90, 0x75,
-	0x21, 0xcd, 0xb2, 0xaa, 0x21, 0x28, 0x2c, 0x78, 0x59, 0xf0, 0x5e, 0x5c, 0x41, 0x59, 0x99, 0x62,
-	0xa4, 0x85, 0x81, 0x26, 0x0f, 0x65, 0x33, 0x35, 0x53, 0x07, 0x14, 0x52, 0x83, 0x29, 0x6e, 0xbf,
-	0x1a, 0xa5, 0xa6, 0xe4, 0x1c, 0xb7, 0x41, 0x81, 0x58, 0x24, 0x28, 0x45, 0x59, 0xcc, 0x03, 0x71,
-	0x6a, 0x55, 0x17, 0xf2, 0x3d, 0x39, 0x0a, 0xaa, 0x27, 0xe4, 0x12, 0x77, 0x17, 0x52, 0x4c, 0x47,
-	0xa5, 0xb0, 0x65, 0x12, 0xa7, 0x28, 0xeb, 0xf1, 0x8e, 0x13, 0x1e, 0x85, 0x2d, 0x5d, 0x44, 0xac,
-	0x6a, 0xb0, 0x49, 0x2b, 0x8d, 0xb3, 0x1e, 0x0f, 0x64, 0xf0, 0x80, 0x4f, 0xfc, 0xce, 0x8b, 0x26,
-	0x04, 0xb7, 0xdc, 0x4d, 0xfc, 0x50, 0x97, 0x7b, 0x4c, 0xce, 0x70, 0x3c, 0x97, 0x8d, 0x5f, 0xe9,
-	0x71, 0x07, 0x9d, 0xab, 0x10, 0x20, 0xf6, 0xf5, 0x1e, 0x0f, 0x9e, 0x70, 0x67, 0x5f, 0x62, 0xc9,
-	0x3d, 0x8e, 0x95, 0xb6, 0x09, 0x4a, 0xe3, 0xec, 0xf4, 0xe6, 0x9a, 0xfd, 0xff, 0x1c, 0x6c, 0x1f,
-	0x1b, 0xb6, 0xd6, 0x5f, 0xfd, 0x88, 0xbb, 0xe4, 0xf0, 0x79, 0xbd, 0xa5, 0x68, 0xb3, 0xa5, 0xe8,
-	0x7b, 0x4b, 0xd1, 0xc7, 0x8e, 0x46, 0x9b, 0x1d, 0x8d, 0x3e, 0x77, 0x34, 0x7a, 0xbb, 0x9b, 0x55,
-	0x50, 0xae, 0xc6, 0x6c, 0xa2, 0x96, 0xf9, 0xa1, 0xf7, 0x37, 0xfc, 0xe3, 0x77, 0xc6, 0xc7, 0x5e,
-	0xbc, 0xfd, 0x09, 0x00, 0x00, 0xff, 0xff, 0x3b, 0x62, 0x4b, 0x7e, 0xbb, 0x01, 0x00, 0x00,
+	// 372 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x4f, 0x4b, 0xc3, 0x30,
+	0x18, 0xc6, 0xdb, 0xb5, 0xfb, 0x97, 0xed, 0x20, 0x41, 0xa4, 0x28, 0x74, 0xa5, 0xa0, 0xf6, 0xd4,
+	0xc2, 0xf4, 0xe6, 0x41, 0x98, 0x1e, 0x44, 0xc1, 0x49, 0x0f, 0x22, 0x5e, 0x46, 0xb6, 0x66, 0x6b,
+	0x59, 0xdb, 0x84, 0x34, 0x05, 0xfb, 0x2d, 0xfc, 0x58, 0x3b, 0xee, 0xe8, 0x49, 0x64, 0xfb, 0x22,
+	0x92, 0xa4, 0x32, 0x05, 0x11, 0x6f, 0xcf, 0xf3, 0x34, 0xcf, 0x2f, 0xef, 0x1b, 0x0a, 0x06, 0x94,
+	0x11, 0x4e, 0x82, 0x19, 0xab, 0x28, 0x27, 0x41, 0x86, 0xd9, 0x32, 0xc5, 0x01, 0xaf, 0x28, 0x2e,
+	0x7c, 0xf9, 0x05, 0xda, 0x1c, 0xe7, 0x11, 0x66, 0x59, 0x92, 0x73, 0x95, 0xf8, 0xea, 0xac, 0xaf,
+	0xce, 0x1e, 0x9e, 0xf0, 0x38, 0x61, 0xd1, 0x84, 0x22, 0xc6, 0xab, 0x40, 0xc1, 0x16, 0x64, 0x41,
+	0x76, 0x4a, 0xb5, 0xdc, 0x39, 0x68, 0x3e, 0x30, 0x42, 0xe6, 0x70, 0x1f, 0x34, 0x39, 0xe1, 0x28,
+	0xb5, 0x74, 0x47, 0xf7, 0x8c, 0x50, 0x19, 0x91, 0x26, 0x79, 0x84, 0x5f, 0xac, 0x86, 0x4a, 0xa5,
+	0x81, 0x47, 0xa0, 0x9b, 0x62, 0x34, 0x9f, 0xc4, 0xa8, 0x88, 0x2d, 0xc3, 0xd1, 0xbd, 0x7e, 0xd8,
+	0x11, 0xc1, 0x0d, 0x2a, 0x62, 0x51, 0x41, 0x65, 0xce, 0x0b, 0xcb, 0x74, 0x0c, 0xaf, 0x1f, 0x2a,
+	0xe3, 0x3e, 0x81, 0xf6, 0x23, 0x4a, 0x4b, 0x3c, 0xa6, 0x70, 0x0f, 0x18, 0x4b, 0x5c, 0xc9, 0x7b,
+	0xfa, 0xa1, 0x90, 0xf0, 0x02, 0x34, 0xa9, 0x18, 0x42, 0xde, 0xd2, 0x1b, 0x1e, 0xfb, 0x7f, 0x2f,
+	0xe7, 0xcb, 0x89, 0x43, 0xd5, 0x71, 0x6f, 0x41, 0xe7, 0x9a, 0x64, 0x49, 0x4e, 0x7e, 0xa2, 0xbb,
+	0x0a, 0x2d, 0x17, 0xa0, 0x25, 0x97, 0xe8, 0x6e, 0xa8, 0x0c, 0x3c, 0x00, 0x2d, 0x52, 0x72, 0x11,
+	0x1b, 0x32, 0xae, 0x9d, 0x7b, 0x05, 0xda, 0x92, 0x3d, 0xa6, 0x10, 0x02, 0x53, 0xbc, 0x77, 0xcd,
+	0x92, 0xfa, 0x0b, 0xdf, 0xd8, 0x4d, 0x0e, 0x81, 0x19, 0x21, 0x8e, 0xea, 0x47, 0x90, 0xda, 0xbd,
+	0x03, 0x9d, 0x1a, 0x52, 0xc0, 0x4b, 0x60, 0x10, 0x5a, 0x58, 0xba, 0x63, 0x78, 0xbd, 0xe1, 0xe9,
+	0xbf, 0xf6, 0x1a, 0xd3, 0x91, 0xb9, 0x7a, 0x1f, 0x68, 0xa1, 0x68, 0x8e, 0xee, 0x57, 0x1b, 0x5b,
+	0x5f, 0x6f, 0x6c, 0xfd, 0x63, 0x63, 0xeb, 0xaf, 0x5b, 0x5b, 0x5b, 0x6f, 0x6d, 0xed, 0x6d, 0x6b,
+	0x6b, 0xcf, 0xe7, 0x8b, 0x84, 0xc7, 0xe5, 0xd4, 0x9f, 0x91, 0x2c, 0xd8, 0x71, 0xbf, 0xcb, 0x5f,
+	0xfe, 0xa1, 0x69, 0x4b, 0x86, 0x67, 0x9f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xee, 0x66, 0x38, 0xd7,
+	0x61, 0x02, 0x00, 0x00,
 }
 
 func (m *Proof) Marshal() (dAtA []byte, err error) {
@@ -279,6 +400,92 @@ func (m *Proof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *ValueOp) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ValueOp) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ValueOp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Proof != nil {
+		{
+			size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTypes(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Key) > 0 {
+		i -= len(m.Key)
+		copy(dAtA[i:], m.Key)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Key)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *DominoOp) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *DominoOp) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DominoOp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Output) > 0 {
+		i -= len(m.Output)
+		copy(dAtA[i:], m.Output)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Output)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.Input) > 0 {
+		i -= len(m.Input)
+		copy(dAtA[i:], m.Input)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Input)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Key) > 0 {
+		i -= len(m.Key)
+		copy(dAtA[i:], m.Key)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Key)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *ProofOp) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -396,6 +603,44 @@ func (m *Proof) Size() (n int) {
 	return n
 }
 
+func (m *ValueOp) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	if m.Proof != nil {
+		l = m.Proof.Size()
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	return n
+}
+
+func (m *DominoOp) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	l = len(m.Input)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	l = len(m.Output)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	return n
+}
+
 func (m *ProofOp) Size() (n int) {
 	if m == nil {
 		return 0
@@ -595,6 +840,278 @@ func (m *Proof) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *ValueOp) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ValueOp: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ValueOp: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
+			if m.Key == nil {
+				m.Key = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Proof == nil {
+				m.Proof = &Proof{}
+			}
+			if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DominoOp) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: DominoOp: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DominoOp: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Key = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Input", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Input = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Output = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *ProofOp) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0

proto/crypto/merkle/types.proto

@@ -12,6 +12,20 @@ message Proof {
   repeated bytes aunts     = 4;
 }
 
+message ValueOp {
+  // Encoded in ProofOp.Key.
+  bytes key = 1;
+
+  // To encode in ProofOp.Data
+  Proof proof = 2;
+}
+
+message DominoOp {
+  string key    = 1;
+  string input  = 2;
+  string output = 3;
+}
+
 // ProofOp defines an operation used for calculating Merkle root
 // The data could be arbitrary format, providing nessecary data
 // for example neighbouring node hash

proto/types/evidence.pb.go

@@ -435,6 +435,58 @@ func (m *LunaticValidatorEvidence) GetInvalidHeaderField() string {
 	return ""
 }
 
+type PhantomValidatorEvidence struct {
+	Vote                        *Vote `protobuf:"bytes,1,opt,name=vote,proto3" json:"vote,omitempty"`
+	LastHeightValidatorWasInSet int64 `protobuf:"varint,2,opt,name=last_height_validator_was_in_set,json=lastHeightValidatorWasInSet,proto3" json:"last_height_validator_was_in_set,omitempty"`
+}
+
+func (m *PhantomValidatorEvidence) Reset()         { *m = PhantomValidatorEvidence{} }
+func (m *PhantomValidatorEvidence) String() string { return proto.CompactTextString(m) }
+func (*PhantomValidatorEvidence) ProtoMessage()    {}
+func (*PhantomValidatorEvidence) Descriptor() ([]byte, []int) {
+	return fileDescriptor_86495eef24aeacc0, []int{7}
+}
+func (m *PhantomValidatorEvidence) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *PhantomValidatorEvidence) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_PhantomValidatorEvidence.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *PhantomValidatorEvidence) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PhantomValidatorEvidence.Merge(m, src)
+}
+func (m *PhantomValidatorEvidence) XXX_Size() int {
+	return m.Size()
+}
+func (m *PhantomValidatorEvidence) XXX_DiscardUnknown() {
+	xxx_messageInfo_PhantomValidatorEvidence.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PhantomValidatorEvidence proto.InternalMessageInfo
+
+func (m *PhantomValidatorEvidence) GetVote() *Vote {
+	if m != nil {
+		return m.Vote
+	}
+	return nil
+}
+
+func (m *PhantomValidatorEvidence) GetLastHeightValidatorWasInSet() int64 {
+	if m != nil {
+		return m.LastHeightValidatorWasInSet
+	}
+	return 0
+}
+
 type Evidence struct {
 	// Types that are valid to be assigned to Sum:
 	//	*Evidence_DuplicateVoteEvidence
@@ -442,6 +494,7 @@ type Evidence struct {
 	//	*Evidence_LunaticValidatorEvidence
 	//	*Evidence_PotentialAmnesiaEvidence
 	//	*Evidence_AmnesiaEvidence
+	//	*Evidence_PhantomValidatorEvidence
 	//	*Evidence_MockEvidence
 	//	*Evidence_MockRandomEvidence
 	Sum isEvidence_Sum `protobuf_oneof:"sum"`
@@ -451,7 +504,7 @@ func (m *Evidence) Reset()         { *m = Evidence{} }
 func (m *Evidence) String() string { return proto.CompactTextString(m) }
 func (*Evidence) ProtoMessage()    {}
 func (*Evidence) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86495eef24aeacc0, []int{7}
+	return fileDescriptor_86495eef24aeacc0, []int{8}
 }
 func (m *Evidence) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -501,11 +554,14 @@ type Evidence_PotentialAmnesiaEvidence struct {
 type Evidence_AmnesiaEvidence struct {
 	AmnesiaEvidence *AmnesiaEvidence `protobuf:"bytes,5,opt,name=amnesia_evidence,json=amnesiaEvidence,proto3,oneof" json:"amnesia_evidence,omitempty"`
 }
+type Evidence_PhantomValidatorEvidence struct {
+	PhantomValidatorEvidence *PhantomValidatorEvidence `protobuf:"bytes,6,opt,name=phantom_validator_evidence,json=phantomValidatorEvidence,proto3,oneof" json:"phantom_validator_evidence,omitempty"`
+}
 type Evidence_MockEvidence struct {
-	MockEvidence *MockEvidence `protobuf:"bytes,6,opt,name=mock_evidence,json=mockEvidence,proto3,oneof" json:"mock_evidence,omitempty"`
+	MockEvidence *MockEvidence `protobuf:"bytes,7,opt,name=mock_evidence,json=mockEvidence,proto3,oneof" json:"mock_evidence,omitempty"`
 }
 type Evidence_MockRandomEvidence struct {
-	MockRandomEvidence *MockRandomEvidence `protobuf:"bytes,7,opt,name=mock_random_evidence,json=mockRandomEvidence,proto3,oneof" json:"mock_random_evidence,omitempty"`
+	MockRandomEvidence *MockRandomEvidence `protobuf:"bytes,8,opt,name=mock_random_evidence,json=mockRandomEvidence,proto3,oneof" json:"mock_random_evidence,omitempty"`
 }
 
 func (*Evidence_DuplicateVoteEvidence) isEvidence_Sum()      {}
@@ -513,6 +569,7 @@ func (*Evidence_ConflictingHeadersEvidence) isEvidence_Sum() {}
 func (*Evidence_LunaticValidatorEvidence) isEvidence_Sum()   {}
 func (*Evidence_PotentialAmnesiaEvidence) isEvidence_Sum()   {}
 func (*Evidence_AmnesiaEvidence) isEvidence_Sum()            {}
+func (*Evidence_PhantomValidatorEvidence) isEvidence_Sum()   {}
 func (*Evidence_MockEvidence) isEvidence_Sum()               {}
 func (*Evidence_MockRandomEvidence) isEvidence_Sum()         {}
 
@@ -558,6 +615,13 @@ func (m *Evidence) GetAmnesiaEvidence() *AmnesiaEvidence {
 	return nil
 }
 
+func (m *Evidence) GetPhantomValidatorEvidence() *PhantomValidatorEvidence {
+	if x, ok := m.GetSum().(*Evidence_PhantomValidatorEvidence); ok {
+		return x.PhantomValidatorEvidence
+	}
+	return nil
+}
+
 func (m *Evidence) GetMockEvidence() *MockEvidence {
 	if x, ok := m.GetSum().(*Evidence_MockEvidence); ok {
 		return x.MockEvidence
@@ -580,6 +644,7 @@ func (*Evidence) XXX_OneofWrappers() []interface{} {
 		(*Evidence_LunaticValidatorEvidence)(nil),
 		(*Evidence_PotentialAmnesiaEvidence)(nil),
 		(*Evidence_AmnesiaEvidence)(nil),
+		(*Evidence_PhantomValidatorEvidence)(nil),
 		(*Evidence_MockEvidence)(nil),
 		(*Evidence_MockRandomEvidence)(nil),
 	}
@@ -595,7 +660,7 @@ func (m *EvidenceData) Reset()         { *m = EvidenceData{} }
 func (m *EvidenceData) String() string { return proto.CompactTextString(m) }
 func (*EvidenceData) ProtoMessage()    {}
 func (*EvidenceData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86495eef24aeacc0, []int{8}
+	return fileDescriptor_86495eef24aeacc0, []int{9}
 }
 func (m *EvidenceData) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -647,7 +712,7 @@ func (m *ProofOfLockChange) Reset()         { *m = ProofOfLockChange{} }
 func (m *ProofOfLockChange) String() string { return proto.CompactTextString(m) }
 func (*ProofOfLockChange) ProtoMessage()    {}
 func (*ProofOfLockChange) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86495eef24aeacc0, []int{9}
+	return fileDescriptor_86495eef24aeacc0, []int{10}
 }
 func (m *ProofOfLockChange) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -698,6 +763,7 @@ func init() {
 	proto.RegisterType((*MockRandomEvidence)(nil), "tendermint.proto.types.MockRandomEvidence")
 	proto.RegisterType((*ConflictingHeadersEvidence)(nil), "tendermint.proto.types.ConflictingHeadersEvidence")
 	proto.RegisterType((*LunaticValidatorEvidence)(nil), "tendermint.proto.types.LunaticValidatorEvidence")
+	proto.RegisterType((*PhantomValidatorEvidence)(nil), "tendermint.proto.types.PhantomValidatorEvidence")
 	proto.RegisterType((*Evidence)(nil), "tendermint.proto.types.Evidence")
 	proto.RegisterType((*EvidenceData)(nil), "tendermint.proto.types.EvidenceData")
 	proto.RegisterType((*ProofOfLockChange)(nil), "tendermint.proto.types.ProofOfLockChange")
@@ -706,61 +772,66 @@ func init() {
 func init() { proto.RegisterFile("proto/types/evidence.proto", fileDescriptor_86495eef24aeacc0) }
 
 var fileDescriptor_86495eef24aeacc0 = []byte{
-	// 858 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0xcf, 0x6f, 0xdc, 0x44,
-	0x14, 0xb6, 0xb3, 0x9b, 0x6d, 0xfa, 0xb2, 0x25, 0x65, 0xd4, 0x52, 0xcb, 0x6a, 0x37, 0xc1, 0x42,
-	0x34, 0x45, 0xe0, 0x4d, 0xb7, 0x88, 0x1b, 0x12, 0xd9, 0x96, 0x6a, 0x51, 0x8a, 0xa8, 0xa6, 0x55,
-	0x0f, 0x1c, 0xb0, 0xc6, 0xf6, 0xac, 0x3d, 0x5a, 0xdb, 0x63, 0xd9, 0xe3, 0x95, 0x7c, 0xe4, 0x06,
-	0xb7, 0xfe, 0x17, 0x9c, 0xb8, 0x72, 0xe6, 0xd8, 0x63, 0xc5, 0x09, 0x2e, 0x80, 0x92, 0x7f, 0x04,
-	0x79, 0xc6, 0xf6, 0x6e, 0x7e, 0x38, 0x8a, 0x38, 0x20, 0x71, 0x59, 0x79, 0xdf, 0xbc, 0xef, 0x7b,
-	0xdf, 0x9b, 0xf7, 0xc3, 0x06, 0x33, 0xcd, 0xb8, 0xe0, 0x63, 0x51, 0xa6, 0x34, 0x1f, 0xd3, 0x25,
-	0xf3, 0x69, 0xe2, 0x51, 0x5b, 0x1a, 0xd1, 0x7b, 0x82, 0x26, 0x3e, 0xcd, 0x62, 0x96, 0x08, 0x65,
-	0xb1, 0xa5, 0x9b, 0xf9, 0xa1, 0x08, 0x59, 0xe6, 0x3b, 0x29, 0xc9, 0x44, 0x39, 0x56, 0xf8, 0x80,
-	0x07, 0x7c, 0xf5, 0xa4, 0xbc, 0xcd, 0x3b, 0xeb, 0xdc, 0xf2, 0xb7, 0x3e, 0xd8, 0x0d, 0x38, 0x0f,
-	0x22, 0xaa, 0xb0, 0x6e, 0x31, 0x1f, 0x0b, 0x16, 0xd3, 0x5c, 0x90, 0x38, 0xad, 0x1d, 0xee, 0x29,
-	0xa4, 0x97, 0x95, 0xa9, 0xe0, 0xe3, 0x05, 0x2d, 0x4f, 0xe1, 0xad, 0xef, 0x75, 0xb8, 0xfd, 0xa4,
-	0x48, 0x23, 0xe6, 0x11, 0x41, 0x5f, 0x71, 0x41, 0xbf, 0xac, 0x85, 0xa3, 0x47, 0x30, 0x58, 0x72,
-	0x41, 0x1d, 0x62, 0xe8, 0x7b, 0xfa, 0xfe, 0xf6, 0xe4, 0xae, 0x7d, 0x71, 0x0e, 0x76, 0x85, 0xc2,
-	0x9b, 0x95, 0xef, 0x61, 0x0b, 0x72, 0x8d, 0x8d, 0xab, 0x82, 0xa6, 0xd6, 0x4f, 0x3a, 0x18, 0xcf,
-	0xb9, 0xa0, 0x89, 0x60, 0x24, 0x3a, 0x8c, 0x13, 0x9a, 0x33, 0xf2, 0xdf, 0xcb, 0x40, 0xef, 0xc3,
-	0x30, 0xa4, 0x2c, 0x08, 0x85, 0x23, 0xef, 0xcf, 0xe8, 0xed, 0xe9, 0xfb, 0x3d, 0xbc, 0xad, 0x6c,
-	0x2f, 0x2a, 0x93, 0xf5, 0xab, 0x0e, 0x3b, 0x67, 0x05, 0x26, 0x60, 0xa6, 0x8d, 0x78, 0x87, 0xa8,
-	0x43, 0xa7, 0x29, 0x7f, 0x2d, 0xfa, 0xa0, 0x2b, 0x7e, 0x57, 0xda, 0xd8, 0x48, 0xbb, 0x2e, 0xe4,
-	0x73, 0xe8, 0xa7, 0x3c, 0xf2, 0xea, 0xcc, 0x1e, 0x74, 0x32, 0x67, 0x9c, 0xcf, 0xbf, 0x99, 0x3f,
-	0xe3, 0xde, 0xe2, 0x71, 0x48, 0x92, 0x80, 0x62, 0x09, 0xb3, 0x7e, 0xd6, 0x61, 0xf8, 0x35, 0xf7,
-	0x16, 0x2d, 0xdf, 0x7d, 0xd8, 0x69, 0xd4, 0x3a, 0x2a, 0x57, 0x29, 0xba, 0x87, 0xdf, 0x69, 0xcc,
-	0x33, 0x69, 0x45, 0x5f, 0xc1, 0x8d, 0xd6, 0xb1, 0xea, 0xb2, 0x5a, 0x81, 0x69, 0xab, 0x16, 0xb4,
-	0x9b, 0x16, 0xb4, 0x5f, 0x36, 0x2d, 0x38, 0xdd, 0x7a, 0xf3, 0xe7, 0xae, 0xf6, 0xfa, 0xaf, 0x5d,
-	0x1d, 0x0f, 0x1b, 0x68, 0x75, 0x88, 0x1e, 0xc0, 0xcd, 0x96, 0x8a, 0xf8, 0x7e, 0x46, 0xf3, 0x5c,
-	0x5e, 0xf7, 0x10, 0xb7, 0x5a, 0x0e, 0x95, 0xd9, 0xfa, 0x4d, 0x07, 0x54, 0xe9, 0xc5, 0x24, 0xf1,
-	0x79, 0xfc, 0x3f, 0x51, 0x8d, 0xee, 0x01, 0x64, 0x24, 0xf1, 0x1d, 0xb7, 0x14, 0x34, 0x37, 0xfa,
-	0xd2, 0xe9, 0x7a, 0x65, 0x99, 0x56, 0x06, 0xeb, 0x07, 0x1d, 0xcc, 0xc7, 0x3c, 0x99, 0x47, 0xcc,
-	0x13, 0x2c, 0x09, 0x66, 0x94, 0xf8, 0x34, 0xcb, 0xdb, 0xe4, 0x3e, 0x85, 0x8d, 0xf0, 0x61, 0xdd,
-	0x3a, 0x1f, 0x74, 0x15, 0xf8, 0x05, 0x0b, 0x12, 0xea, 0x2b, 0x28, 0xde, 0x08, 0x1f, 0x4a, 0xd4,
-	0xa4, 0x4e, 0xef, 0xaa, 0xa8, 0x89, 0xf5, 0x8b, 0x0e, 0xc6, 0xb3, 0x22, 0x21, 0x82, 0x79, 0xaf,
-	0x48, 0xc4, 0x7c, 0x22, 0x78, 0xd6, 0x0a, 0xf9, 0x0c, 0x06, 0xa1, 0x74, 0xad, 0xc5, 0x8c, 0xba,
-	0x68, 0x6b, 0xc2, 0xda, 0x1b, 0x1d, 0x40, 0xbf, 0x9a, 0xa9, 0x2b, 0x4d, 0x9f, 0xf4, 0x44, 0x07,
-	0x70, 0x8b, 0x25, 0xcb, 0x4a, 0x80, 0xa3, 0x38, 0x9c, 0x39, 0xa3, 0x91, 0x2f, 0xef, 0xf7, 0x3a,
-	0x46, 0xf5, 0x99, 0x0a, 0xf3, 0xb4, 0x3a, 0xb1, 0xfe, 0xd8, 0x84, 0xad, 0x56, 0x68, 0x00, 0x77,
-	0xfc, 0x66, 0x8b, 0x39, 0x72, 0xf4, 0xcf, 0x4c, 0xe0, 0x27, 0x5d, 0x1a, 0x2e, 0x5c, 0x7e, 0x33,
-	0x0d, 0xdf, 0xf6, 0x2f, 0xdc, 0x8a, 0x4b, 0xb8, 0xeb, 0xad, 0x0a, 0x57, 0x6b, 0xcd, 0x57, 0xd1,
-	0x54, 0xc6, 0x93, 0xae, 0x68, 0xdd, 0x45, 0x9f, 0x69, 0xd8, 0xf4, 0xba, 0x5b, 0x22, 0x05, 0x33,
-	0x52, 0x55, 0x72, 0x96, 0x4d, 0x99, 0x56, 0x51, 0x7b, 0x97, 0x6f, 0x99, 0xae, 0xfa, 0xce, 0x34,
-	0x6c, 0x44, 0x5d, 0xb5, 0x4f, 0x2f, 0xdd, 0x6b, 0xfd, 0x7f, 0xb7, 0xd7, 0xaa, 0x88, 0x9d, 0x9b,
-	0xed, 0x25, 0xdc, 0x3c, 0x17, 0x67, 0x53, 0xc6, 0xb9, 0xdf, 0x15, 0xe7, 0x3c, 0xfd, 0x0e, 0x39,
-	0xc3, 0x7a, 0x04, 0x37, 0x62, 0xee, 0x2d, 0x56, 0x94, 0x83, 0xcb, 0x27, 0x64, 0x7d, 0x39, 0xce,
-	0x34, 0x3c, 0x8c, 0xd7, 0x97, 0xe5, 0x77, 0x70, 0x4b, 0x92, 0x65, 0x72, 0x1b, 0xad, 0x38, 0xaf,
-	0x49, 0xce, 0x8f, 0x2e, 0xe3, 0x3c, 0xbd, 0xc0, 0x66, 0x1a, 0x46, 0xf1, 0x39, 0xeb, 0x74, 0x13,
-	0x7a, 0x79, 0x11, 0x5b, 0x73, 0x18, 0x36, 0xa6, 0x27, 0x44, 0x10, 0x34, 0x85, 0xad, 0xb5, 0x7e,
-	0xee, 0xed, 0x6f, 0x4f, 0xf6, 0xba, 0x42, 0xb5, 0x54, 0xfd, 0x6a, 0x8b, 0xe1, 0x16, 0x87, 0x10,
-	0xf4, 0x43, 0x92, 0x87, 0xb2, 0x43, 0x87, 0x58, 0x3e, 0x5b, 0x3f, 0xea, 0xf0, 0xee, 0xb9, 0x17,
-	0x05, 0x9a, 0x80, 0x7c, 0x23, 0xe6, 0x75, 0xa8, 0x2b, 0xbc, 0x3c, 0x73, 0xf4, 0x05, 0x5c, 0x4b,
-	0x0b, 0xd7, 0x59, 0xd0, 0xb2, 0x1e, 0x81, 0x0b, 0x4a, 0xa6, 0xbe, 0x41, 0xec, 0xea, 0x1b, 0xc4,
-	0x7e, 0x5e, 0xb8, 0x11, 0xf3, 0x8e, 0x68, 0x89, 0x07, 0x69, 0xe1, 0x1e, 0xd1, 0x72, 0xfa, 0xf4,
-	0xcd, 0xf1, 0x48, 0x7f, 0x7b, 0x3c, 0xd2, 0xff, 0x3e, 0x1e, 0xe9, 0xaf, 0x4f, 0x46, 0xda, 0xdb,
-	0x93, 0x91, 0xf6, 0xfb, 0xc9, 0x48, 0xfb, 0xf6, 0xe3, 0x80, 0x89, 0xb0, 0x70, 0x6d, 0x8f, 0xc7,
-	0xe3, 0x15, 0xe9, 0xfa, 0xe3, 0xda, 0xd7, 0x91, 0x3b, 0x90, 0x7f, 0x1e, 0xfd, 0x13, 0x00, 0x00,
-	0xff, 0xff, 0xa6, 0x62, 0x87, 0x20, 0x8f, 0x09, 0x00, 0x00,
+	// 930 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0xcf, 0x8f, 0xdb, 0x44,
+	0x14, 0xb6, 0x37, 0xd9, 0x74, 0xfb, 0x36, 0x65, 0x8b, 0xd5, 0xd2, 0x28, 0xb4, 0xd9, 0xc5, 0x42,
+	0x74, 0x8b, 0xc0, 0xd9, 0xa6, 0x88, 0x1b, 0x12, 0x9b, 0xfe, 0x50, 0xaa, 0x2d, 0xa2, 0x9a, 0xad,
+	0x8a, 0xc4, 0x01, 0x6b, 0x62, 0x4f, 0xec, 0x51, 0x6c, 0x8f, 0x65, 0x4f, 0x82, 0x72, 0xe4, 0x06,
+	0xb7, 0x4a, 0xfc, 0x11, 0x9c, 0xb8, 0x72, 0xe6, 0x58, 0x89, 0x4b, 0xc5, 0x89, 0x13, 0xa0, 0xdd,
+	0x7f, 0x04, 0xcd, 0x8c, 0xed, 0xa4, 0x9b, 0x4c, 0x88, 0x38, 0x20, 0xf5, 0x12, 0x39, 0x6f, 0xde,
+	0xfb, 0xde, 0xf7, 0xc6, 0xdf, 0x7c, 0x1e, 0x68, 0xa7, 0x19, 0xe3, 0xac, 0xcb, 0x67, 0x29, 0xc9,
+	0xbb, 0x64, 0x4a, 0x7d, 0x92, 0x78, 0xc4, 0x91, 0x41, 0xeb, 0x1d, 0x4e, 0x12, 0x9f, 0x64, 0x31,
+	0x4d, 0xb8, 0x8a, 0x38, 0x32, 0xad, 0xfd, 0x01, 0x0f, 0x69, 0xe6, 0xbb, 0x29, 0xce, 0xf8, 0xac,
+	0xab, 0xea, 0x03, 0x16, 0xb0, 0xf9, 0x93, 0xca, 0x6e, 0xdf, 0x58, 0xc4, 0x96, 0xbf, 0xc5, 0xc2,
+	0x7e, 0xc0, 0x58, 0x10, 0x11, 0x55, 0x3b, 0x9c, 0x8c, 0xba, 0x9c, 0xc6, 0x24, 0xe7, 0x38, 0x4e,
+	0x8b, 0x84, 0x5b, 0xaa, 0xd2, 0xcb, 0x66, 0x29, 0x67, 0xdd, 0x31, 0x99, 0xbd, 0x56, 0x6f, 0x7f,
+	0x67, 0xc2, 0xf5, 0x07, 0x93, 0x34, 0xa2, 0x1e, 0xe6, 0xe4, 0x39, 0xe3, 0xe4, 0x61, 0x41, 0xdc,
+	0xba, 0x07, 0x8d, 0x29, 0xe3, 0xc4, 0xc5, 0x2d, 0xf3, 0xc0, 0x3c, 0xdc, 0xed, 0xdd, 0x74, 0x56,
+	0xcf, 0xe0, 0x88, 0x2a, 0xb4, 0x2d, 0x72, 0x8f, 0xab, 0xa2, 0x61, 0x6b, 0x6b, 0xd3, 0xa2, 0xbe,
+	0xfd, 0x93, 0x09, 0xad, 0xa7, 0x8c, 0x93, 0x84, 0x53, 0x1c, 0x1d, 0xc7, 0x09, 0xc9, 0x29, 0xfe,
+	0xff, 0x69, 0x58, 0xef, 0x41, 0x33, 0x24, 0x34, 0x08, 0xb9, 0x2b, 0xf7, 0xaf, 0x55, 0x3b, 0x30,
+	0x0f, 0x6b, 0x68, 0x57, 0xc5, 0x4e, 0x45, 0xc8, 0xfe, 0xd5, 0x84, 0xbd, 0x8b, 0x04, 0x13, 0x68,
+	0xa7, 0x25, 0x79, 0x17, 0xab, 0x45, 0xb7, 0x7c, 0xfd, 0x05, 0xe9, 0x23, 0x5d, 0x7f, 0xdd, 0xd8,
+	0xa8, 0x95, 0xea, 0x36, 0xe4, 0x33, 0xa8, 0xa7, 0x2c, 0xf2, 0x8a, 0xc9, 0xee, 0x68, 0x91, 0x33,
+	0xc6, 0x46, 0x5f, 0x8e, 0x9e, 0x30, 0x6f, 0x7c, 0x3f, 0xc4, 0x49, 0x40, 0x90, 0x2c, 0xb3, 0x7f,
+	0x36, 0xa1, 0xf9, 0x05, 0xf3, 0xc6, 0x15, 0xde, 0x6d, 0xd8, 0x2b, 0xd9, 0xba, 0x6a, 0x56, 0x49,
+	0xba, 0x86, 0xde, 0x2a, 0xc3, 0x03, 0x19, 0xb5, 0x1e, 0xc3, 0x95, 0x2a, 0x51, 0xa8, 0xac, 0x60,
+	0xd0, 0x76, 0x94, 0x04, 0x9d, 0x52, 0x82, 0xce, 0xb3, 0x52, 0x82, 0xfd, 0x9d, 0x97, 0x7f, 0xee,
+	0x1b, 0x2f, 0xfe, 0xda, 0x37, 0x51, 0xb3, 0x2c, 0x15, 0x8b, 0xd6, 0x1d, 0xb8, 0x5a, 0x41, 0x61,
+	0xdf, 0xcf, 0x48, 0x9e, 0xcb, 0xed, 0x6e, 0xa2, 0x8a, 0xcb, 0xb1, 0x0a, 0xdb, 0xbf, 0x9b, 0x60,
+	0x09, 0xbe, 0x08, 0x27, 0x3e, 0x8b, 0xdf, 0x10, 0xd6, 0xd6, 0x2d, 0x80, 0x0c, 0x27, 0xbe, 0x3b,
+	0x9c, 0x71, 0x92, 0xb7, 0xea, 0x32, 0xe9, 0xb2, 0x88, 0xf4, 0x45, 0xc0, 0xfe, 0xde, 0x84, 0xf6,
+	0x7d, 0x96, 0x8c, 0x22, 0xea, 0x71, 0x9a, 0x04, 0x03, 0x82, 0x7d, 0x92, 0xe5, 0xd5, 0x70, 0x9f,
+	0xc0, 0x56, 0x78, 0xb7, 0x90, 0xce, 0xfb, 0xba, 0x17, 0x7c, 0x4a, 0x83, 0x84, 0xf8, 0xaa, 0x14,
+	0x6d, 0x85, 0x77, 0x65, 0x55, 0xaf, 0x18, 0x6f, 0xd3, 0xaa, 0x9e, 0xfd, 0x8b, 0x09, 0xad, 0x27,
+	0x93, 0x04, 0x73, 0xea, 0x3d, 0xc7, 0x11, 0xf5, 0x31, 0x67, 0x59, 0x45, 0xe4, 0x53, 0x68, 0x84,
+	0x32, 0xb5, 0x20, 0xd3, 0xd1, 0xc1, 0x16, 0x80, 0x45, 0xb6, 0x75, 0x04, 0x75, 0x71, 0xa6, 0x36,
+	0x3a, 0x7d, 0x32, 0xd3, 0x3a, 0x82, 0x6b, 0x34, 0x99, 0x0a, 0x02, 0xae, 0xc2, 0x70, 0x47, 0x94,
+	0x44, 0xbe, 0xdc, 0xdf, 0xcb, 0xc8, 0x2a, 0xd6, 0x54, 0x9b, 0x47, 0x62, 0xc5, 0xfe, 0x51, 0xb8,
+	0x46, 0x88, 0x13, 0xce, 0xe2, 0x65, 0xe2, 0x25, 0x01, 0x73, 0x63, 0x02, 0x0f, 0xe1, 0x20, 0xc2,
+	0x39, 0x2f, 0xc4, 0xe4, 0x4e, 0x4b, 0x48, 0xf7, 0x5b, 0x9c, 0xbb, 0x34, 0x71, 0x73, 0xc2, 0xe5,
+	0x38, 0x35, 0xf4, 0xae, 0xc8, 0x53, 0xea, 0xaa, 0x1a, 0x7f, 0x85, 0xf3, 0xc7, 0xc9, 0x29, 0xe1,
+	0xf6, 0x6f, 0x0d, 0xd8, 0xa9, 0x58, 0x04, 0x70, 0xc3, 0x2f, 0xbd, 0xd5, 0x95, 0x86, 0x74, 0xc1,
+	0x17, 0x3e, 0xd6, 0x11, 0x5b, 0x69, 0xc9, 0x03, 0x03, 0x5d, 0xf7, 0x57, 0x7a, 0xf5, 0x14, 0x6e,
+	0x7a, 0x73, 0x39, 0x15, 0x3b, 0x98, 0xcf, 0xbb, 0xa9, 0xf7, 0xd0, 0xd3, 0x75, 0xd3, 0x4b, 0x71,
+	0x60, 0xa0, 0xb6, 0xa7, 0x17, 0x6a, 0x0a, 0xed, 0x48, 0x69, 0x67, 0x61, 0xc3, 0xaa, 0xae, 0xb5,
+	0xf5, 0xde, 0xa7, 0x53, 0xdd, 0xc0, 0x40, 0xad, 0x48, 0xa7, 0xc8, 0x74, 0xad, 0xdb, 0xd6, 0xff,
+	0x9b, 0xdb, 0x8a, 0x8e, 0x5a, 0xbf, 0x7d, 0x06, 0x57, 0x97, 0xfa, 0x6c, 0xcb, 0x3e, 0xb7, 0x75,
+	0x7d, 0x96, 0xe1, 0xf7, 0xf0, 0x05, 0x54, 0x31, 0x87, 0x12, 0xef, 0xaa, 0x9d, 0x6b, 0xfc, 0xcb,
+	0x1c, 0x1a, 0xd9, 0xcb, 0x39, 0x74, 0x47, 0xe2, 0x04, 0xae, 0xc4, 0xcc, 0x1b, 0xcf, 0x9b, 0x5c,
+	0x5a, 0xef, 0x14, 0x8b, 0x1f, 0x89, 0x81, 0x81, 0x9a, 0xf1, 0xe2, 0x47, 0xe3, 0x1b, 0xb8, 0x26,
+	0xc1, 0x32, 0xe9, 0xca, 0x73, 0xcc, 0x1d, 0x89, 0xf9, 0xe1, 0x3a, 0xcc, 0xd7, 0x8d, 0x7c, 0x60,
+	0x20, 0x2b, 0x5e, 0x8a, 0xf6, 0xb7, 0xa1, 0x96, 0x4f, 0x62, 0x7b, 0x04, 0xcd, 0x32, 0xf4, 0x00,
+	0x73, 0x6c, 0xf5, 0x61, 0x67, 0xe1, 0x04, 0xd5, 0x0e, 0x77, 0x7b, 0x07, 0xba, 0x56, 0x15, 0x54,
+	0x5d, 0xb8, 0x39, 0xaa, 0xea, 0x2c, 0x0b, 0xea, 0x21, 0xce, 0x43, 0x79, 0x26, 0x9a, 0x48, 0x3e,
+	0xdb, 0x3f, 0x98, 0xf0, 0xf6, 0xd2, 0x07, 0xd3, 0xea, 0x81, 0xbc, 0x19, 0xe4, 0x45, 0xab, 0x0d,
+	0x2e, 0x11, 0xb9, 0xf5, 0x39, 0x5c, 0x4a, 0x27, 0x43, 0x77, 0x4c, 0x66, 0xc5, 0xa1, 0x5b, 0x21,
+	0x12, 0x75, 0x17, 0x73, 0xc4, 0x5d, 0xcc, 0x79, 0x3a, 0x19, 0x46, 0xd4, 0x3b, 0x21, 0x33, 0xd4,
+	0x48, 0x27, 0xc3, 0x13, 0x32, 0xeb, 0x3f, 0x7a, 0x79, 0xd6, 0x31, 0x5f, 0x9d, 0x75, 0xcc, 0xbf,
+	0xcf, 0x3a, 0xe6, 0x8b, 0xf3, 0x8e, 0xf1, 0xea, 0xbc, 0x63, 0xfc, 0x71, 0xde, 0x31, 0xbe, 0xfe,
+	0x28, 0xa0, 0x3c, 0x9c, 0x0c, 0x1d, 0x8f, 0xc5, 0xdd, 0x39, 0xe8, 0xe2, 0xe3, 0xc2, 0x2d, 0x71,
+	0xd8, 0x90, 0x7f, 0xee, 0xfd, 0x13, 0x00, 0x00, 0xff, 0xff, 0x7c, 0xcb, 0x14, 0xa7, 0x97, 0x0a,
+	0x00, 0x00,
 }
 
 func (m *DuplicateVoteEvidence) Marshal() (dAtA []byte, err error) {
@@ -1103,6 +1174,46 @@ func (m *LunaticValidatorEvidence) MarshalToSizedBuffer(dAtA []byte) (int, error
 	return len(dAtA) - i, nil
 }
 
+func (m *PhantomValidatorEvidence) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *PhantomValidatorEvidence) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PhantomValidatorEvidence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.LastHeightValidatorWasInSet != 0 {
+		i = encodeVarintEvidence(dAtA, i, uint64(m.LastHeightValidatorWasInSet))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.Vote != nil {
+		{
+			size, err := m.Vote.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintEvidence(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *Evidence) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -1240,6 +1351,27 @@ func (m *Evidence_AmnesiaEvidence) MarshalToSizedBuffer(dAtA []byte) (int, error
 	}
 	return len(dAtA) - i, nil
 }
+func (m *Evidence_PhantomValidatorEvidence) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Evidence_PhantomValidatorEvidence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.PhantomValidatorEvidence != nil {
+		{
+			size, err := m.PhantomValidatorEvidence.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintEvidence(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x32
+	}
+	return len(dAtA) - i, nil
+}
 func (m *Evidence_MockEvidence) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
@@ -1257,7 +1389,7 @@ func (m *Evidence_MockEvidence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintEvidence(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x32
+		dAtA[i] = 0x3a
 	}
 	return len(dAtA) - i, nil
 }
@@ -1278,7 +1410,7 @@ func (m *Evidence_MockRandomEvidence) MarshalToSizedBuffer(dAtA []byte) (int, er
 			i = encodeVarintEvidence(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x3a
+		dAtA[i] = 0x42
 	}
 	return len(dAtA) - i, nil
 }
@@ -1518,6 +1650,22 @@ func (m *LunaticValidatorEvidence) Size() (n int) {
 	return n
 }
 
+func (m *PhantomValidatorEvidence) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Vote != nil {
+		l = m.Vote.Size()
+		n += 1 + l + sovEvidence(uint64(l))
+	}
+	if m.LastHeightValidatorWasInSet != 0 {
+		n += 1 + sovEvidence(uint64(m.LastHeightValidatorWasInSet))
+	}
+	return n
+}
+
 func (m *Evidence) Size() (n int) {
 	if m == nil {
 		return 0
@@ -1590,6 +1738,18 @@ func (m *Evidence_AmnesiaEvidence) Size() (n int) {
 	}
 	return n
 }
+func (m *Evidence_PhantomValidatorEvidence) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.PhantomValidatorEvidence != nil {
+		l = m.PhantomValidatorEvidence.Size()
+		n += 1 + l + sovEvidence(uint64(l))
+	}
+	return n
+}
 func (m *Evidence_MockEvidence) Size() (n int) {
 	if m == nil {
 		return 0
@@ -2646,6 +2806,114 @@ func (m *LunaticValidatorEvidence) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *PhantomValidatorEvidence) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowEvidence
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: PhantomValidatorEvidence: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: PhantomValidatorEvidence: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Vote", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEvidence
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthEvidence
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthEvidence
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Vote == nil {
+				m.Vote = &Vote{}
+			}
+			if err := m.Vote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LastHeightValidatorWasInSet", wireType)
+			}
+			m.LastHeightValidatorWasInSet = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEvidence
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.LastHeightValidatorWasInSet |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipEvidence(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthEvidence
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthEvidence
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *Evidence) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -2851,6 +3119,41 @@ func (m *Evidence) Unmarshal(dAtA []byte) error {
 			m.Sum = &Evidence_AmnesiaEvidence{v}
 			iNdEx = postIndex
 		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PhantomValidatorEvidence", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEvidence
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthEvidence
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthEvidence
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &PhantomValidatorEvidence{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Sum = &Evidence_PhantomValidatorEvidence{v}
+			iNdEx = postIndex
+		case 7:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field MockEvidence", wireType)
 			}
@@ -2885,7 +3188,7 @@ func (m *Evidence) Unmarshal(dAtA []byte) error {
 			}
 			m.Sum = &Evidence_MockEvidence{v}
 			iNdEx = postIndex
-		case 7:
+		case 8:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field MockRandomEvidence", wireType)
 			}

proto/types/evidence.proto

@@ -53,6 +53,11 @@ message LunaticValidatorEvidence {
   string invalid_header_field = 3;
 }
 
+message PhantomValidatorEvidence {
+  Vote  vote                             = 1;
+  int64 last_height_validator_was_in_set = 2;
+}
+
 message Evidence {
   oneof sum {
     DuplicateVoteEvidence      duplicate_vote_evidence      = 1;
@@ -60,9 +65,10 @@ message Evidence {
     LunaticValidatorEvidence   lunatic_validator_evidence   = 3;
     PotentialAmnesiaEvidence   potential_amnesia_evidence   = 4;
     AmnesiaEvidence            amnesia_evidence             = 5;
+    PhantomValidatorEvidence   phantom_validator_evidence   = 6;
 
-    MockEvidence       mock_evidence        = 6;
-    MockRandomEvidence mock_random_evidence = 7;
+    MockEvidence       mock_evidence        = 7;
+    MockRandomEvidence mock_random_evidence = 8;
   }
 }
 

proto/types/types.pb.go

@@ -939,6 +939,67 @@ func (m *BlockMeta) GetNumTxs() int64 {
 	return 0
 }
 
+// TxProof represents a Merkle proof of the presence of a transaction in the Merkle tree.
+type TxProof struct {
+	RootHash []byte        `protobuf:"bytes,1,opt,name=root_hash,json=rootHash,proto3" json:"root_hash,omitempty"`
+	Data     []byte        `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+	Proof    *merkle.Proof `protobuf:"bytes,3,opt,name=Proof,proto3" json:"Proof,omitempty"`
+}
+
+func (m *TxProof) Reset()         { *m = TxProof{} }
+func (m *TxProof) String() string { return proto.CompactTextString(m) }
+func (*TxProof) ProtoMessage()    {}
+func (*TxProof) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ff06f8095857fb18, []int{11}
+}
+func (m *TxProof) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *TxProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_TxProof.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *TxProof) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TxProof.Merge(m, src)
+}
+func (m *TxProof) XXX_Size() int {
+	return m.Size()
+}
+func (m *TxProof) XXX_DiscardUnknown() {
+	xxx_messageInfo_TxProof.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TxProof proto.InternalMessageInfo
+
+func (m *TxProof) GetRootHash() []byte {
+	if m != nil {
+		return m.RootHash
+	}
+	return nil
+}
+
+func (m *TxProof) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func (m *TxProof) GetProof() *merkle.Proof {
+	if m != nil {
+		return m.Proof
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterEnum("tendermint.proto.types.BlockIDFlag", BlockIDFlag_name, BlockIDFlag_value)
 	proto.RegisterEnum("tendermint.proto.types.SignedMsgType", SignedMsgType_name, SignedMsgType_value)
@@ -953,92 +1014,96 @@ func init() {
 	proto.RegisterType((*Proposal)(nil), "tendermint.proto.types.Proposal")
 	proto.RegisterType((*SignedHeader)(nil), "tendermint.proto.types.SignedHeader")
 	proto.RegisterType((*BlockMeta)(nil), "tendermint.proto.types.BlockMeta")
+	proto.RegisterType((*TxProof)(nil), "tendermint.proto.types.TxProof")
 }
 
 func init() { proto.RegisterFile("proto/types/types.proto", fileDescriptor_ff06f8095857fb18) }
 
 var fileDescriptor_ff06f8095857fb18 = []byte{
-	// 1274 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0x4d, 0x6f, 0x1a, 0x47,
-	0x18, 0xf6, 0xc2, 0x62, 0xe0, 0x05, 0x6c, 0xbc, 0x72, 0x13, 0x8a, 0x5b, 0x4c, 0x70, 0x93, 0x3a,
-	0x69, 0x04, 0x95, 0x2b, 0x55, 0x8d, 0xd4, 0x0b, 0x5f, 0x71, 0x50, 0x6c, 0x40, 0x0b, 0x4d, 0xd5,
-	0x5e, 0x56, 0x03, 0x3b, 0x59, 0x56, 0x59, 0x76, 0x57, 0xbb, 0x83, 0x65, 0x72, 0xe8, 0xb9, 0xf2,
-	0x29, 0x7f, 0xc0, 0xa7, 0xb4, 0x52, 0xff, 0x45, 0x7b, 0xcc, 0xa9, 0xca, 0xb1, 0xa7, 0xb4, 0xb2,
-	0xff, 0x41, 0xd5, 0x1f, 0x50, 0xcd, 0xc7, 0x2e, 0x10, 0x4c, 0x1b, 0x35, 0x51, 0x2f, 0xf6, 0xce,
-	0xfb, 0x3e, 0xcf, 0x3b, 0xf3, 0x3e, 0xf3, 0xcc, 0x8c, 0x80, 0xeb, 0xae, 0xe7, 0x10, 0xa7, 0x42,
-	0xa6, 0x2e, 0xf6, 0xf9, 0xdf, 0x32, 0x8b, 0x28, 0xd7, 0x08, 0xb6, 0x75, 0xec, 0x8d, 0x4d, 0x9b,
-	0xf0, 0x48, 0x99, 0x65, 0xf3, 0xb7, 0xc8, 0xc8, 0xf4, 0x74, 0xcd, 0x45, 0x1e, 0x99, 0x56, 0x38,
-	0xd9, 0x70, 0x0c, 0x67, 0xf6, 0xc5, 0xd1, 0xf9, 0x5d, 0xc3, 0x71, 0x0c, 0x0b, 0x73, 0xc8, 0x60,
-	0xf2, 0xb8, 0x42, 0xcc, 0x31, 0xf6, 0x09, 0x1a, 0xbb, 0x02, 0xb0, 0xc3, 0x29, 0x96, 0x39, 0xf0,
-	0x2b, 0x03, 0x93, 0x2c, 0xcc, 0x9e, 0xdf, 0xe5, 0xc9, 0xa1, 0x37, 0x75, 0x89, 0x53, 0x19, 0x63,
-	0xef, 0x89, 0x85, 0x17, 0x00, 0x82, 0x7d, 0x82, 0x3d, 0xdf, 0x74, 0xec, 0xe0, 0x3f, 0x4f, 0x96,
-	0xee, 0x41, 0xa6, 0x8b, 0x3c, 0xd2, 0xc3, 0xe4, 0x01, 0x46, 0x3a, 0xf6, 0x94, 0x6d, 0x88, 0x11,
-	0x87, 0x20, 0x2b, 0x27, 0x15, 0xa5, 0xfd, 0x8c, 0xca, 0x07, 0x8a, 0x02, 0xf2, 0x08, 0xf9, 0xa3,
-	0x5c, 0xa4, 0x28, 0xed, 0xa7, 0x55, 0xf6, 0x5d, 0x9a, 0x80, 0x4c, 0xa9, 0x94, 0x61, 0xda, 0x3a,
-	0x3e, 0x0d, 0x18, 0x6c, 0x40, 0xa3, 0x83, 0x29, 0xc1, 0xbe, 0xa0, 0xf0, 0x81, 0x52, 0x85, 0x98,
-	0xeb, 0x39, 0xce, 0xe3, 0x5c, 0xb4, 0x28, 0xed, 0xa7, 0x0e, 0x6e, 0x96, 0x97, 0xa4, 0xe3, 0x7d,
-	0x94, 0x79, 0x1f, 0xe5, 0x2e, 0x05, 0xd7, 0xe4, 0x17, 0xaf, 0x76, 0xd7, 0x54, 0xce, 0x2c, 0x8d,
-	0x21, 0x5e, 0xb3, 0x9c, 0xe1, 0x93, 0x56, 0x23, 0x5c, 0x95, 0x34, 0x5b, 0x95, 0xd2, 0x86, 0x34,
-	0x15, 0xdc, 0xd7, 0x46, 0xac, 0x1f, 0x36, 0xfd, 0x95, 0x13, 0x71, 0x89, 0x16, 0x9a, 0x17, 0x13,
-	0xa5, 0x58, 0x01, 0x1e, 0x2a, 0xfd, 0x29, 0xc3, 0xba, 0x90, 0xa6, 0x0e, 0x71, 0x21, 0x1e, 0x9b,
-	0x31, 0x75, 0xb0, 0xb7, 0x5c, 0x35, 0x50, 0xb7, 0xee, 0xd8, 0x3e, 0xb6, 0xfd, 0x89, 0x2f, 0x6a,
-	0x06, 0x4c, 0xe5, 0x16, 0x24, 0x86, 0x23, 0x64, 0xda, 0x9a, 0xa9, 0xb3, 0xb5, 0x25, 0x6b, 0xa9,
-	0x8b, 0x57, 0xbb, 0xf1, 0x3a, 0x8d, 0xb5, 0x1a, 0x6a, 0x9c, 0x25, 0x5b, 0xba, 0x72, 0x0d, 0xd6,
-	0x47, 0xd8, 0x34, 0x46, 0x84, 0x49, 0x15, 0x55, 0xc5, 0x48, 0xf9, 0x02, 0x64, 0x6a, 0x8f, 0x9c,
-	0xcc, 0x56, 0x90, 0x2f, 0x73, 0xef, 0x94, 0x03, 0xef, 0x94, 0xfb, 0x81, 0x77, 0x6a, 0x09, 0x3a,
-	0xf1, 0xb3, 0xdf, 0x77, 0x25, 0x95, 0x31, 0x94, 0x16, 0x64, 0x2c, 0xe4, 0x13, 0x6d, 0x40, 0xd5,
-	0xa3, 0xd3, 0xc7, 0x58, 0x89, 0xdd, 0x55, 0xd2, 0x08, 0x95, 0x03, 0x51, 0x28, 0x97, 0x87, 0x74,
-	0x65, 0x1f, 0xb2, 0xac, 0xd4, 0xd0, 0x19, 0x8f, 0x4d, 0xa2, 0xb1, 0x4d, 0x58, 0x67, 0x9b, 0xb0,
-	0x41, 0xe3, 0x75, 0x16, 0x7e, 0x40, 0xb7, 0x63, 0x07, 0x92, 0x3a, 0x22, 0x88, 0x43, 0xe2, 0x0c,
-	0x92, 0xa0, 0x01, 0x96, 0xfc, 0x18, 0x36, 0x4f, 0x90, 0x65, 0xea, 0x88, 0x38, 0x9e, 0xcf, 0x21,
-	0x09, 0x5e, 0x65, 0x16, 0x66, 0xc0, 0x4f, 0x61, 0xdb, 0xc6, 0xa7, 0x44, 0x7b, 0x1d, 0x9d, 0x64,
-	0x68, 0x85, 0xe6, 0x1e, 0x2d, 0x32, 0x6e, 0xc2, 0xc6, 0x30, 0xd8, 0x02, 0x8e, 0x05, 0x86, 0xcd,
-	0x84, 0x51, 0x06, 0x7b, 0x1f, 0x12, 0xc8, 0x75, 0x39, 0x20, 0xc5, 0x00, 0x71, 0xe4, 0xba, 0x2c,
-	0x75, 0x07, 0xb6, 0x58, 0x8f, 0x1e, 0xf6, 0x27, 0x16, 0x11, 0x45, 0xd2, 0x0c, 0xb3, 0x49, 0x13,
-	0x2a, 0x8f, 0x33, 0xec, 0x1e, 0x64, 0xf0, 0x89, 0xa9, 0x63, 0x7b, 0x88, 0x39, 0x2e, 0xc3, 0x70,
-	0xe9, 0x20, 0xc8, 0x40, 0xb7, 0x21, 0xeb, 0x7a, 0x8e, 0xeb, 0xf8, 0xd8, 0xd3, 0x90, 0xae, 0x7b,
-	0xd8, 0xf7, 0x73, 0x1b, 0xbc, 0x5e, 0x10, 0xaf, 0xf2, 0x70, 0xe9, 0x2e, 0xc8, 0x0d, 0x44, 0x90,
-	0x92, 0x85, 0x28, 0x39, 0xf5, 0x73, 0x52, 0x31, 0xba, 0x9f, 0x56, 0xe9, 0xe7, 0x95, 0x07, 0xf1,
-	0xaf, 0x08, 0xc8, 0x8f, 0x1c, 0x82, 0x95, 0x7b, 0x20, 0xd3, 0xad, 0x63, 0xee, 0xdc, 0x58, 0xed,
-	0xf9, 0x9e, 0x69, 0xd8, 0x58, 0x3f, 0xf6, 0x8d, 0xfe, 0xd4, 0xc5, 0x2a, 0xa3, 0xcc, 0xd9, 0x2d,
-	0xb2, 0x60, 0xb7, 0x6d, 0x88, 0x79, 0xce, 0xc4, 0xd6, 0x99, 0x0b, 0x63, 0x2a, 0x1f, 0x28, 0x0f,
-	0x21, 0x11, 0xba, 0x48, 0x7e, 0x33, 0x17, 0x6d, 0x52, 0x17, 0x51, 0xa7, 0x8b, 0x80, 0x1a, 0x1f,
-	0x08, 0x33, 0xd5, 0x20, 0x19, 0x5e, 0x78, 0xc2, 0x93, 0x6f, 0x66, 0xeb, 0x19, 0x4d, 0xf9, 0x04,
-	0xb6, 0x42, 0x6f, 0x84, 0xe2, 0x72, 0x47, 0x66, 0xc3, 0x84, 0x50, 0x77, 0xc1, 0x76, 0x1a, 0xbf,
-	0xba, 0xe2, 0xac, 0xbb, 0x99, 0xed, 0x5a, 0xec, 0x0e, 0xfb, 0x00, 0x92, 0xbe, 0x69, 0xd8, 0x88,
-	0x4c, 0x3c, 0x2c, 0x9c, 0x39, 0x0b, 0x94, 0x9e, 0x47, 0x60, 0x9d, 0x3b, 0x7d, 0x4e, 0x3d, 0xe9,
-	0x6a, 0xf5, 0x22, 0xab, 0xd4, 0x8b, 0xbe, 0xad, 0x7a, 0x87, 0x00, 0xe1, 0x92, 0xfc, 0x9c, 0x5c,
-	0x8c, 0xee, 0xa7, 0x0e, 0x6e, 0xac, 0x2a, 0xc7, 0x97, 0xdb, 0x33, 0x0d, 0x71, 0xa8, 0xe7, 0xa8,
-	0xa1, 0xb3, 0x62, 0x73, 0x97, 0x69, 0x15, 0x92, 0x03, 0x93, 0x68, 0xc8, 0xf3, 0xd0, 0x94, 0xc9,
-	0x99, 0x3a, 0xf8, 0x68, 0xb9, 0x36, 0x7d, 0x97, 0xca, 0xf4, 0x5d, 0x2a, 0xd7, 0x4c, 0x52, 0xa5,
-	0x58, 0x35, 0x31, 0x10, 0x5f, 0xa5, 0x4b, 0x09, 0x92, 0xe1, 0xb4, 0xca, 0x21, 0x64, 0x82, 0xd6,
-	0xb5, 0xc7, 0x16, 0x32, 0x84, 0x55, 0xf7, 0xfe, 0xa5, 0xff, 0xfb, 0x16, 0x32, 0xd4, 0x94, 0x68,
-	0x99, 0x0e, 0xae, 0xde, 0xf0, 0xc8, 0x8a, 0x0d, 0x5f, 0x70, 0x58, 0xf4, 0xbf, 0x39, 0x6c, 0xc1,
-	0x0b, 0xf2, 0xeb, 0x5e, 0xf8, 0x39, 0x02, 0x89, 0x2e, 0x3b, 0xc4, 0xc8, 0xfa, 0xff, 0x8e, 0xe1,
-	0x0e, 0x24, 0x5d, 0xc7, 0xd2, 0x78, 0x46, 0x66, 0x99, 0x84, 0xeb, 0x58, 0xea, 0x92, 0xcb, 0x62,
-	0xef, 0xf4, 0x8c, 0xae, 0xbf, 0x03, 0x05, 0xe3, 0xaf, 0x2b, 0xf8, 0x1d, 0xa4, 0xb9, 0x20, 0xe2,
-	0xb1, 0xfd, 0x9c, 0x2a, 0xc1, 0x5e, 0x70, 0xfe, 0xd6, 0x16, 0x56, 0x2d, 0x9e, 0xe3, 0x55, 0x81,
-	0xa6, 0x3c, 0xfe, 0x2a, 0x89, 0x97, 0xbf, 0xf0, 0xcf, 0x67, 0x41, 0x15, 0xe8, 0xd2, 0xaf, 0x12,
-	0x24, 0x59, 0xdb, 0xc7, 0x98, 0xa0, 0x05, 0xf1, 0xa4, 0xb7, 0x15, 0xef, 0x43, 0x00, 0x5e, 0xcc,
-	0x37, 0x9f, 0x62, 0xb1, 0xb1, 0x49, 0x16, 0xe9, 0x99, 0x4f, 0xb1, 0xf2, 0x65, 0xd8, 0x69, 0xf4,
-	0x4d, 0x3a, 0x15, 0x47, 0x37, 0xe8, 0xf7, 0x3a, 0xc4, 0xed, 0xc9, 0x58, 0xa3, 0xcf, 0x84, 0xcc,
-	0x2d, 0x63, 0x4f, 0xc6, 0xfd, 0x53, 0xff, 0xce, 0x2f, 0x12, 0xa4, 0xe6, 0x8e, 0x8f, 0x92, 0x87,
-	0x6b, 0xb5, 0xa3, 0x4e, 0xfd, 0x61, 0x43, 0x6b, 0x35, 0xb4, 0xfb, 0x47, 0xd5, 0x43, 0xed, 0xab,
-	0xf6, 0xc3, 0x76, 0xe7, 0xeb, 0x76, 0x76, 0x4d, 0xa9, 0xc0, 0x36, 0xcb, 0x85, 0xa9, 0x6a, 0xad,
-	0xd7, 0x6c, 0xf7, 0xb3, 0x52, 0xfe, 0xbd, 0xb3, 0xf3, 0xe2, 0xd6, 0x5c, 0x99, 0xea, 0xc0, 0xc7,
-	0x36, 0x59, 0x26, 0xd4, 0x3b, 0xc7, 0xc7, 0xad, 0x7e, 0x36, 0xb2, 0x44, 0x10, 0x37, 0xe4, 0x6d,
-	0xd8, 0x5a, 0x24, 0xb4, 0x5b, 0x47, 0xd9, 0x68, 0x5e, 0x39, 0x3b, 0x2f, 0x6e, 0xcc, 0xa1, 0xdb,
-	0xa6, 0x95, 0x4f, 0x7c, 0xff, 0xbc, 0xb0, 0xf6, 0xd3, 0x0f, 0x05, 0xe9, 0xce, 0x8f, 0x12, 0x64,
-	0x16, 0x4e, 0x89, 0xb2, 0x03, 0xd7, 0x7b, 0xad, 0xc3, 0x76, 0xb3, 0xa1, 0x1d, 0xf7, 0x0e, 0xb5,
-	0xfe, 0x37, 0xdd, 0xe6, 0x5c, 0x17, 0x37, 0x20, 0xdd, 0x55, 0x9b, 0x8f, 0x3a, 0xfd, 0x26, 0xcb,
-	0x64, 0xa5, 0xfc, 0xe6, 0xd9, 0x79, 0x31, 0xd5, 0xf5, 0xf0, 0x89, 0x43, 0x30, 0xe3, 0xdf, 0x84,
-	0x8d, 0xae, 0xda, 0xe4, 0x8b, 0xe5, 0xa0, 0x48, 0x7e, 0xeb, 0xec, 0xbc, 0x98, 0xe9, 0x7a, 0x98,
-	0x1b, 0x81, 0xc1, 0xf6, 0x20, 0xd3, 0x55, 0x3b, 0xdd, 0x4e, 0xaf, 0x7a, 0xc4, 0x51, 0xd1, 0x7c,
-	0xf6, 0xec, 0xbc, 0x98, 0x0e, 0x8e, 0x38, 0x05, 0xcd, 0xd6, 0x59, 0xbb, 0xff, 0xe2, 0xa2, 0x20,
-	0xbd, 0xbc, 0x28, 0x48, 0x7f, 0x5c, 0x14, 0xa4, 0x67, 0x97, 0x85, 0xb5, 0x97, 0x97, 0x85, 0xb5,
-	0xdf, 0x2e, 0x0b, 0x6b, 0xdf, 0xde, 0x35, 0x4c, 0x32, 0x9a, 0x0c, 0xca, 0x43, 0x67, 0x5c, 0x99,
-	0xed, 0xea, 0xfc, 0xe7, 0xdc, 0x8f, 0x8a, 0xc1, 0x3a, 0x1b, 0x7c, 0xf6, 0x77, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0x94, 0x73, 0x22, 0x3b, 0x6a, 0x0c, 0x00, 0x00,
+	// 1317 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0x41, 0x6f, 0x1b, 0xc5,
+	0x17, 0xcf, 0xda, 0xeb, 0xd8, 0x7e, 0xb6, 0x13, 0x67, 0x95, 0x7f, 0xeb, 0xbf, 0x03, 0x8e, 0xeb,
+	0xd0, 0x92, 0x96, 0xca, 0x46, 0x41, 0x42, 0x54, 0x70, 0xb1, 0x93, 0x34, 0xb5, 0x9a, 0x38, 0xd6,
+	0xda, 0x14, 0xc1, 0x65, 0xb5, 0xf6, 0x4e, 0xed, 0x55, 0xd7, 0x3b, 0xab, 0xdd, 0x71, 0x48, 0x7a,
+	0xe0, 0x8c, 0x72, 0xea, 0x17, 0xc8, 0xa9, 0x20, 0xf1, 0x2d, 0xe0, 0xd8, 0x13, 0xea, 0x91, 0x53,
+	0x41, 0xc9, 0x37, 0x40, 0x7c, 0x00, 0x34, 0x6f, 0x66, 0xd7, 0x76, 0x93, 0x40, 0xa0, 0x15, 0x97,
+	0x64, 0xe6, 0xbd, 0xdf, 0x7b, 0x33, 0xef, 0x37, 0xbf, 0x99, 0xb7, 0x86, 0xeb, 0x9e, 0x4f, 0x19,
+	0xad, 0xb1, 0x23, 0x8f, 0x04, 0xe2, 0x6f, 0x15, 0x2d, 0xda, 0x35, 0x46, 0x5c, 0x8b, 0xf8, 0x23,
+	0xdb, 0x65, 0xc2, 0x52, 0x45, 0x6f, 0xf1, 0x16, 0x1b, 0xda, 0xbe, 0x65, 0x78, 0xa6, 0xcf, 0x8e,
+	0x6a, 0x22, 0x78, 0x40, 0x07, 0x74, 0x32, 0x12, 0xe8, 0xe2, 0xea, 0x80, 0xd2, 0x81, 0x43, 0x04,
+	0xa4, 0x37, 0x7e, 0x5c, 0x63, 0xf6, 0x88, 0x04, 0xcc, 0x1c, 0x79, 0x12, 0xb0, 0x22, 0x42, 0x1c,
+	0xbb, 0x17, 0xd4, 0x7a, 0x36, 0x9b, 0x59, 0xbd, 0xb8, 0x2a, 0x9c, 0x7d, 0xff, 0xc8, 0x63, 0xb4,
+	0x36, 0x22, 0xfe, 0x13, 0x87, 0xcc, 0x00, 0x64, 0xf4, 0x01, 0xf1, 0x03, 0x9b, 0xba, 0xe1, 0x7f,
+	0xe1, 0xac, 0xdc, 0x83, 0x5c, 0xdb, 0xf4, 0x59, 0x87, 0xb0, 0x07, 0xc4, 0xb4, 0x88, 0xaf, 0x2d,
+	0x43, 0x82, 0x51, 0x66, 0x3a, 0x05, 0xa5, 0xac, 0xac, 0xe7, 0x74, 0x31, 0xd1, 0x34, 0x50, 0x87,
+	0x66, 0x30, 0x2c, 0xc4, 0xca, 0xca, 0x7a, 0x56, 0xc7, 0x71, 0x65, 0x0c, 0x2a, 0x0f, 0xe5, 0x11,
+	0xb6, 0x6b, 0x91, 0xc3, 0x30, 0x02, 0x27, 0xdc, 0xda, 0x3b, 0x62, 0x24, 0x90, 0x21, 0x62, 0xa2,
+	0xd5, 0x21, 0xe1, 0xf9, 0x94, 0x3e, 0x2e, 0xc4, 0xcb, 0xca, 0x7a, 0x66, 0xe3, 0x66, 0xf5, 0x1c,
+	0x75, 0xa2, 0x8e, 0xaa, 0xa8, 0xa3, 0xda, 0xe6, 0xe0, 0x86, 0xfa, 0xe2, 0xd5, 0xea, 0x9c, 0x2e,
+	0x22, 0x2b, 0x23, 0x48, 0x36, 0x1c, 0xda, 0x7f, 0xd2, 0xdc, 0x8a, 0x76, 0xa5, 0x4c, 0x76, 0xa5,
+	0xb5, 0x20, 0xcb, 0x09, 0x0f, 0x8c, 0x21, 0xd6, 0x83, 0xcb, 0x5f, 0xb8, 0x90, 0xa0, 0x68, 0xa6,
+	0x78, 0xb9, 0x50, 0x06, 0x13, 0x08, 0x53, 0xe5, 0x77, 0x15, 0xe6, 0x25, 0x35, 0x9b, 0x90, 0x94,
+	0xe4, 0xe1, 0x8a, 0x99, 0x8d, 0xb5, 0xf3, 0x59, 0x43, 0x76, 0x37, 0xa9, 0x1b, 0x10, 0x37, 0x18,
+	0x07, 0x32, 0x67, 0x18, 0xa9, 0xdd, 0x82, 0x54, 0x7f, 0x68, 0xda, 0xae, 0x61, 0x5b, 0xb8, 0xb7,
+	0x74, 0x23, 0x73, 0xfa, 0x6a, 0x35, 0xb9, 0xc9, 0x6d, 0xcd, 0x2d, 0x3d, 0x89, 0xce, 0xa6, 0xa5,
+	0x5d, 0x83, 0xf9, 0x21, 0xb1, 0x07, 0x43, 0x86, 0x54, 0xc5, 0x75, 0x39, 0xd3, 0x3e, 0x01, 0x95,
+	0xcb, 0xa3, 0xa0, 0xe2, 0x0e, 0x8a, 0x55, 0xa1, 0x9d, 0x6a, 0xa8, 0x9d, 0x6a, 0x37, 0xd4, 0x4e,
+	0x23, 0xc5, 0x17, 0x7e, 0xf6, 0xeb, 0xaa, 0xa2, 0x63, 0x84, 0xd6, 0x84, 0x9c, 0x63, 0x06, 0xcc,
+	0xe8, 0x71, 0xf6, 0xf8, 0xf2, 0x09, 0x4c, 0xb1, 0x7a, 0x19, 0x35, 0x92, 0xe5, 0x90, 0x14, 0x1e,
+	0x2b, 0x4c, 0x96, 0xb6, 0x0e, 0x79, 0x4c, 0xd5, 0xa7, 0xa3, 0x91, 0xcd, 0x0c, 0x3c, 0x84, 0x79,
+	0x3c, 0x84, 0x05, 0x6e, 0xdf, 0x44, 0xf3, 0x03, 0x7e, 0x1c, 0x2b, 0x90, 0xb6, 0x4c, 0x66, 0x0a,
+	0x48, 0x12, 0x21, 0x29, 0x6e, 0x40, 0xe7, 0xfb, 0xb0, 0x78, 0x60, 0x3a, 0xb6, 0x65, 0x32, 0xea,
+	0x07, 0x02, 0x92, 0x12, 0x59, 0x26, 0x66, 0x04, 0x7e, 0x08, 0xcb, 0x2e, 0x39, 0x64, 0xc6, 0xeb,
+	0xe8, 0x34, 0xa2, 0x35, 0xee, 0x7b, 0x34, 0x1b, 0x71, 0x13, 0x16, 0xfa, 0xe1, 0x11, 0x08, 0x2c,
+	0x20, 0x36, 0x17, 0x59, 0x11, 0xf6, 0x7f, 0x48, 0x99, 0x9e, 0x27, 0x00, 0x19, 0x04, 0x24, 0x4d,
+	0xcf, 0x43, 0xd7, 0x1d, 0x58, 0xc2, 0x1a, 0x7d, 0x12, 0x8c, 0x1d, 0x26, 0x93, 0x64, 0x11, 0xb3,
+	0xc8, 0x1d, 0xba, 0xb0, 0x23, 0x76, 0x0d, 0x72, 0xe4, 0xc0, 0xb6, 0x88, 0xdb, 0x27, 0x02, 0x97,
+	0x43, 0x5c, 0x36, 0x34, 0x22, 0xe8, 0x36, 0xe4, 0x3d, 0x9f, 0x7a, 0x34, 0x20, 0xbe, 0x61, 0x5a,
+	0x96, 0x4f, 0x82, 0xa0, 0xb0, 0x20, 0xf2, 0x85, 0xf6, 0xba, 0x30, 0x57, 0xee, 0x82, 0xba, 0x65,
+	0x32, 0x53, 0xcb, 0x43, 0x9c, 0x1d, 0x06, 0x05, 0xa5, 0x1c, 0x5f, 0xcf, 0xea, 0x7c, 0x78, 0xe1,
+	0x45, 0xfc, 0x23, 0x06, 0xea, 0x23, 0xca, 0x88, 0x76, 0x0f, 0x54, 0x7e, 0x74, 0xa8, 0xce, 0x85,
+	0xcb, 0x35, 0xdf, 0xb1, 0x07, 0x2e, 0xb1, 0xf6, 0x82, 0x41, 0xf7, 0xc8, 0x23, 0x3a, 0x86, 0x4c,
+	0xc9, 0x2d, 0x36, 0x23, 0xb7, 0x65, 0x48, 0xf8, 0x74, 0xec, 0x5a, 0xa8, 0xc2, 0x84, 0x2e, 0x26,
+	0xda, 0x43, 0x48, 0x45, 0x2a, 0x52, 0xaf, 0xa6, 0xa2, 0x45, 0xae, 0x22, 0xae, 0x74, 0x69, 0xd0,
+	0x93, 0x3d, 0x29, 0xa6, 0x06, 0xa4, 0xa3, 0x07, 0x4f, 0x6a, 0xf2, 0x6a, 0xb2, 0x9e, 0x84, 0x69,
+	0x1f, 0xc0, 0x52, 0xa4, 0x8d, 0x88, 0x5c, 0xa1, 0xc8, 0x7c, 0xe4, 0x90, 0xec, 0xce, 0xc8, 0xce,
+	0x10, 0x4f, 0x57, 0x12, 0xab, 0x9b, 0xc8, 0xae, 0x89, 0x6f, 0xd8, 0x3b, 0x90, 0x0e, 0xec, 0x81,
+	0x6b, 0xb2, 0xb1, 0x4f, 0xa4, 0x32, 0x27, 0x86, 0xca, 0xf3, 0x18, 0xcc, 0x0b, 0xa5, 0x4f, 0xb1,
+	0xa7, 0x5c, 0xcc, 0x5e, 0xec, 0x32, 0xf6, 0xe2, 0x6f, 0xca, 0xde, 0x0e, 0x40, 0xb4, 0xa5, 0xa0,
+	0xa0, 0x96, 0xe3, 0xeb, 0x99, 0x8d, 0x1b, 0x97, 0xa5, 0x13, 0xdb, 0xed, 0xd8, 0x03, 0x79, 0xa9,
+	0xa7, 0x42, 0x23, 0x65, 0x25, 0xa6, 0x1e, 0xd3, 0x3a, 0xa4, 0x7b, 0x36, 0x33, 0x4c, 0xdf, 0x37,
+	0x8f, 0x90, 0xce, 0xcc, 0xc6, 0x7b, 0xe7, 0x73, 0xf3, 0xbe, 0x54, 0xe5, 0x7d, 0xa9, 0xda, 0xb0,
+	0x59, 0x9d, 0x63, 0xf5, 0x54, 0x4f, 0x8e, 0x2a, 0x67, 0x0a, 0xa4, 0xa3, 0x65, 0xb5, 0x1d, 0xc8,
+	0x85, 0xa5, 0x1b, 0x8f, 0x1d, 0x73, 0x20, 0xa5, 0xba, 0xf6, 0x37, 0xf5, 0xdf, 0x77, 0xcc, 0x81,
+	0x9e, 0x91, 0x25, 0xf3, 0xc9, 0xc5, 0x07, 0x1e, 0xbb, 0xe4, 0xc0, 0x67, 0x14, 0x16, 0xff, 0x77,
+	0x0a, 0x9b, 0xd1, 0x82, 0xfa, 0xba, 0x16, 0x7e, 0x8c, 0x41, 0xaa, 0x8d, 0x97, 0xd8, 0x74, 0xfe,
+	0xbb, 0x6b, 0xb8, 0x02, 0x69, 0x8f, 0x3a, 0x86, 0xf0, 0xa8, 0xe8, 0x49, 0x79, 0xd4, 0xd1, 0xcf,
+	0xa9, 0x2c, 0xf1, 0x56, 0xef, 0xe8, 0xfc, 0x5b, 0x60, 0x30, 0xf9, 0x3a, 0x83, 0xdf, 0x40, 0x56,
+	0x10, 0x22, 0x9b, 0xed, 0xc7, 0x9c, 0x09, 0xec, 0xe0, 0xa2, 0xd7, 0x96, 0x2e, 0xdb, 0xbc, 0xc0,
+	0xeb, 0x12, 0xcd, 0xe3, 0x44, 0x57, 0x92, 0x9d, 0xbf, 0xf4, 0xd7, 0x77, 0x41, 0x97, 0xe8, 0xca,
+	0xcf, 0x0a, 0xa4, 0xb1, 0xec, 0x3d, 0xc2, 0xcc, 0x19, 0xf2, 0x94, 0x37, 0x25, 0xef, 0x5d, 0x00,
+	0x91, 0x2c, 0xb0, 0x9f, 0x12, 0x79, 0xb0, 0x69, 0xb4, 0x74, 0xec, 0xa7, 0x44, 0xfb, 0x2c, 0xaa,
+	0x34, 0x7e, 0x95, 0x4a, 0xe5, 0xd5, 0x0d, 0xeb, 0xbd, 0x0e, 0x49, 0x77, 0x3c, 0x32, 0x78, 0x9b,
+	0x50, 0x85, 0x64, 0xdc, 0xf1, 0xa8, 0x7b, 0x18, 0x54, 0xbe, 0x86, 0x64, 0xf7, 0x10, 0xbf, 0x9f,
+	0xb8, 0x4e, 0x7c, 0x4a, 0x65, 0x9f, 0x16, 0x1f, 0x4b, 0x29, 0x6e, 0xc0, 0xb6, 0xa4, 0x81, 0xca,
+	0x1b, 0x72, 0xd8, 0x51, 0xf8, 0x58, 0xfb, 0x14, 0x12, 0xed, 0x7f, 0xfc, 0x99, 0xa6, 0x8b, 0x98,
+	0x3b, 0x3f, 0x29, 0x90, 0x99, 0xba, 0xb7, 0x5a, 0x11, 0xae, 0x35, 0x76, 0xf7, 0x37, 0x1f, 0x6e,
+	0x19, 0xcd, 0x2d, 0xe3, 0xfe, 0x6e, 0x7d, 0xc7, 0xf8, 0xbc, 0xf5, 0xb0, 0xb5, 0xff, 0x45, 0x2b,
+	0x3f, 0xa7, 0xd5, 0x60, 0x19, 0x7d, 0x91, 0xab, 0xde, 0xe8, 0x6c, 0xb7, 0xba, 0x79, 0xa5, 0xf8,
+	0xbf, 0xe3, 0x93, 0xf2, 0xd2, 0x54, 0x9a, 0x7a, 0x2f, 0x20, 0x2e, 0x3b, 0x1f, 0xb0, 0xb9, 0xbf,
+	0xb7, 0xd7, 0xec, 0xe6, 0x63, 0xe7, 0x02, 0xe4, 0xd3, 0x7c, 0x1b, 0x96, 0x66, 0x03, 0x5a, 0xcd,
+	0xdd, 0x7c, 0xbc, 0xa8, 0x1d, 0x9f, 0x94, 0x17, 0xa6, 0xd0, 0x2d, 0xdb, 0x29, 0xa6, 0xbe, 0x7d,
+	0x5e, 0x9a, 0xfb, 0xe1, 0xbb, 0x92, 0x72, 0xe7, 0x7b, 0x05, 0x72, 0x33, 0xd7, 0x53, 0x5b, 0x81,
+	0xeb, 0x9d, 0xe6, 0x4e, 0x6b, 0x7b, 0xcb, 0xd8, 0xeb, 0xec, 0x18, 0xdd, 0x2f, 0xdb, 0xdb, 0x53,
+	0x55, 0xdc, 0x80, 0x6c, 0x5b, 0xdf, 0x7e, 0xb4, 0xdf, 0xdd, 0x46, 0x4f, 0x5e, 0x29, 0x2e, 0x1e,
+	0x9f, 0x94, 0x33, 0x6d, 0x9f, 0x1c, 0x50, 0x46, 0x30, 0xfe, 0x26, 0x2c, 0xb4, 0xf5, 0x6d, 0xb1,
+	0x59, 0x01, 0x8a, 0x15, 0x97, 0x8e, 0x4f, 0xca, 0xb9, 0xb6, 0x4f, 0x84, 0x02, 0x11, 0xb6, 0x06,
+	0xb9, 0xb6, 0xbe, 0xdf, 0xde, 0xef, 0xd4, 0x77, 0x05, 0x2a, 0x5e, 0xcc, 0x1f, 0x9f, 0x94, 0xb3,
+	0xe1, 0xdb, 0xc2, 0x41, 0x93, 0x7d, 0x36, 0xee, 0xbf, 0x38, 0x2d, 0x29, 0x2f, 0x4f, 0x4b, 0xca,
+	0x6f, 0xa7, 0x25, 0xe5, 0xd9, 0x59, 0x69, 0xee, 0xe5, 0x59, 0x69, 0xee, 0x97, 0xb3, 0xd2, 0xdc,
+	0x57, 0x77, 0x07, 0x36, 0x1b, 0x8e, 0x7b, 0xd5, 0x3e, 0x1d, 0xd5, 0x26, 0x87, 0x37, 0x3d, 0x9c,
+	0xfa, 0x35, 0xd3, 0x9b, 0xc7, 0xc9, 0x47, 0x7f, 0x06, 0x00, 0x00, 0xff, 0xff, 0x21, 0xb8, 0xcf,
+	0x26, 0xe3, 0x0c, 0x00, 0x00,
 }
 
 func (m *PartSetHeader) Marshal() (dAtA []byte, err error) {
@@ -1695,6 +1760,55 @@ func (m *BlockMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *TxProof) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *TxProof) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxProof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Proof != nil {
+		{
+			size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTypes(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.Data) > 0 {
+		i -= len(m.Data)
+		copy(dAtA[i:], m.Data)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Data)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.RootHash) > 0 {
+		i -= len(m.RootHash)
+		copy(dAtA[i:], m.RootHash)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.RootHash)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
 	offset -= sovTypes(v)
 	base := offset
@@ -1983,6 +2097,27 @@ func (m *BlockMeta) Size() (n int) {
 	return n
 }
 
+func (m *TxProof) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.RootHash)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	l = len(m.Data)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	if m.Proof != nil {
+		l = m.Proof.Size()
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	return n
+}
+
 func sovTypes(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -4157,6 +4292,163 @@ func (m *BlockMeta) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *TxProof) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: TxProof: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: TxProof: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RootHash", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.RootHash = append(m.RootHash[:0], dAtA[iNdEx:postIndex]...)
+			if m.RootHash == nil {
+				m.RootHash = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
+			if m.Data == nil {
+				m.Data = []byte{}
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Proof == nil {
+				m.Proof = &merkle.Proof{}
+			}
+			if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipTypes(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0

proto/types/types.proto

@@ -144,3 +144,10 @@ message BlockMeta {
   Header  header     = 3 [(gogoproto.nullable) = false];
   int64   num_txs    = 4;
 }
+
+// TxProof represents a Merkle proof of the presence of a transaction in the Merkle tree.
+message TxProof {
+  bytes                                root_hash = 1;
+  bytes                                data      = 2;
+  tendermint.proto.crypto.merkle.Proof Proof     = 3;
+}

proto/types/validator.pb.go

@@ -154,41 +154,98 @@ func (m *Validator) GetProposerPriority() int64 {
 	return 0
 }
 
+type SimpleValidator struct {
+	PubKey      *keys.PublicKey `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
+	VotingPower int64           `protobuf:"varint,2,opt,name=voting_power,json=votingPower,proto3" json:"voting_power,omitempty"`
+}
+
+func (m *SimpleValidator) Reset()         { *m = SimpleValidator{} }
+func (m *SimpleValidator) String() string { return proto.CompactTextString(m) }
+func (*SimpleValidator) ProtoMessage()    {}
+func (*SimpleValidator) Descriptor() ([]byte, []int) {
+	return fileDescriptor_2e7c6b38c20e5406, []int{2}
+}
+func (m *SimpleValidator) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *SimpleValidator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_SimpleValidator.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *SimpleValidator) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SimpleValidator.Merge(m, src)
+}
+func (m *SimpleValidator) XXX_Size() int {
+	return m.Size()
+}
+func (m *SimpleValidator) XXX_DiscardUnknown() {
+	xxx_messageInfo_SimpleValidator.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SimpleValidator proto.InternalMessageInfo
+
+func (m *SimpleValidator) GetPubKey() *keys.PublicKey {
+	if m != nil {
+		return m.PubKey
+	}
+	return nil
+}
+
+func (m *SimpleValidator) GetVotingPower() int64 {
+	if m != nil {
+		return m.VotingPower
+	}
+	return 0
+}
+
 func init() {
 	proto.RegisterType((*ValidatorSet)(nil), "tendermint.proto.types.ValidatorSet")
 	golang_proto.RegisterType((*ValidatorSet)(nil), "tendermint.proto.types.ValidatorSet")
 	proto.RegisterType((*Validator)(nil), "tendermint.proto.types.Validator")
 	golang_proto.RegisterType((*Validator)(nil), "tendermint.proto.types.Validator")
+	proto.RegisterType((*SimpleValidator)(nil), "tendermint.proto.types.SimpleValidator")
+	golang_proto.RegisterType((*SimpleValidator)(nil), "tendermint.proto.types.SimpleValidator")
 }
 
 func init() { proto.RegisterFile("proto/types/validator.proto", fileDescriptor_2e7c6b38c20e5406) }
-func init() { golang_proto.RegisterFile("proto/types/validator.proto", fileDescriptor_2e7c6b38c20e5406) }
+func init() {
+	golang_proto.RegisterFile("proto/types/validator.proto", fileDescriptor_2e7c6b38c20e5406)
+}
 
 var fileDescriptor_2e7c6b38c20e5406 = []byte{
-	// 358 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x3f, 0x4f, 0xfa, 0x40,
-	0x18, 0xc7, 0x7b, 0x3f, 0x08, 0xfc, 0x3c, 0x18, 0xf4, 0x06, 0xd3, 0x60, 0xac, 0xc0, 0xa0, 0x24,
-	0x92, 0x36, 0xd1, 0xd9, 0x41, 0x06, 0x07, 0x59, 0x48, 0x4d, 0x18, 0x5c, 0x9a, 0x96, 0x5e, 0xca,
-	0x85, 0x3f, 0x77, 0xb9, 0x3e, 0xc5, 0xdc, 0xbb, 0xf0, 0x0d, 0x69, 0x1c, 0x19, 0x19, 0x9d, 0x8c,
-	0xa1, 0x6f, 0xc4, 0xd0, 0xa3, 0x85, 0x44, 0x06, 0xb7, 0xe7, 0xf9, 0x7e, 0x9f, 0x3f, 0x9f, 0x7b,
-	0x72, 0xf8, 0x4c, 0x48, 0x0e, 0xdc, 0x01, 0x25, 0x68, 0xec, 0x2c, 0xfc, 0x29, 0x0b, 0x7d, 0xe0,
-	0xd2, 0xce, 0x54, 0x72, 0x0a, 0x74, 0x1e, 0x52, 0x39, 0x63, 0x73, 0xd0, 0x8a, 0x9d, 0xd5, 0x35,
-	0x2e, 0x61, 0xcc, 0x64, 0xe8, 0x09, 0x5f, 0x82, 0x72, 0xf4, 0x80, 0x88, 0x47, 0x7c, 0x17, 0xe9,
-	0xea, 0xc6, 0xb9, 0x56, 0x46, 0x52, 0x09, 0xe0, 0xce, 0x84, 0xaa, 0x58, 0x2f, 0xd2, 0x76, 0xfb,
-	0x1d, 0xe1, 0xfa, 0x30, 0x5f, 0xf9, 0x44, 0x81, 0xdc, 0x63, 0x5c, 0x20, 0xc4, 0x26, 0x6a, 0x96,
-	0x3a, 0xb5, 0x9b, 0x96, 0x7d, 0x18, 0xc2, 0x2e, 0x3a, 0xdd, 0xbd, 0x26, 0x72, 0x87, 0xff, 0x0b,
-	0xc9, 0x05, 0x8f, 0xa9, 0x34, 0xff, 0x35, 0xd1, 0xdf, 0x06, 0x14, 0x2d, 0xa4, 0x8b, 0x09, 0x70,
-	0xf0, 0xa7, 0xde, 0x82, 0x03, 0x9b, 0x47, 0x9e, 0xe0, 0x2f, 0x54, 0x9a, 0xa5, 0x26, 0xea, 0x94,
-	0xdc, 0xe3, 0xcc, 0x19, 0x66, 0xc6, 0x60, 0xa3, 0xb7, 0xdf, 0x10, 0x3e, 0x2a, 0xa6, 0x10, 0x13,
-	0x57, 0xfd, 0x30, 0x94, 0x34, 0xde, 0xa0, 0xa3, 0x4e, 0xdd, 0xcd, 0x53, 0xf2, 0x80, 0xab, 0x22,
-	0x09, 0xbc, 0x09, 0x55, 0x5b, 0xa6, 0xab, 0xdf, 0x4c, 0xfa, 0x48, 0xf6, 0xe6, 0x48, 0xf6, 0x20,
-	0x09, 0xa6, 0x6c, 0xd4, 0xa7, 0xaa, 0x57, 0x5e, 0x7e, 0x5d, 0x18, 0x6e, 0x45, 0x24, 0x41, 0x9f,
-	0x2a, 0xd2, 0xc2, 0xf5, 0x03, 0x5c, 0xb5, 0xc5, 0x0e, 0x89, 0x5c, 0xe3, 0x93, 0xfc, 0x31, 0x9e,
-	0x90, 0x8c, 0x4b, 0x06, 0xca, 0x2c, 0x6b, 0xfe, 0xdc, 0x18, 0x6c, 0xf5, 0xde, 0xe3, 0x72, 0x6d,
-	0xa1, 0xd5, 0xda, 0x42, 0xdf, 0x6b, 0x0b, 0xbd, 0xa6, 0x96, 0xf1, 0x91, 0x5a, 0x68, 0x95, 0x5a,
-	0xc6, 0x67, 0x6a, 0x19, 0xcf, 0xdd, 0x88, 0xc1, 0x38, 0x09, 0xec, 0x11, 0x9f, 0x39, 0x3b, 0xdc,
-	0xfd, 0x70, 0xef, 0xef, 0x04, 0x95, 0x2c, 0xb9, 0xfd, 0x09, 0x00, 0x00, 0xff, 0xff, 0xbb, 0xf6,
-	0x8f, 0xab, 0x51, 0x02, 0x00, 0x00,
+	// 383 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0x4f, 0x6b, 0xe2, 0x40,
+	0x18, 0xc6, 0x33, 0x2a, 0xba, 0x3b, 0x0a, 0xbb, 0x3b, 0x87, 0x25, 0xb8, 0x6c, 0x56, 0x3d, 0xec,
+	0x0a, 0x2b, 0x09, 0xb4, 0xe7, 0x42, 0xeb, 0xa1, 0x87, 0x7a, 0x91, 0x08, 0x1e, 0x7a, 0x09, 0x89,
+	0x19, 0xe2, 0x60, 0x74, 0x86, 0xc9, 0x24, 0x65, 0xbe, 0x45, 0xbf, 0x50, 0x4b, 0x8f, 0x1e, 0x3d,
+	0xf6, 0x54, 0x8a, 0xf9, 0x22, 0xc5, 0x8c, 0x49, 0x04, 0x2d, 0xb4, 0xb7, 0x79, 0x9f, 0xe7, 0xfd,
+	0xf3, 0x7b, 0x5f, 0x06, 0xfe, 0x62, 0x9c, 0x0a, 0x6a, 0x09, 0xc9, 0x70, 0x64, 0x25, 0x6e, 0x48,
+	0x7c, 0x57, 0x50, 0x6e, 0x66, 0x2a, 0xfa, 0x29, 0xf0, 0xca, 0xc7, 0x7c, 0x49, 0x56, 0x42, 0x29,
+	0x66, 0x96, 0xd7, 0xfe, 0x2b, 0xe6, 0x84, 0xfb, 0x0e, 0x73, 0xb9, 0x90, 0x96, 0x6a, 0x10, 0xd0,
+	0x80, 0x96, 0x2f, 0x95, 0xdd, 0xfe, 0xad, 0x94, 0x19, 0x97, 0x4c, 0x50, 0x6b, 0x81, 0x65, 0xa4,
+	0x06, 0x29, 0xbb, 0xf7, 0x08, 0x60, 0x6b, 0x9a, 0x8f, 0x9c, 0x60, 0x81, 0xae, 0x20, 0x2c, 0x10,
+	0x22, 0x1d, 0x74, 0xaa, 0xfd, 0xe6, 0x59, 0xd7, 0x3c, 0x0d, 0x61, 0x16, 0x95, 0xf6, 0x41, 0x11,
+	0xba, 0x80, 0x5f, 0x18, 0xa7, 0x8c, 0x46, 0x98, 0xeb, 0x95, 0x0e, 0xf8, 0x58, 0x83, 0xa2, 0x04,
+	0x0d, 0x20, 0x12, 0x54, 0xb8, 0xa1, 0x93, 0x50, 0x41, 0x56, 0x81, 0xc3, 0xe8, 0x1d, 0xe6, 0x7a,
+	0xb5, 0x03, 0xfa, 0x55, 0xfb, 0x7b, 0xe6, 0x4c, 0x33, 0x63, 0xbc, 0xd3, 0x7b, 0x0f, 0x00, 0x7e,
+	0x2d, 0xba, 0x20, 0x1d, 0x36, 0x5c, 0xdf, 0xe7, 0x38, 0xda, 0xa1, 0x83, 0x7e, 0xcb, 0xce, 0x43,
+	0x74, 0x0d, 0x1b, 0x2c, 0xf6, 0x9c, 0x05, 0x96, 0x7b, 0xa6, 0x7f, 0xc7, 0x4c, 0xea, 0x48, 0xe6,
+	0xee, 0x48, 0xe6, 0x38, 0xf6, 0x42, 0x32, 0x1b, 0x61, 0x39, 0xac, 0xad, 0x5f, 0xfe, 0x68, 0x76,
+	0x9d, 0xc5, 0xde, 0x08, 0x4b, 0xd4, 0x85, 0xad, 0x13, 0x5c, 0xcd, 0xa4, 0x44, 0x42, 0xff, 0xe1,
+	0x8f, 0x7c, 0x19, 0x87, 0x71, 0x42, 0x39, 0x11, 0x52, 0xaf, 0x29, 0xfe, 0xdc, 0x18, 0xef, 0xf5,
+	0x5e, 0x02, 0xbf, 0x4d, 0xc8, 0x92, 0x85, 0xb8, 0x5c, 0xe2, 0xb2, 0x44, 0x05, 0x9f, 0x42, 0x7d,
+	0x17, 0xb2, 0x72, 0x04, 0x39, 0xbc, 0x59, 0x6f, 0x0d, 0xb0, 0xd9, 0x1a, 0xe0, 0x75, 0x6b, 0x80,
+	0xfb, 0xd4, 0xd0, 0x9e, 0x52, 0x03, 0x6c, 0x52, 0x43, 0x7b, 0x4e, 0x0d, 0xed, 0x76, 0x10, 0x10,
+	0x31, 0x8f, 0x3d, 0x73, 0x46, 0x97, 0x56, 0x39, 0xfb, 0xf0, 0x79, 0xf0, 0x67, 0xbd, 0x7a, 0x16,
+	0x9c, 0xbf, 0x05, 0x00, 0x00, 0xff, 0xff, 0xbd, 0x74, 0x56, 0xec, 0xc9, 0x02, 0x00, 0x00,
 }
 
 func (m *ValidatorSet) Marshal() (dAtA []byte, err error) {
@@ -295,6 +352,46 @@ func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *SimpleValidator) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *SimpleValidator) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *SimpleValidator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.VotingPower != 0 {
+		i = encodeVarintValidator(dAtA, i, uint64(m.VotingPower))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.PubKey != nil {
+		{
+			size, err := m.PubKey.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintValidator(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintValidator(dAtA []byte, offset int, v uint64) int {
 	offset -= sovValidator(v)
 	base := offset
@@ -349,6 +446,22 @@ func (m *Validator) Size() (n int) {
 	return n
 }
 
+func (m *SimpleValidator) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.PubKey != nil {
+		l = m.PubKey.Size()
+		n += 1 + l + sovValidator(uint64(l))
+	}
+	if m.VotingPower != 0 {
+		n += 1 + sovValidator(uint64(m.VotingPower))
+	}
+	return n
+}
+
 func sovValidator(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -655,6 +768,114 @@ func (m *Validator) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *SimpleValidator) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowValidator
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: SimpleValidator: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: SimpleValidator: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowValidator
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthValidator
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthValidator
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.PubKey == nil {
+				m.PubKey = &keys.PublicKey{}
+			}
+			if err := m.PubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field VotingPower", wireType)
+			}
+			m.VotingPower = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowValidator
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.VotingPower |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipValidator(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthValidator
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthValidator
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipValidator(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0

proto/types/validator.proto

@@ -23,3 +23,8 @@ message Validator {
   int64                                  voting_power      = 3;
   int64                                  proposer_priority = 4;
 }
+
+message SimpleValidator {
+  tendermint.proto.crypto.keys.PublicKey pub_key      = 1;
+  int64                                  voting_power = 2;
+}

state/main_test.go

@@ -3,11 +3,8 @@ package state_test
 import (
 	"os"
 	"testing"
-
-	"github.com/tendermint/tendermint/types"
 )
 
 func TestMain(m *testing.M) {
-	types.RegisterMockEvidencesGlobal()
 	os.Exit(m.Run())
 }

types/block.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/gogo/protobuf/proto"
+	gogotypes "github.com/gogo/protobuf/types"
 
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/merkle"
@@ -21,10 +22,10 @@ import (
 )
 
 const (
-	// MaxHeaderBytes is a maximum header size (including amino overhead).
-	MaxHeaderBytes int64 = 628
+	// MaxHeaderBytes is a maximum header size.
+	MaxHeaderBytes int64 = 626
 
-	// MaxAminoOverheadForBlock - maximum amino overhead to encode a block (up to
+	// MaxOverheadForBlock - maximum overhead to encode a block (up to
 	// MaxBlockSizeBytes in size) not including it's parts except Data.
 	// This means it also excludes the overhead for individual transactions.
 	//
@@ -32,7 +33,7 @@ const (
 	// 2 fields (2 embedded):               2 bytes
 	// Uvarint length of Data.Txs:          4 bytes
 	// Data.Txs field:                      1 byte
-	MaxAminoOverheadForBlock int64 = 11
+	MaxOverheadForBlock int64 = 11
 )
 
 // Block defines the atomic unit of a Tendermint blockchain.
@@ -167,11 +168,12 @@ func (b *Block) HashesTo(hash []byte) bool {
 
 // Size returns size of the block in bytes.
 func (b *Block) Size() int {
-	bz, err := cdc.MarshalBinaryBare(b)
+	pbb, err := b.ToProto()
 	if err != nil {
 		return 0
 	}
-	return len(bz)
+
+	return pbb.Size()
 }
 
 // String returns a string representation of the block
@@ -257,28 +259,6 @@ func BlockFromProto(bp *tmproto.Block) (*Block, error) {
 	return b, b.ValidateBasic()
 }
 
-//-----------------------------------------------------------
-// These methods are for Protobuf Compatibility
-
-// Marshal returns the amino encoding.
-func (b *Block) Marshal() ([]byte, error) {
-	return cdc.MarshalBinaryBare(b)
-}
-
-// MarshalTo calls Marshal and copies to the given buffer.
-func (b *Block) MarshalTo(data []byte) (int, error) {
-	bs, err := b.Marshal()
-	if err != nil {
-		return -1, err
-	}
-	return copy(data, bs), nil
-}
-
-// Unmarshal deserializes from amino encoded form.
-func (b *Block) Unmarshal(bs []byte) error {
-	return cdc.UnmarshalBinaryBare(bs, b)
-}
-
 //-----------------------------------------------------------------------------
 
 // MaxDataBytes returns the maximum size of block's data.
@@ -286,7 +266,7 @@ func (b *Block) Unmarshal(bs []byte) error {
 // XXX: Panics on negative result.
 func MaxDataBytes(maxBytes int64, valsCount, evidenceCount int) int64 {
 	maxDataBytes := maxBytes -
-		MaxAminoOverheadForBlock -
+		MaxOverheadForBlock -
 		MaxHeaderBytes -
 		int64(valsCount)*MaxVoteBytes -
 		int64(evidenceCount)*MaxEvidenceBytes
@@ -311,7 +291,7 @@ func MaxDataBytes(maxBytes int64, valsCount, evidenceCount int) int64 {
 func MaxDataBytesUnknownEvidence(maxBytes int64, valsCount int, maxNumEvidence uint32) int64 {
 	maxEvidenceBytes := int64(maxNumEvidence) * MaxEvidenceBytes
 	maxDataBytes := maxBytes -
-		MaxAminoOverheadForBlock -
+		MaxOverheadForBlock -
 		MaxHeaderBytes -
 		int64(valsCount)*MaxVoteBytes -
 		maxEvidenceBytes
@@ -449,12 +429,27 @@ func (h *Header) Hash() tmbytes.HexBytes {
 	if h == nil || len(h.ValidatorsHash) == 0 {
 		return nil
 	}
+	hbz, err := h.Version.Marshal()
+	if err != nil {
+		return nil
+	}
+
+	pbt, err := gogotypes.StdTimeMarshal(h.Time)
+	if err != nil {
+		return nil
+	}
+
+	pbbi := h.LastBlockID.ToProto()
+	bzbi, err := pbbi.Marshal()
+	if err != nil {
+		return nil
+	}
 	return merkle.HashFromByteSlices([][]byte{
-		cdcEncode(h.Version),
+		hbz,
 		cdcEncode(h.ChainID),
 		cdcEncode(h.Height),
-		cdcEncode(h.Time),
-		cdcEncode(h.LastBlockID),
+		pbt,
+		bzbi,
 		cdcEncode(h.LastCommitHash),
 		cdcEncode(h.DataHash),
 		cdcEncode(h.ValidatorsHash),
@@ -866,7 +861,13 @@ func (commit *Commit) Hash() tmbytes.HexBytes {
 	if commit.hash == nil {
 		bs := make([][]byte, len(commit.Signatures))
 		for i, commitSig := range commit.Signatures {
-			bs[i] = cdcEncode(commitSig)
+			pbcs := commitSig.ToProto()
+			bz, err := pbcs.Marshal()
+			if err != nil {
+				panic(err)
+			}
+
+			bs[i] = bz
 		}
 		commit.hash = merkle.HashFromByteSlices(bs)
 	}
@@ -1248,10 +1249,12 @@ func (blockID BlockID) Equals(other BlockID) bool {
 
 // Key returns a machine-readable string representation of the BlockID
 func (blockID BlockID) Key() string {
-	bz, err := cdc.MarshalBinaryBare(blockID.PartsHeader)
+	pbph := blockID.PartsHeader.ToProto()
+	bz, err := pbph.Marshal()
 	if err != nil {
 		panic(err)
 	}
+
 	return string(blockID.Hash) + string(bz)
 }
 

types/block_meta.go

@@ -65,34 +65,6 @@ func BlockMetaFromProto(pb *tmproto.BlockMeta) (*BlockMeta, error) {
 	return bm, bm.ValidateBasic()
 }
 
-//-----------------------------------------------------------
-// These methods are for Protobuf Compatibility
-
-// Size returns the size of the amino encoding, in bytes.
-func (bm *BlockMeta) Size() int {
-	bs, _ := bm.Marshal()
-	return len(bs)
-}
-
-// Marshal returns the amino encoding.
-func (bm *BlockMeta) Marshal() ([]byte, error) {
-	return cdc.MarshalBinaryBare(bm)
-}
-
-// MarshalTo calls Marshal and copies to the given buffer.
-func (bm *BlockMeta) MarshalTo(data []byte) (int, error) {
-	bs, err := bm.Marshal()
-	if err != nil {
-		return -1, err
-	}
-	return copy(data, bs), nil
-}
-
-// Unmarshal deserializes from amino encoded form.
-func (bm *BlockMeta) Unmarshal(bs []byte) error {
-	return cdc.UnmarshalBinaryBare(bs, bm)
-}
-
 // ValidateBasic performs basic validation.
 func (bm *BlockMeta) ValidateBasic() error {
 	if err := bm.BlockID.ValidateBasic(); err != nil {

types/block_test.go

@@ -11,6 +11,7 @@ import (
 	"testing"
 	"time"
 
+	gogotypes "github.com/gogo/protobuf/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -26,8 +27,6 @@ import (
 )
 
 func TestMain(m *testing.M) {
-	RegisterMockEvidences(cdc)
-
 	code := m.Run()
 	os.Exit(code)
 }
@@ -270,7 +269,7 @@ func TestHeaderHash(t *testing.T) {
 			LastResultsHash:    tmhash.Sum([]byte("last_results_hash")),
 			EvidenceHash:       tmhash.Sum([]byte("evidence_hash")),
 			ProposerAddress:    crypto.AddressHash([]byte("proposer_address")),
-		}, hexBytesFromString("ABDC78921B18A47EE6BEF5E31637BADB0F3E587E3C0F4DB2D1E93E9FF0533862")},
+		}, hexBytesFromString("F740121F553B5418C3EFBD343C2DBFE9E007BB67B0D020A0741374BAB65242A4")},
 		{"nil header yields nil", nil, nil},
 		{"nil ValidatorsHash yields nil", &Header{
 			Version:            version.Consensus{Block: 1, App: 2},
@@ -298,12 +297,33 @@ func TestHeaderHash(t *testing.T) {
 			// fields in the test struct are non-zero.
 			if tc.header != nil && tc.expectHash != nil {
 				byteSlices := [][]byte{}
+
 				s := reflect.ValueOf(*tc.header)
 				for i := 0; i < s.NumField(); i++ {
 					f := s.Field(i)
+
 					assert.False(t, f.IsZero(), "Found zero-valued field %v",
 						s.Type().Field(i).Name)
-					byteSlices = append(byteSlices, cdcEncode(f.Interface()))
+
+					switch f := f.Interface().(type) {
+					case int64, bytes.HexBytes, string:
+						byteSlices = append(byteSlices, cdcEncode(f))
+					case time.Time:
+						bz, err := gogotypes.StdTimeMarshal(f)
+						require.NoError(t, err)
+						byteSlices = append(byteSlices, bz)
+					case version.Consensus:
+						bz, err := f.Marshal()
+						require.NoError(t, err)
+						byteSlices = append(byteSlices, bz)
+					case BlockID:
+						pbbi := f.ToProto()
+						bz, err := pbbi.Marshal()
+						require.NoError(t, err)
+						byteSlices = append(byteSlices, bz)
+					default:
+						t.Errorf("unknown type %T", f)
+					}
 				}
 				assert.Equal(t,
 					bytes.HexBytes(merkle.HashFromByteSlices(byteSlices)), tc.header.Hash())
@@ -343,7 +363,7 @@ func TestMaxHeaderBytes(t *testing.T) {
 		ProposerAddress:    crypto.AddressHash([]byte("proposer_address")),
 	}
 
-	bz, err := cdc.MarshalBinaryLengthPrefixed(h)
+	bz, err := h.ToProto().Marshal()
 	require.NoError(t, err)
 
 	assert.EqualValues(t, MaxHeaderBytes, int64(len(bz)))
@@ -378,9 +398,9 @@ func TestBlockMaxDataBytes(t *testing.T) {
 	}{
 		0: {-10, 1, 0, true, 0},
 		1: {10, 1, 0, true, 0},
-		2: {846, 1, 0, true, 0},
-		3: {848, 1, 0, false, 0},
-		4: {849, 1, 0, false, 1},
+		2: {844, 1, 0, true, 0},
+		3: {846, 1, 0, false, 0},
+		4: {847, 1, 0, false, 1},
 	}
 
 	for i, tc := range testCases {
@@ -408,10 +428,10 @@ func TestBlockMaxDataBytesUnknownEvidence(t *testing.T) {
 	}{
 		0: {-10, 0, 1, true, 0},
 		1: {10, 0, 1, true, 0},
-		2: {847, 0, 1, true, 0},
-		3: {848, 0, 1, false, 0},
-		4: {1292, 1, 1, false, 0},
-		5: {1293, 1, 1, false, 1},
+		2: {845, 0, 1, true, 0},
+		3: {846, 0, 1, false, 0},
+		4: {1290, 1, 1, false, 0},
+		5: {1291, 1, 1, false, 1},
 	}
 
 	for i, tc := range testCases {
@@ -445,9 +465,12 @@ func TestCommitToVoteSet(t *testing.T) {
 		vote2 := voteSet2.GetByIndex(i)
 		vote3 := commit.GetVote(i)
 
-		vote1bz := cdc.MustMarshalBinaryBare(vote1)
-		vote2bz := cdc.MustMarshalBinaryBare(vote2)
-		vote3bz := cdc.MustMarshalBinaryBare(vote3)
+		vote1bz, err := vote1.ToProto().Marshal()
+		require.NoError(t, err)
+		vote2bz, err := vote2.ToProto().Marshal()
+		require.NoError(t, err)
+		vote3bz, err := vote3.ToProto().Marshal()
+		require.NoError(t, err)
 		assert.Equal(t, vote1bz, vote2bz)
 		assert.Equal(t, vote1bz, vote3bz)
 	}

types/codec.go

@@ -1,28 +0,0 @@
-package types
-
-import (
-	amino "github.com/tendermint/go-amino"
-
-	cryptoamino "github.com/tendermint/tendermint/crypto/encoding/amino"
-)
-
-var cdc = amino.NewCodec()
-
-func init() {
-	RegisterBlockAmino(cdc)
-}
-
-func RegisterBlockAmino(cdc *amino.Codec) {
-	cryptoamino.RegisterAmino(cdc)
-	RegisterEvidences(cdc)
-}
-
-// GetCodec returns a codec used by the package. For testing purposes only.
-func GetCodec() *amino.Codec {
-	return cdc
-}
-
-// For testing purposes only
-func RegisterMockEvidencesGlobal() {
-	RegisterMockEvidences(cdc)
-}

types/encoding_helper.go

@@ -1,10 +1,47 @@
 package types
 
+import (
+	gogotypes "github.com/gogo/protobuf/types"
+
+	"github.com/tendermint/tendermint/libs/bytes"
+)
+
 // cdcEncode returns nil if the input is nil, otherwise returns
-// cdc.MustMarshalBinaryBare(item)
+// proto.Marshal(<type>Value{Value: item})
 func cdcEncode(item interface{}) []byte {
 	if item != nil && !isTypedNil(item) && !isEmpty(item) {
-		return cdc.MustMarshalBinaryBare(item)
+		switch item := item.(type) {
+		case string:
+			i := gogotypes.StringValue{
+				Value: item,
+			}
+			bz, err := i.Marshal()
+			if err != nil {
+				return nil
+			}
+			return bz
+		case int64:
+			i := gogotypes.Int64Value{
+				Value: item,
+			}
+			bz, err := i.Marshal()
+			if err != nil {
+				return nil
+			}
+			return bz
+		case bytes.HexBytes:
+			i := gogotypes.BytesValue{
+				Value: item,
+			}
+			bz, err := i.Marshal()
+			if err != nil {
+				return nil
+			}
+			return bz
+		default:
+			return nil
+		}
 	}
+
 	return nil
 }

types/events.go

@@ -3,8 +3,6 @@ package types
 import (
 	"fmt"
 
-	amino "github.com/tendermint/go-amino"
-
 	abci "github.com/tendermint/tendermint/abci/types"
 	tmjson "github.com/tendermint/tendermint/libs/json"
 	tmpubsub "github.com/tendermint/tendermint/libs/pubsub"
@@ -48,19 +46,6 @@ type TMEventData interface {
 	// empty interface
 }
 
-func RegisterEventDatas(cdc *amino.Codec) {
-	cdc.RegisterInterface((*TMEventData)(nil), nil)
-	cdc.RegisterConcrete(EventDataNewBlock{}, "tendermint/event/NewBlock", nil)
-	cdc.RegisterConcrete(EventDataNewBlockHeader{}, "tendermint/event/NewBlockHeader", nil)
-	cdc.RegisterConcrete(EventDataTx{}, "tendermint/event/Tx", nil)
-	cdc.RegisterConcrete(EventDataRoundState{}, "tendermint/event/RoundState", nil)
-	cdc.RegisterConcrete(EventDataNewRound{}, "tendermint/event/NewRound", nil)
-	cdc.RegisterConcrete(EventDataCompleteProposal{}, "tendermint/event/CompleteProposal", nil)
-	cdc.RegisterConcrete(EventDataVote{}, "tendermint/event/Vote", nil)
-	cdc.RegisterConcrete(EventDataValidatorSetUpdates{}, "tendermint/event/ValidatorSetUpdates", nil)
-	cdc.RegisterConcrete(EventDataString(""), "tendermint/event/ProposalString", nil)
-}
-
 func init() {
 	tmjson.RegisterType(EventDataNewBlock{}, "tendermint/event/NewBlock")
 	tmjson.RegisterType(EventDataNewBlockHeader{}, "tendermint/event/NewBlockHeader")

types/evidence.go

@@ -7,8 +7,6 @@ import (
 	"strings"
 	"time"
 
-	amino "github.com/tendermint/go-amino"
-
 	"github.com/tendermint/tendermint/crypto"
 	cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
 	"github.com/tendermint/tendermint/crypto/merkle"
@@ -91,99 +89,89 @@ func EvidenceToProto(evidence Evidence) (*tmproto.Evidence, error) {
 
 	switch evi := evidence.(type) {
 	case *DuplicateVoteEvidence:
-		voteB := evi.VoteB.ToProto()
-		voteA := evi.VoteA.ToProto()
+		pbevi := evi.ToProto()
 		tp := &tmproto.Evidence{
 			Sum: &tmproto.Evidence_DuplicateVoteEvidence{
-				DuplicateVoteEvidence: &tmproto.DuplicateVoteEvidence{
-					VoteA: voteA,
-					VoteB: voteB,
-				},
+				DuplicateVoteEvidence: &pbevi,
 			},
 		}
 		return tp, nil
 	case ConflictingHeadersEvidence:
-		pbh1 := evi.H1.ToProto()
-		pbh2 := evi.H2.ToProto()
+		pbevi := evi.ToProto()
 
 		tp := &tmproto.Evidence{
 			Sum: &tmproto.Evidence_ConflictingHeadersEvidence{
-				ConflictingHeadersEvidence: &tmproto.ConflictingHeadersEvidence{
-					H1: pbh1,
-					H2: pbh2,
-				},
+				ConflictingHeadersEvidence: &pbevi,
 			},
 		}
 
 		return tp, nil
 	case *ConflictingHeadersEvidence:
-		pbh1 := evi.H1.ToProto()
-		pbh2 := evi.H2.ToProto()
+		pbevi := evi.ToProto()
 
 		tp := &tmproto.Evidence{
 			Sum: &tmproto.Evidence_ConflictingHeadersEvidence{
-				ConflictingHeadersEvidence: &tmproto.ConflictingHeadersEvidence{
-					H1: pbh1,
-					H2: pbh2,
-				},
+				ConflictingHeadersEvidence: &pbevi,
 			},
 		}
 
 		return tp, nil
 	case *LunaticValidatorEvidence:
-		h := evi.Header.ToProto()
-		v := evi.Vote.ToProto()
+		pbevi := evi.ToProto()
 
 		tp := &tmproto.Evidence{
 			Sum: &tmproto.Evidence_LunaticValidatorEvidence{
-				LunaticValidatorEvidence: &tmproto.LunaticValidatorEvidence{
-					Header:             h,
-					Vote:               v,
-					InvalidHeaderField: evi.InvalidHeaderField,
-				},
+				LunaticValidatorEvidence: &pbevi,
 			},
 		}
+
 		return tp, nil
 	case LunaticValidatorEvidence:
-		h := evi.Header.ToProto()
-		v := evi.Vote.ToProto()
+		pbevi := evi.ToProto()
 
 		tp := &tmproto.Evidence{
 			Sum: &tmproto.Evidence_LunaticValidatorEvidence{
-				LunaticValidatorEvidence: &tmproto.LunaticValidatorEvidence{
-					Header:             h,
-					Vote:               v,
-					InvalidHeaderField: evi.InvalidHeaderField,
-				},
+				LunaticValidatorEvidence: &pbevi,
 			},
 		}
+
+		return tp, nil
+	case *PhantomValidatorEvidence:
+		pbevi := evi.ToProto()
+
+		tp := &tmproto.Evidence{
+			Sum: &tmproto.Evidence_PhantomValidatorEvidence{
+				PhantomValidatorEvidence: &pbevi,
+			},
+		}
+
+		return tp, nil
+	case PhantomValidatorEvidence:
+		pbevi := evi.ToProto()
+
+		tp := &tmproto.Evidence{
+			Sum: &tmproto.Evidence_PhantomValidatorEvidence{
+				PhantomValidatorEvidence: &pbevi,
+			},
+		}
+
 		return tp, nil
 	case *PotentialAmnesiaEvidence:
-		voteB := evi.VoteB.ToProto()
-		voteA := evi.VoteA.ToProto()
+		pbevi := evi.ToProto()
 
 		tp := &tmproto.Evidence{
 			Sum: &tmproto.Evidence_PotentialAmnesiaEvidence{
-				PotentialAmnesiaEvidence: &tmproto.PotentialAmnesiaEvidence{
-					VoteA:       voteA,
-					VoteB:       voteB,
-					HeightStamp: evi.HeightStamp,
-				},
+				PotentialAmnesiaEvidence: &pbevi,
 			},
 		}
 
 		return tp, nil
 	case PotentialAmnesiaEvidence:
-		voteB := evi.VoteB.ToProto()
-		voteA := evi.VoteA.ToProto()
+		pbevi := evi.ToProto()
 
 		tp := &tmproto.Evidence{
 			Sum: &tmproto.Evidence_PotentialAmnesiaEvidence{
-				PotentialAmnesiaEvidence: &tmproto.PotentialAmnesiaEvidence{
-					VoteA:       voteA,
-					VoteB:       voteB,
-					HeightStamp: evi.HeightStamp,
-				},
+				PotentialAmnesiaEvidence: &pbevi,
 			},
 		}
 		return tp, nil
@@ -238,78 +226,17 @@ func EvidenceFromProto(evidence *tmproto.Evidence) (Evidence, error) {
 
 	switch evi := evidence.Sum.(type) {
 	case *tmproto.Evidence_DuplicateVoteEvidence:
-
-		vA, err := VoteFromProto(evi.DuplicateVoteEvidence.VoteA)
-		if err != nil {
-			return nil, err
-		}
-
-		vB, err := VoteFromProto(evi.DuplicateVoteEvidence.VoteB)
-		if err != nil {
-			return nil, err
-		}
-
-		dve := DuplicateVoteEvidence{
-			VoteA: vA,
-			VoteB: vB,
-		}
-
-		return &dve, dve.ValidateBasic()
+		return DuplicateVoteEvidenceFromProto(evi.DuplicateVoteEvidence)
 	case *tmproto.Evidence_ConflictingHeadersEvidence:
-
-		h1, err := SignedHeaderFromProto(evi.ConflictingHeadersEvidence.H1)
-		if err != nil {
-			return nil, fmt.Errorf("from proto err: %w", err)
-		}
-		h2, err := SignedHeaderFromProto(evi.ConflictingHeadersEvidence.H2)
-		if err != nil {
-			return nil, fmt.Errorf("from proto err: %w", err)
-		}
-
-		tp := ConflictingHeadersEvidence{
-			H1: h1,
-			H2: h2,
-		}
-
-		return tp, tp.ValidateBasic()
+		return ConflictingHeadersEvidenceFromProto(evi.ConflictingHeadersEvidence)
 	case *tmproto.Evidence_LunaticValidatorEvidence:
-
-		h, err := HeaderFromProto(evi.LunaticValidatorEvidence.GetHeader())
-		if err != nil {
-			return nil, err
-		}
-
-		v, err := VoteFromProto(evi.LunaticValidatorEvidence.GetVote())
-		if err != nil {
-			return nil, err
-		}
-
-		tp := LunaticValidatorEvidence{
-			Header:             &h,
-			Vote:               v,
-			InvalidHeaderField: evi.LunaticValidatorEvidence.InvalidHeaderField,
-		}
-
-		return &tp, tp.ValidateBasic()
+		return LunaticValidatorEvidenceFromProto(evi.LunaticValidatorEvidence)
 	case *tmproto.Evidence_PotentialAmnesiaEvidence:
 		return PotentialAmnesiaEvidenceFromProto(evi.PotentialAmnesiaEvidence)
-
 	case *tmproto.Evidence_AmnesiaEvidence:
-		pae, err := PotentialAmnesiaEvidenceFromProto(evi.AmnesiaEvidence.PotentialAmnesiaEvidence)
-		if err != nil {
-			return nil, err
-		}
-		polc, err := ProofOfLockChangeFromProto(evi.AmnesiaEvidence.Polc)
-		if err != nil {
-			return nil, err
-		}
-
-		tp := AmnesiaEvidence{
-			PotentialAmnesiaEvidence: *pae,
-			Polc:                     *polc,
-		}
-
-		return tp, tp.ValidateBasic()
+		return AmensiaEvidenceFromProto(evi.AmnesiaEvidence)
+	case *tmproto.Evidence_PhantomValidatorEvidence:
+		return PhantomValidatorEvidenceFromProto(evi.PhantomValidatorEvidence)
 	case *tmproto.Evidence_MockEvidence:
 		me := MockEvidence{
 			EvidenceHeight:  evi.MockEvidence.GetEvidenceHeight(),
@@ -332,16 +259,6 @@ func EvidenceFromProto(evidence *tmproto.Evidence) (Evidence, error) {
 	}
 }
 
-func RegisterEvidences(cdc *amino.Codec) {
-	cdc.RegisterInterface((*Evidence)(nil), nil)
-	cdc.RegisterConcrete(&DuplicateVoteEvidence{}, "tendermint/DuplicateVoteEvidence", nil)
-	cdc.RegisterConcrete(&ConflictingHeadersEvidence{}, "tendermint/ConflictingHeadersEvidence", nil)
-	cdc.RegisterConcrete(&PhantomValidatorEvidence{}, "tendermint/PhantomValidatorEvidence", nil)
-	cdc.RegisterConcrete(&LunaticValidatorEvidence{}, "tendermint/LunaticValidatorEvidence", nil)
-	cdc.RegisterConcrete(&PotentialAmnesiaEvidence{}, "tendermint/PotentialAmnesiaEvidence", nil)
-	cdc.RegisterConcrete(&AmnesiaEvidence{}, "tendermint/AmnesiaEvidence", nil)
-}
-
 func init() {
 	tmjson.RegisterType(&DuplicateVoteEvidence{}, "tendermint/DuplicateVoteEvidence")
 	tmjson.RegisterType(&ConflictingHeadersEvidence{}, "tendermint/ConflictingHeadersEvidence")
@@ -351,11 +268,6 @@ func init() {
 	tmjson.RegisterType(&AmnesiaEvidence{}, "tendermint/AmnesiaEvidence")
 }
 
-func RegisterMockEvidences(cdc *amino.Codec) {
-	cdc.RegisterConcrete(MockEvidence{}, "tendermint/MockEvidence", nil)
-	cdc.RegisterConcrete(MockRandomEvidence{}, "tendermint/MockRandomEvidence", nil)
-}
-
 //-------------------------------------------
 
 // DuplicateVoteEvidence contains evidence a validator signed two conflicting
@@ -410,12 +322,24 @@ func (dve *DuplicateVoteEvidence) Address() []byte {
 
 // Hash returns the hash of the evidence.
 func (dve *DuplicateVoteEvidence) Bytes() []byte {
-	return cdcEncode(dve)
+	pbe := dve.ToProto()
+	bz, err := pbe.Marshal()
+	if err != nil {
+		panic(err)
+	}
+
+	return bz
 }
 
 // Hash returns the hash of the evidence.
 func (dve *DuplicateVoteEvidence) Hash() []byte {
-	return tmhash.Sum(cdcEncode(dve))
+	pbe := dve.ToProto()
+	bz, err := pbe.Marshal()
+	if err != nil {
+		panic(err)
+	}
+
+	return tmhash.Sum(bz)
 }
 
 // Verify returns an error if the two votes aren't conflicting.
@@ -481,11 +405,24 @@ func (dve *DuplicateVoteEvidence) Equal(ev Evidence) bool {
 	if _, ok := ev.(*DuplicateVoteEvidence); !ok {
 		return false
 	}
+	pbdev := dve.ToProto()
+	bz, err := pbdev.Marshal()
+	if err != nil {
+		panic(err)
+	}
+
+	var evbz []byte
+	if ev, ok := ev.(*DuplicateVoteEvidence); ok {
+		evpb := ev.ToProto()
+		evbz, err = evpb.Marshal()
+		if err != nil {
+			panic(err)
+		}
+	}
 
 	// just check their hashes
-	dveHash := tmhash.Sum(cdcEncode(dve))
-	evHash := tmhash.Sum(cdcEncode(ev))
-	fmt.Println(dveHash, evHash)
+	dveHash := tmhash.Sum(bz)
+	evHash := tmhash.Sum(evbz)
 	return bytes.Equal(dveHash, evHash)
 }
 
@@ -507,6 +444,39 @@ func (dve *DuplicateVoteEvidence) ValidateBasic() error {
 	return nil
 }
 
+func (dve DuplicateVoteEvidence) ToProto() tmproto.DuplicateVoteEvidence {
+	voteB := dve.VoteB.ToProto()
+	voteA := dve.VoteA.ToProto()
+	tp := tmproto.DuplicateVoteEvidence{
+		VoteA: voteA,
+		VoteB: voteB,
+	}
+	return tp
+}
+
+func DuplicateVoteEvidenceFromProto(pb *tmproto.DuplicateVoteEvidence) (*DuplicateVoteEvidence, error) {
+	if pb == nil {
+		return nil, errors.New("nil duplicate vote evidence")
+	}
+
+	vA, err := VoteFromProto(pb.VoteA)
+	if err != nil {
+		return nil, err
+	}
+
+	vB, err := VoteFromProto(pb.VoteB)
+	if err != nil {
+		return nil, err
+	}
+
+	dve := new(DuplicateVoteEvidence)
+
+	dve.VoteA = vA
+	dve.VoteB = vB
+
+	return dve, dve.ValidateBasic()
+}
+
 //-------------------------------------------
 
 // EvidenceList is a list of Evidence. Evidences is not a word.
@@ -715,7 +685,14 @@ func (ev ConflictingHeadersEvidence) Address() []byte {
 }
 
 func (ev ConflictingHeadersEvidence) Bytes() []byte {
-	return cdcEncode(ev)
+	pbe := ev.ToProto()
+
+	bz, err := pbe.Marshal()
+	if err != nil {
+		panic(err)
+	}
+
+	return bz
 }
 
 func (ev ConflictingHeadersEvidence) Hash() []byte {
@@ -811,6 +788,38 @@ func (ev ConflictingHeadersEvidence) String() string {
 		ev.H2.Height, ev.H2.Hash())
 }
 
+func (ev ConflictingHeadersEvidence) ToProto() tmproto.ConflictingHeadersEvidence {
+	pbh1 := ev.H1.ToProto()
+	pbh2 := ev.H2.ToProto()
+
+	tp := tmproto.ConflictingHeadersEvidence{
+		H1: pbh1,
+		H2: pbh2,
+	}
+	return tp
+}
+
+func ConflictingHeadersEvidenceFromProto(pb *tmproto.ConflictingHeadersEvidence) (ConflictingHeadersEvidence, error) {
+	if pb == nil {
+		return ConflictingHeadersEvidence{}, errors.New("nil ConflictingHeadersEvidence")
+	}
+	h1, err := SignedHeaderFromProto(pb.H1)
+	if err != nil {
+		return ConflictingHeadersEvidence{}, fmt.Errorf("from proto err: %w", err)
+	}
+	h2, err := SignedHeaderFromProto(pb.H2)
+	if err != nil {
+		return ConflictingHeadersEvidence{}, fmt.Errorf("from proto err: %w", err)
+	}
+
+	tp := ConflictingHeadersEvidence{
+		H1: h1,
+		H2: h2,
+	}
+
+	return tp, tp.ValidateBasic()
+}
+
 //-------------------------------------------
 
 type PhantomValidatorEvidence struct {
@@ -833,11 +842,24 @@ func (e PhantomValidatorEvidence) Address() []byte {
 }
 
 func (e PhantomValidatorEvidence) Hash() []byte {
-	return tmhash.Sum(cdcEncode(e))
+	pbe := e.ToProto()
+
+	bz, err := pbe.Marshal()
+	if err != nil {
+		panic(err)
+	}
+	return tmhash.Sum(bz)
 }
 
 func (e PhantomValidatorEvidence) Bytes() []byte {
-	return cdcEncode(e)
+	pbe := e.ToProto()
+
+	bz, err := pbe.Marshal()
+	if err != nil {
+		panic(err)
+	}
+
+	return bz
 }
 
 func (e PhantomValidatorEvidence) Verify(chainID string, pubKey crypto.PubKey) error {
@@ -889,6 +911,35 @@ func (e PhantomValidatorEvidence) String() string {
 		e.Vote.ValidatorAddress, e.Vote.Height)
 }
 
+func (e PhantomValidatorEvidence) ToProto() tmproto.PhantomValidatorEvidence {
+	vpb := e.Vote.ToProto()
+
+	tp := tmproto.PhantomValidatorEvidence{
+		Vote:                        vpb,
+		LastHeightValidatorWasInSet: e.LastHeightValidatorWasInSet,
+	}
+
+	return tp
+}
+
+func PhantomValidatorEvidenceFromProto(pb *tmproto.PhantomValidatorEvidence) (PhantomValidatorEvidence, error) {
+	if pb == nil {
+		return PhantomValidatorEvidence{}, errors.New("nil PhantomValidatorEvidence")
+	}
+
+	vpb, err := VoteFromProto(pb.Vote)
+	if err != nil {
+		return PhantomValidatorEvidence{}, err
+	}
+
+	tp := PhantomValidatorEvidence{
+		Vote:                        vpb,
+		LastHeightValidatorWasInSet: pb.LastHeightValidatorWasInSet,
+	}
+
+	return tp, tp.ValidateBasic()
+}
+
 //-------------------------------------------
 
 type LunaticValidatorEvidence struct {
@@ -919,7 +970,14 @@ func (e LunaticValidatorEvidence) Hash() []byte {
 }
 
 func (e LunaticValidatorEvidence) Bytes() []byte {
-	return cdcEncode(e)
+	pbe := e.ToProto()
+
+	bz, err := pbe.Marshal()
+	if err != nil {
+		panic(err)
+	}
+
+	return bz
 }
 
 func (e LunaticValidatorEvidence) Verify(chainID string, pubKey crypto.PubKey) error {
@@ -1030,6 +1088,43 @@ func (e LunaticValidatorEvidence) VerifyHeader(committedHeader *Header) error {
 	return nil
 }
 
+func (e LunaticValidatorEvidence) ToProto() tmproto.LunaticValidatorEvidence {
+	h := e.Header.ToProto()
+	v := e.Vote.ToProto()
+
+	tp := tmproto.LunaticValidatorEvidence{
+		Header:             h,
+		Vote:               v,
+		InvalidHeaderField: e.InvalidHeaderField,
+	}
+
+	return tp
+}
+
+func LunaticValidatorEvidenceFromProto(pb *tmproto.LunaticValidatorEvidence) (*LunaticValidatorEvidence, error) {
+	if pb == nil {
+		return nil, errors.New("nil LunaticValidatorEvidence")
+	}
+
+	h, err := HeaderFromProto(pb.GetHeader())
+	if err != nil {
+		return nil, err
+	}
+
+	v, err := VoteFromProto(pb.GetVote())
+	if err != nil {
+		return nil, err
+	}
+
+	tp := LunaticValidatorEvidence{
+		Header:             &h,
+		Vote:               v,
+		InvalidHeaderField: pb.InvalidHeaderField,
+	}
+
+	return &tp, tp.ValidateBasic()
+}
+
 //-------------------------------------------
 
 // PotentialAmnesiaEvidence is constructed when a validator votes on two different blocks at different rounds
@@ -1059,11 +1154,25 @@ func (e PotentialAmnesiaEvidence) Address() []byte {
 }
 
 func (e PotentialAmnesiaEvidence) Hash() []byte {
-	return tmhash.Sum(cdcEncode(e))
+	pbe := e.ToProto()
+
+	bz, err := pbe.Marshal()
+	if err != nil {
+		panic(err)
+	}
+
+	return tmhash.Sum(bz)
 }
 
 func (e PotentialAmnesiaEvidence) Bytes() []byte {
-	return cdcEncode(e)
+	pbe := e.ToProto()
+
+	bz, err := pbe.Marshal()
+	if err != nil {
+		panic(err)
+	}
+
+	return bz
 }
 
 func (e PotentialAmnesiaEvidence) Verify(chainID string, pubKey crypto.PubKey) error {
@@ -1173,6 +1282,21 @@ func (e PotentialAmnesiaEvidence) Primed(trialPeriod, currentHeight int64) bool
 	return false
 }
 
+func (e PotentialAmnesiaEvidence) ToProto() tmproto.PotentialAmnesiaEvidence {
+	voteB := e.VoteB.ToProto()
+	voteA := e.VoteA.ToProto()
+
+	tp := tmproto.PotentialAmnesiaEvidence{
+		VoteA:       voteA,
+		VoteB:       voteB,
+		HeightStamp: e.HeightStamp,
+	}
+
+	return tp
+}
+
+// ------------------
+
 // ProofOfLockChange (POLC) proves that a node followed the consensus protocol and voted for a precommit in two
 // different rounds because the node received a majority of votes for a different block in the latter round. In cases of
 // amnesia evidence, a suspected node will need ProofOfLockChange to prove that the node did not break protocol.
@@ -1522,15 +1646,7 @@ func PotentialAmnesiaEvidenceFromProto(pb *tmproto.PotentialAmnesiaEvidence) (*P
 }
 
 func AmnesiaEvidenceToProto(evi AmnesiaEvidence) (*tmproto.Evidence, error) {
-	ev, err := EvidenceToProto(evi.PotentialAmnesiaEvidence)
-	if err != nil {
-		return nil, err
-	}
-
-	paepb := ev.GetPotentialAmnesiaEvidence()
-	if paepb == nil {
-		return nil, errors.New("provided evidence is not potential amnesia evidence")
-	}
+	paepb := evi.PotentialAmnesiaEvidence.ToProto()
 
 	polc, err := evi.Polc.ToProto()
 	if err != nil {
@@ -1540,14 +1656,35 @@ func AmnesiaEvidenceToProto(evi AmnesiaEvidence) (*tmproto.Evidence, error) {
 	tp := &tmproto.Evidence{
 		Sum: &tmproto.Evidence_AmnesiaEvidence{
 			AmnesiaEvidence: &tmproto.AmnesiaEvidence{
-				PotentialAmnesiaEvidence: paepb,
+				PotentialAmnesiaEvidence: &paepb,
 				Polc:                     polc,
 			},
 		},
 	}
 
 	return tp, nil
+}
+
+func AmensiaEvidenceFromProto(pb *tmproto.AmnesiaEvidence) (AmnesiaEvidence, error) {
+	if pb == nil {
+		return AmnesiaEvidence{}, errors.New("nil duplicate vote evidence")
+	}
+
+	pae, err := PotentialAmnesiaEvidenceFromProto(pb.PotentialAmnesiaEvidence)
+	if err != nil {
+		return AmnesiaEvidence{}, err
+	}
+	polc, err := ProofOfLockChangeFromProto(pb.Polc)
+	if err != nil {
+		return AmnesiaEvidence{}, err
+	}
+
+	tp := AmnesiaEvidence{
+		PotentialAmnesiaEvidence: *pae,
+		Polc:                     *polc,
+	}
 
+	return tp, tp.ValidateBasic()
 }
 
 //-----------------------------------------------------------------

types/evidence_test.go

@@ -135,7 +135,9 @@ func TestMaxEvidenceBytes(t *testing.T) {
 	}
 
 	for _, tt := range testCases {
-		bz, err := cdc.MarshalBinaryLengthPrefixed(tt.evidence)
+		pb, err := EvidenceToProto(tt.evidence)
+		require.NoError(t, err, tt.testName)
+		bz, err := pb.Marshal()
 		require.NoError(t, err, tt.testName)
 
 		assert.LessOrEqual(t, int64(len(bz)), MaxEvidenceBytes, tt.testName)
@@ -664,6 +666,11 @@ func TestEvidenceProto(t *testing.T) {
 		{"&PotentialAmnesiaEvidence nil VoteB", &PotentialAmnesiaEvidence{VoteA: v, VoteB: nil}, false, true},
 		{"&PotentialAmnesiaEvidence nil VoteA", &PotentialAmnesiaEvidence{VoteA: nil, VoteB: v2}, false, true},
 		{"&PotentialAmnesiaEvidence success", &PotentialAmnesiaEvidence{VoteA: v2, VoteB: v}, false, false},
+		{"&PhantomValidatorEvidence empty fail", &PhantomValidatorEvidence{}, false, true},
+		{"&PhantomValidatorEvidence nil LastHeightValidatorWasInSet", &PhantomValidatorEvidence{Vote: v}, false, true},
+		{"&PhantomValidatorEvidence nil Vote", &PhantomValidatorEvidence{LastHeightValidatorWasInSet: 2}, false, true},
+		{"PhantomValidatorEvidence success", PhantomValidatorEvidence{Vote: v2, LastHeightValidatorWasInSet: 2},
+			false, false},
 	}
 	for _, tt := range tests {
 		tt := tt

types/params.go

@@ -128,7 +128,7 @@ func ValidateConsensusParams(params tmproto.ConsensusParams) error {
 	// Check if keyType is a known ABCIPubKeyType
 	for i := 0; i < len(params.Validator.PubKeyTypes); i++ {
 		keyType := params.Validator.PubKeyTypes[i]
-		if _, ok := ABCIPubKeyTypesToAminoNames[keyType]; !ok {
+		if _, ok := ABCIPubKeyTypesToNames[keyType]; !ok {
 			return fmt.Errorf("params.Validator.PubKeyTypes[%d], %s, is an unknown pubkey type",
 				i, keyType)
 		}

types/protobuf.go

@@ -30,10 +30,10 @@ const (
 
 // TODO: Make non-global by allowing for registration of more pubkey types
 
-var ABCIPubKeyTypesToAminoNames = map[string]string{
-	ABCIPubKeyTypeEd25519:   ed25519.PubKeyAminoName,
-	ABCIPubKeyTypeSr25519:   sr25519.PubKeyAminoName,
-	ABCIPubKeyTypeSecp256k1: secp256k1.PubKeyAminoName,
+var ABCIPubKeyTypesToNames = map[string]string{
+	ABCIPubKeyTypeEd25519:   ed25519.PubKeyName,
+	ABCIPubKeyTypeSr25519:   sr25519.PubKeyName,
+	ABCIPubKeyTypeSecp256k1: secp256k1.PubKeyName,
 }
 
 //-------------------------------------------------------

types/protobuf_test.go

@@ -4,17 +4,13 @@ import (
 	"testing"
 	"time"
 
-	"github.com/gogo/protobuf/proto"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	amino "github.com/tendermint/go-amino"
-
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
-	"github.com/tendermint/tendermint/proto/version"
 )
 
 func TestABCIPubKey(t *testing.T) {
@@ -65,63 +61,6 @@ func TestABCIConsensusParams(t *testing.T) {
 	assert.Equal(t, *cp, cp2)
 }
 
-func newHeader(
-	height int64, commitHash, dataHash, evidenceHash []byte,
-) *Header {
-	return &Header{
-		Height:         height,
-		LastCommitHash: commitHash,
-		DataHash:       dataHash,
-		EvidenceHash:   evidenceHash,
-	}
-}
-
-func TestABCIHeader(t *testing.T) {
-	// build a full header
-	var height int64 = 5
-	header := newHeader(height, []byte("lastCommitHash"), []byte("dataHash"), []byte("evidenceHash"))
-	protocolVersion := version.Consensus{Block: 7, App: 8}
-	timestamp := time.Now()
-	lastBlockID := BlockID{
-		Hash: []byte("hash"),
-		PartsHeader: PartSetHeader{
-			Total: 10,
-			Hash:  []byte("hash"),
-		},
-	}
-	header.Populate(
-		protocolVersion, "chainID", timestamp, lastBlockID,
-		[]byte("valHash"), []byte("nextValHash"),
-		[]byte("consHash"), []byte("appHash"), []byte("lastResultsHash"),
-		[]byte("proposerAddress"),
-	)
-
-	cdc := amino.NewCodec()
-	headerBz := cdc.MustMarshalBinaryBare(header)
-
-	pbHeader := header.ToProto()
-	pbHeaderBz, err := proto.Marshal(pbHeader)
-	assert.NoError(t, err)
-
-	// assert some fields match
-	assert.EqualValues(t, protocolVersion.Block, pbHeader.Version.Block)
-	assert.EqualValues(t, protocolVersion.App, pbHeader.Version.App)
-	assert.EqualValues(t, "chainID", pbHeader.ChainID)
-	assert.EqualValues(t, height, pbHeader.Height)
-	assert.EqualValues(t, timestamp, pbHeader.Time)
-	assert.EqualValues(t, lastBlockID.Hash, pbHeader.LastBlockId.Hash)
-	assert.EqualValues(t, []byte("lastCommitHash"), pbHeader.LastCommitHash)
-	assert.Equal(t, []byte("proposerAddress"), pbHeader.ProposerAddress)
-
-	// assert the encodings match
-	// NOTE: they don't yet because Amino encodes
-	// int64 as zig-zag and we're using non-zigzag in the protobuf.
-	// See https://github.com/tendermint/tendermint/issues/2682
-	_, _ = headerBz, pbHeaderBz
-	// assert.EqualValues(t, headerBz, pbHeaderBz)
-
-}
-
 func TestABCIEvidence(t *testing.T) {
 	val := NewMockPV()
 	blockID := makeBlockID([]byte("blockhash"), 1000, []byte("partshash"))

types/tx.go

@@ -8,6 +8,7 @@ import (
 	"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/types"
 )
 
 // Tx is an arbitrary byte array.
@@ -108,3 +109,31 @@ func (tp TxProof) Validate(dataHash []byte) error {
 	}
 	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
+}

types/tx_test.go

@@ -5,9 +5,11 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 	ctest "github.com/tendermint/tendermint/libs/test"
+	tmproto "github.com/tendermint/tendermint/proto/types"
 )
 
 func makeTxs(cnt, size int) Txs {
@@ -77,10 +79,18 @@ func TestValidTxProof(t *testing.T) {
 			assert.NotNil(t, proof.Validate([]byte("foobar")), "%d: %d", h, i)
 
 			// read-write must also work
-			var p2 TxProof
-			bin, err := cdc.MarshalBinaryLengthPrefixed(proof)
-			assert.Nil(t, err)
-			err = cdc.UnmarshalBinaryLengthPrefixed(bin, &p2)
+			var (
+				p2  TxProof
+				pb2 tmproto.TxProof
+			)
+			pbProof := proof.ToProto()
+			bin, err := pbProof.Marshal()
+			require.NoError(t, err)
+
+			err = pb2.Unmarshal(bin)
+			require.NoError(t, err)
+
+			p2, err = TxProofFromProto(pb2)
 			if assert.Nil(t, err, "%d: %d: %+v", h, i, err) {
 				assert.Nil(t, p2.Validate(root), "%d: %d", h, i)
 			}
@@ -104,8 +114,9 @@ func testTxProofUnchangable(t *testing.T) {
 
 	// make sure it is valid to start with
 	assert.Nil(t, proof.Validate(root))
-	bin, err := cdc.MarshalBinaryLengthPrefixed(proof)
-	assert.Nil(t, err)
+	pbProof := proof.ToProto()
+	bin, err := pbProof.Marshal()
+	require.NoError(t, err)
 
 	// try mutating the data and make sure nothing breaks
 	for j := 0; j < 500; j++ {
@@ -118,16 +129,23 @@ func testTxProofUnchangable(t *testing.T) {
 
 // This makes sure that the proof doesn't deserialize into something valid.
 func assertBadProof(t *testing.T, root []byte, bad []byte, good TxProof) {
-	var proof TxProof
-	err := cdc.UnmarshalBinaryLengthPrefixed(bad, &proof)
+
+	var (
+		proof   TxProof
+		pbProof tmproto.TxProof
+	)
+	err := pbProof.Unmarshal(bad)
 	if err == nil {
-		err = proof.Validate(root)
+		proof, err = TxProofFromProto(pbProof)
 		if err == nil {
-			// XXX Fix simple merkle proofs so the following is *not* OK.
-			// This can happen if we have a slightly different total (where the
-			// path ends up the same). If it is something else, we have a real
-			// problem.
-			assert.NotEqual(t, proof.Proof.Total, good.Proof.Total, "bad: %#v\ngood: %#v", proof, good)
+			err = proof.Validate(root)
+			if err == nil {
+				// XXX Fix simple merkle proofs so the following is *not* OK.
+				// This can happen if we have a slightly different total (where the
+				// path ends up the same). If it is something else, we have a real
+				// problem.
+				assert.NotEqual(t, proof.Proof.Total, good.Proof.Total, "bad: %#v\ngood: %#v", proof, good)
+			}
 		}
 	}
 }

types/validator.go

@@ -107,13 +107,21 @@ func ValidatorListString(vals []*Validator) string {
 // as its redundant with the pubkey. This also excludes ProposerPriority
 // which changes every round.
 func (v *Validator) Bytes() []byte {
-	return cdcEncode(struct {
-		PubKey      crypto.PubKey
-		VotingPower int64
-	}{
-		v.PubKey,
-		v.VotingPower,
-	})
+	pk, err := ce.PubKeyToProto(v.PubKey)
+	if err != nil {
+		panic(err)
+	}
+
+	pbv := tmproto.SimpleValidator{
+		PubKey:      &pk,
+		VotingPower: v.VotingPower,
+	}
+
+	bz, err := pbv.Marshal()
+	if err != nil {
+		panic(err)
+	}
+	return bz
 }
 
 // ToProto converts Valiator to protobuf

types/validator_set_test.go

@@ -301,14 +301,17 @@ func TestProposerSelection2(t *testing.T) {
 
 func TestProposerSelection3(t *testing.T) {
 	vset := NewValidatorSet([]*Validator{
-		newValidator([]byte("a"), 1),
-		newValidator([]byte("b"), 1),
-		newValidator([]byte("c"), 1),
-		newValidator([]byte("d"), 1),
+		newValidator([]byte("avalidator_address12"), 1),
+		newValidator([]byte("bvalidator_address12"), 1),
+		newValidator([]byte("cvalidator_address12"), 1),
+		newValidator([]byte("dvalidator_address12"), 1),
 	})
 
 	proposerOrder := make([]*Validator, 4)
 	for i := 0; i < 4; i++ {
+		// need to give all validators to have keys
+		pk := ed25519.GenPrivKey().PubKey()
+		vset.Validators[i].PubKey = pk
 		proposerOrder[i] = vset.GetProposer()
 		vset.IncrementProposerPriority(1)
 	}
@@ -329,7 +332,7 @@ func TestProposerSelection3(t *testing.T) {
 
 		// serialize, deserialize, check proposer
 		b := vset.toBytes()
-		vset.fromBytes(b)
+		vset = vset.fromBytes(b)
 
 		computed := vset.GetProposer() // findGetProposer()
 		if i != 0 {
@@ -388,19 +391,33 @@ func randValidatorSet(numValidators int) *ValidatorSet {
 }
 
 func (vals *ValidatorSet) toBytes() []byte {
-	bz, err := cdc.MarshalBinaryLengthPrefixed(vals)
+	pbvs, err := vals.ToProto()
 	if err != nil {
 		panic(err)
 	}
+
+	bz, err := pbvs.Marshal()
+	if err != nil {
+		panic(err)
+	}
+
 	return bz
 }
 
-func (vals *ValidatorSet) fromBytes(b []byte) {
-	err := cdc.UnmarshalBinaryLengthPrefixed(b, &vals)
+func (vals *ValidatorSet) fromBytes(b []byte) *ValidatorSet {
+	pbvs := new(tmproto.ValidatorSet)
+	err := pbvs.Unmarshal(b)
 	if err != nil {
 		// DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED
 		panic(err)
 	}
+
+	vs, err := ValidatorSetFromProto(pbvs)
+	if err != nil {
+		panic(err)
+	}
+
+	return vs
 }
 
 //-------------------------------------------------------------------