From b8b50733f0a88211034b96181d5dd64c0a8f87ed Mon Sep 17 00:00:00 2001 From: Marko Date: Mon, 15 Jun 2020 13:17:12 +0200 Subject: [PATCH] encoding: remove codecs (#4996) ## Description This pr removes amino from tendermint. Closes: #4278 --- consensus/types/round_state_test.go | 93 ----------- crypto/encoding/amino/amino.go | 82 ---------- crypto/encoding/amino/encode_test.go | 224 --------------------------- crypto/merkle/proof_test.go | 1 + go.mod | 1 - go.sum | 2 - node/codec.go | 13 -- state/main_test.go | 10 -- 8 files changed, 1 insertion(+), 425 deletions(-) delete mode 100644 consensus/types/round_state_test.go delete mode 100644 crypto/encoding/amino/amino.go delete mode 100644 crypto/encoding/amino/encode_test.go delete mode 100644 node/codec.go delete mode 100644 state/main_test.go diff --git a/consensus/types/round_state_test.go b/consensus/types/round_state_test.go deleted file mode 100644 index 749546c0d..000000000 --- a/consensus/types/round_state_test.go +++ /dev/null @@ -1,93 +0,0 @@ -package types - -import ( - "testing" - - amino "github.com/tendermint/go-amino" - - "github.com/tendermint/tendermint/crypto/ed25519" - "github.com/tendermint/tendermint/crypto/tmhash" - tmrand "github.com/tendermint/tendermint/libs/rand" - "github.com/tendermint/tendermint/types" - tmtime "github.com/tendermint/tendermint/types/time" -) - -func BenchmarkRoundStateDeepCopy(b *testing.B) { - b.StopTimer() - - // Random validators - nval, ntxs := 100, 100 - vset, _ := types.RandValidatorSet(nval, 1) - commitSigs := make([]types.CommitSig, nval) - blockID := types.BlockID{ - Hash: tmrand.Bytes(tmhash.Size), - PartsHeader: types.PartSetHeader{ - Hash: tmrand.Bytes(tmhash.Size), - Total: 1000, - }, - } - sig := make([]byte, ed25519.SignatureSize) - for i := 0; i < nval; i++ { - commitSigs[i] = (&types.Vote{ - ValidatorAddress: types.Address(tmrand.Bytes(20)), - Timestamp: tmtime.Now(), - BlockID: blockID, - Signature: sig, - }).CommitSig() - } - txs := make([]types.Tx, ntxs) - for i := 0; i < ntxs; i++ { - txs[i] = tmrand.Bytes(100) - } - // Random block - block := &types.Block{ - Header: types.Header{ - ChainID: tmrand.Str(12), - Time: tmtime.Now(), - LastBlockID: blockID, - LastCommitHash: tmrand.Bytes(20), - DataHash: tmrand.Bytes(20), - ValidatorsHash: tmrand.Bytes(20), - ConsensusHash: tmrand.Bytes(20), - AppHash: tmrand.Bytes(20), - LastResultsHash: tmrand.Bytes(20), - EvidenceHash: tmrand.Bytes(20), - }, - Data: types.Data{ - Txs: txs, - }, - Evidence: types.EvidenceData{}, - LastCommit: types.NewCommit(1, 0, blockID, commitSigs), - } - parts := block.MakePartSet(4096) - // Random Proposal - proposal := &types.Proposal{ - Timestamp: tmtime.Now(), - BlockID: blockID, - Signature: sig, - } - // Random HeightVoteSet - // TODO: hvs := - - rs := &RoundState{ - StartTime: tmtime.Now(), - CommitTime: tmtime.Now(), - Validators: vset, - Proposal: proposal, - ProposalBlock: block, - ProposalBlockParts: parts, - LockedBlock: block, - LockedBlockParts: parts, - ValidBlock: block, - ValidBlockParts: parts, - Votes: nil, // TODO - LastCommit: nil, // TODO - LastValidators: vset, - } - - b.StartTimer() - - for i := 0; i < b.N; i++ { - amino.DeepCopy(rs) - } -} diff --git a/crypto/encoding/amino/amino.go b/crypto/encoding/amino/amino.go deleted file mode 100644 index a0e71cdc4..000000000 --- a/crypto/encoding/amino/amino.go +++ /dev/null @@ -1,82 +0,0 @@ -package cryptoamino - -import ( - "reflect" - - amino "github.com/tendermint/go-amino" - - "github.com/tendermint/tendermint/crypto" - "github.com/tendermint/tendermint/crypto/ed25519" - "github.com/tendermint/tendermint/crypto/secp256k1" - "github.com/tendermint/tendermint/crypto/sr25519" -) - -var cdc = amino.NewCodec() - -// nameTable is used to map public key concrete types back -// to their registered amino names. This should eventually be handled -// by amino. Example usage: -// nameTable[reflect.TypeOf(ed25519.PubKey{})] = ed25519.PubKeyAminoName -var nameTable = make(map[reflect.Type]string, 3) - -func init() { - // NOTE: It's important that there be no conflicts here, - // as that would change the canonical representations, - // and therefore change the address. - // TODO: Remove above note when - // https://github.com/tendermint/go-amino/issues/9 - // is resolved - RegisterAmino(cdc) - - // 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.PubKeyName - nameTable[reflect.TypeOf(sr25519.PubKey{})] = sr25519.PubKeyName - nameTable[reflect.TypeOf(secp256k1.PubKey{})] = secp256k1.PubKeyName -} - -// PubkeyAminoName returns the amino route of a pubkey -// cdc is currently passed in, as eventually this will not be using -// a package level codec. -func PubkeyAminoName(cdc *amino.Codec, key crypto.PubKey) (string, bool) { - route, found := nameTable[reflect.TypeOf(key)] - return route, found -} - -// RegisterAmino registers all crypto related types in the given (amino) codec. -func RegisterAmino(cdc *amino.Codec) { - // These are all written here instead of - cdc.RegisterInterface((*crypto.PubKey)(nil), nil) - cdc.RegisterConcrete(ed25519.PubKey{}, - ed25519.PubKeyName, nil) - cdc.RegisterConcrete(sr25519.PubKey{}, - sr25519.PubKeyName, nil) - cdc.RegisterConcrete(secp256k1.PubKey{}, - secp256k1.PubKeyName, nil) - - cdc.RegisterInterface((*crypto.PrivKey)(nil), nil) - cdc.RegisterConcrete(ed25519.PrivKey{}, - ed25519.PrivKeyName, nil) - cdc.RegisterConcrete(sr25519.PrivKey{}, - sr25519.PrivKeyName, nil) - cdc.RegisterConcrete(secp256k1.PrivKey{}, - secp256k1.PrivKeyName, nil) -} - -// RegisterKeyType registers an external key type to allow decoding it from bytes -func RegisterKeyType(o interface{}, name string) { - cdc.RegisterConcrete(o, name, nil) - nameTable[reflect.TypeOf(o)] = name -} - -// PrivKeyFromBytes unmarshals private key bytes and returns a PrivKey -func PrivKeyFromBytes(privKeyBytes []byte) (privKey crypto.PrivKey, err error) { - err = cdc.UnmarshalBinaryBare(privKeyBytes, &privKey) - return -} - -// PubKeyFromBytes unmarshals public key bytes and returns a PubKey -func PubKeyFromBytes(pubKeyBytes []byte) (pubKey crypto.PubKey, err error) { - err = cdc.UnmarshalBinaryBare(pubKeyBytes, &pubKey) - return -} diff --git a/crypto/encoding/amino/encode_test.go b/crypto/encoding/amino/encode_test.go deleted file mode 100644 index 511c47e9d..000000000 --- a/crypto/encoding/amino/encode_test.go +++ /dev/null @@ -1,224 +0,0 @@ -package cryptoamino - -import ( - "reflect" - "testing" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" - - amino "github.com/tendermint/go-amino" - - "github.com/tendermint/tendermint/crypto" - "github.com/tendermint/tendermint/crypto/ed25519" - "github.com/tendermint/tendermint/crypto/secp256k1" - "github.com/tendermint/tendermint/crypto/sr25519" - tmjson "github.com/tendermint/tendermint/libs/json" -) - -type AminoMarshal interface { - AminoMarshal() ([]byte, error) - AminoUnmarshal([]byte) error -} - -func checkAminoBinary(t *testing.T, src, dst interface{}, size int) { - // Marshal to binary bytes. - bz, err := cdc.MarshalBinaryBare(src) - require.Nil(t, err, "%+v", err) - if byterSrc, ok := src.(AminoMarshal); ok { - // Make sure this is compatible with current (Bytes()) encoding. - bza, err := byterSrc.AminoMarshal() - assert.NoError(t, err) - assert.Equal(t, bza, bz, "Amino binary vs Bytes() mismatch") - } - // Make sure we have the expected length. - assert.Equal(t, size, len(bz), "Amino binary size mismatch") - - // Unmarshal. - err = cdc.UnmarshalBinaryBare(bz, dst) - require.Nil(t, err, "%+v", err) -} - -func checkJSON(t *testing.T, src interface{}, dst interface{}, isNil bool) { - // Marshal to JSON bytes. - js, err := tmjson.Marshal(src) - require.Nil(t, err, "%+v", err) - if isNil { - assert.Equal(t, string(js), `null`) - } else { - assert.Contains(t, string(js), `"type":`) - assert.Contains(t, string(js), `"value":`) - } - // Unmarshal. - err = tmjson.Unmarshal(js, dst) - require.Nil(t, err, "%+v", err) -} - -func TestKeyEncodings(t *testing.T) { - cases := []struct { - privKey crypto.PrivKey - privSize, pubSize, sigSize int // binary sizes - }{ - { - privKey: ed25519.GenPrivKey(), - privSize: 69, - pubSize: 37, - sigSize: 65, - }, - { - privKey: sr25519.GenPrivKey(), - privSize: 37, - pubSize: 37, - sigSize: 65, - }, - { - privKey: secp256k1.GenPrivKey(), - privSize: 37, - pubSize: 38, - sigSize: 65, - }, - } - - for tcIndex, tc := range cases { - - // Check (de/en)codings of PrivKeys. - var priv2, priv3 crypto.PrivKey - checkAminoBinary(t, tc.privKey, &priv2, tc.privSize) - assert.EqualValues(t, tc.privKey, priv2, "tc #%d", tcIndex) - checkJSON(t, tc.privKey, &priv3, false) // TODO also check Prefix bytes. - assert.EqualValues(t, tc.privKey, priv3, "tc #%d", tcIndex) - - // Check (de/en)codings of Signatures. - var sig1, sig2 []byte - sig1, err := tc.privKey.Sign([]byte("something")) - assert.NoError(t, err, "tc #%d", tcIndex) - checkAminoBinary(t, sig1, &sig2, tc.sigSize) - assert.EqualValues(t, sig1, sig2, "tc #%d", tcIndex) - - // Check (de/en)codings of PubKeys. - pubKey := tc.privKey.PubKey() - var pub2, pub3 crypto.PubKey - checkAminoBinary(t, pubKey, &pub2, tc.pubSize) - assert.EqualValues(t, pubKey, pub2, "tc #%d", tcIndex) - checkJSON(t, pubKey, &pub3, false) // TODO also check Prefix bytes. - assert.EqualValues(t, pubKey, pub3, "tc #%d", tcIndex) - } -} - -func TestNilEncodings(t *testing.T) { - - // Check nil Signature. - var a, b []byte - checkJSON(t, &a, &b, true) - assert.EqualValues(t, a, b) - - // Check nil PubKey. - var c, d crypto.PubKey - checkJSON(t, &c, &d, true) - assert.EqualValues(t, c, d) - - // Check nil PrivKey. - var e, f crypto.PrivKey - checkJSON(t, &e, &f, true) - assert.EqualValues(t, e, f) -} - -func TestPubKeyInvalidDataProperReturnsEmpty(t *testing.T) { - pk, err := PubKeyFromBytes([]byte("foo")) - require.NotNil(t, err) - require.Nil(t, pk) -} - -func TestPubkeyAminoName(t *testing.T) { - tests := []struct { - key crypto.PubKey - want string - found bool - }{ - {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) - require.Equal(t, tc.found, found, "not equal on tc %d", i) - if tc.found { - require.Equal(t, tc.want, got, "not equal on tc %d", i) - } - } -} - -var _ crypto.PrivKey = testPriv{} -var _ crypto.PubKey = testPub{} -var testCdc = amino.NewCodec() - -type testPriv []byte - -func (privkey testPriv) PubKey() crypto.PubKey { return testPub{} } -func (privkey testPriv) Bytes() []byte { - return testCdc.MustMarshalBinaryBare(privkey) -} -func (privkey testPriv) Sign(msg []byte) ([]byte, error) { return []byte{}, nil } -func (privkey testPriv) Equals(other crypto.PrivKey) bool { return true } -func (privkey testPriv) Type() string { return "testPriv" } - -type testPub []byte - -func (key testPub) Address() crypto.Address { return crypto.Address{} } -func (key testPub) Bytes() []byte { - return testCdc.MustMarshalBinaryBare(key) -} -func (key testPub) VerifyBytes(msg []byte, sig []byte) bool { return true } -func (key testPub) Equals(other crypto.PubKey) bool { return true } -func (key testPub) String() string { return "" } -func (key testPub) Type() string { return "testPub" } - -var ( - privAminoName = "registerTest/Priv" - pubAminoName = "registerTest/Pub" -) - -func TestRegisterKeyType(t *testing.T) { - RegisterAmino(testCdc) - testCdc.RegisterConcrete(testPriv{}, privAminoName, nil) - testCdc.RegisterConcrete(testPub{}, pubAminoName, nil) - - pub := testPub{0x1} - priv := testPriv{0x2} - - // Check to make sure key cannot be decoded before registering - _, err := PrivKeyFromBytes(priv.Bytes()) - require.Error(t, err) - _, err = PubKeyFromBytes(pub.Bytes()) - require.Error(t, err) - - // Check that name is not registered - _, found := PubkeyAminoName(testCdc, pub) - require.False(t, found) - - // Register key types - RegisterKeyType(testPriv{}, privAminoName) - RegisterKeyType(testPub{}, pubAminoName) - - // Name should exist after registering - name, found := PubkeyAminoName(testCdc, pub) - require.True(t, found) - require.Equal(t, name, pubAminoName) - - // Decode keys using the encoded bytes from encoding with the other codec - decodedPriv, err := PrivKeyFromBytes(priv.Bytes()) - require.NoError(t, err) - require.Equal(t, priv, decodedPriv) - - decodedPub, err := PubKeyFromBytes(pub.Bytes()) - require.NoError(t, err) - require.Equal(t, pub, decodedPub) - - // Reset module codec after testing - cdc = amino.NewCodec() - nameTable = make(map[reflect.Type]string, 3) - RegisterAmino(cdc) - nameTable[reflect.TypeOf(ed25519.PubKey{})] = ed25519.PubKeyName - nameTable[reflect.TypeOf(sr25519.PubKey{})] = sr25519.PubKeyName - nameTable[reflect.TypeOf(secp256k1.PubKey{})] = secp256k1.PubKeyName -} diff --git a/crypto/merkle/proof_test.go b/crypto/merkle/proof_test.go index b07673072..fd89be23f 100644 --- a/crypto/merkle/proof_test.go +++ b/crypto/merkle/proof_test.go @@ -7,6 +7,7 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + tmmerkle "github.com/tendermint/tendermint/proto/crypto/merkle" ) diff --git a/go.mod b/go.mod index 83f2c3710..fb763d165 100644 --- a/go.mod +++ b/go.mod @@ -25,7 +25,6 @@ require ( github.com/spf13/cobra v1.0.0 github.com/spf13/viper v1.7.0 github.com/stretchr/testify v1.6.1 - github.com/tendermint/go-amino v0.14.1 github.com/tendermint/tm-db v0.5.1 golang.org/x/crypto v0.0.0-20200406173513-056763e48d71 golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e diff --git a/go.sum b/go.sum index a01c6ab24..7d2afbda6 100644 --- a/go.sum +++ b/go.sum @@ -446,8 +446,6 @@ github.com/syndtr/goleveldb v1.0.1-0.20190923125748-758128399b1d h1:gZZadD8H+fF+ github.com/syndtr/goleveldb v1.0.1-0.20190923125748-758128399b1d/go.mod h1:9OrXJhf154huy1nPWmuSrkgjPUtUNhA+Zmy+6AESzuA= github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c h1:g+WoO5jjkqGAzHWCjJB1zZfXPIAaDpzXIEJ0eS6B5Ok= github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c/go.mod h1:ahpPrc7HpcfEWDQRZEmnXMzHY03mLDYMCxeDzy46i+8= -github.com/tendermint/go-amino v0.14.1 h1:o2WudxNfdLNBwMyl2dqOJxiro5rfrEaU0Ugs6offJMk= -github.com/tendermint/go-amino v0.14.1/go.mod h1:i/UKE5Uocn+argJJBb12qTZsCDBcAYMbR92AaJVmKso= github.com/tendermint/tm-db v0.5.1 h1:H9HDq8UEA7Eeg13kdYckkgwwkQLBnJGgX4PgLJRhieY= github.com/tendermint/tm-db v0.5.1/go.mod h1:g92zWjHpCYlEvQXvy9M168Su8V1IBEeawpXVVBaK4f4= github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= diff --git a/node/codec.go b/node/codec.go deleted file mode 100644 index e172b9696..000000000 --- a/node/codec.go +++ /dev/null @@ -1,13 +0,0 @@ -package node - -import ( - amino "github.com/tendermint/go-amino" - - cryptoamino "github.com/tendermint/tendermint/crypto/encoding/amino" -) - -var cdc = amino.NewCodec() - -func init() { - cryptoamino.RegisterAmino(cdc) -} diff --git a/state/main_test.go b/state/main_test.go deleted file mode 100644 index 864c96dd7..000000000 --- a/state/main_test.go +++ /dev/null @@ -1,10 +0,0 @@ -package state_test - -import ( - "os" - "testing" -) - -func TestMain(m *testing.M) { - os.Exit(m.Run()) -}