remove Must* proof and hash functions

types/tx.go

@@ -62,24 +62,6 @@ func (txs Txs) IndexByHash(hash []byte) int {
 	return -1
 }
 
-// Proof returns a simple merkle proof for this node.
-// Panics if i < 0 or i >= len(txs)
-// TODO: optimize this!
-func (txs Txs) Proof(i int) TxProof {
-	l := len(txs)
-	bzs := make([][]byte, l)
-	for i := 0; i < l; i++ {
-		bzs[i] = txs[i].Hash()
-	}
-	root, proofs := merkle.ProofsFromByteSlices(bzs)
-
-	return TxProof{
-		RootHash: root,
-		Data:     txs[i],
-		Proof:    *proofs[i],
-	}
-}
-
 // ToSliceOfBytes converts a Txs to slice of byte slices.
 //
 // NOTE: This method should become obsolete once Txs is switched to [][]byte.

types/tx_test.go

@@ -1,16 +1,12 @@
 package types
 
 import (
-	"bytes"
 	mrand "math/rand"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 
-	ctest "github.com/tendermint/tendermint/internal/libs/test"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
-	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 )
 
 func makeTxs(cnt, size int) Txs {
@@ -51,102 +47,3 @@ func TestTxIndexByHash(t *testing.T) {
 		assert.Equal(t, -1, txs.IndexByHash(Tx("foodnwkf").Hash()))
 	}
 }
-
-func TestValidTxProof(t *testing.T) {
-	cases := []struct {
-		txs Txs
-	}{
-		{Txs{{1, 4, 34, 87, 163, 1}}},
-		{Txs{{5, 56, 165, 2}, {4, 77}}},
-		{Txs{Tx("foo"), Tx("bar"), Tx("baz")}},
-		{makeTxs(20, 5)},
-		{makeTxs(7, 81)},
-		{makeTxs(61, 15)},
-	}
-
-	for h, tc := range cases {
-		txs := tc.txs
-		root := txs.Hash()
-		// make sure valid proof for every tx
-		for i := range txs {
-			tx := []byte(txs[i])
-			proof := txs.Proof(i)
-			assert.EqualValues(t, i, proof.Proof.Index, "%d: %d", h, i)
-			assert.EqualValues(t, len(txs), proof.Proof.Total, "%d: %d", h, i)
-			assert.EqualValues(t, root, proof.RootHash, "%d: %d", h, i)
-			assert.EqualValues(t, tx, proof.Data, "%d: %d", h, i)
-			assert.EqualValues(t, txs[i].Hash(), proof.Leaf(), "%d: %d", h, i)
-			assert.Nil(t, proof.Validate(root), "%d: %d", h, i)
-			assert.NotNil(t, proof.Validate([]byte("foobar")), "%d: %d", h, i)
-
-			// read-write must also work
-			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.NoError(t, err, "%d: %d: %+v", h, i, err) {
-				assert.Nil(t, p2.Validate(root), "%d: %d", h, i)
-			}
-		}
-	}
-}
-
-func TestTxProofUnchangable(t *testing.T) {
-	// run the other test a bunch...
-	for i := 0; i < 40; i++ {
-		testTxProofUnchangable(t)
-	}
-}
-
-func testTxProofUnchangable(t *testing.T) {
-	// make some proof
-	txs := makeTxs(randInt(2, 100), randInt(16, 128))
-	root := txs.Hash()
-	i := randInt(0, len(txs)-1)
-	proof := txs.Proof(i)
-
-	// make sure it is valid to start with
-	assert.Nil(t, proof.Validate(root))
-	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++ {
-		bad := ctest.MutateByteSlice(bin)
-		if !bytes.Equal(bad, bin) {
-			assertBadProof(t, root, bad, proof)
-		}
-	}
-}
-
-// 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
-		pbProof tmproto.TxProof
-	)
-	err := pbProof.Unmarshal(bad)
-	if err == nil {
-		proof, err = TxProofFromProto(pbProof)
-		if err == nil {
-			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)
-			}
-		}
-	}
-}