chore(migration) add crypto and encoding pkgs (evmos#1317)

* chore(migration) add cripto and encoding pkgs * chore(migration) fix licenses * chore(migration) fix tests * Apply suggestions from code review Co-authored-by: MalteHerrmann <[email protected]> --------- Co-authored-by: MalteHerrmann <[email protected]>
kiloonen · Feb 1, 2023 · 20b606c · 20b606c
1 parent 9b4ab8c
commit 20b606c
Show file tree

Hide file tree

Showing 10 changed files with 494 additions and 6 deletions.
diff --git a/crypto/codec/amino.go b/crypto/codec/amino.go
@@ -0,0 +1,43 @@
+// Copyright 2022 Evmos Foundation
+// This file is part of the Evmos Network packages.
+//
+// Evmos is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The Evmos packages are distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the Evmos packages. If not, see https://github.com/evmos/evmos/blob/main/LICENSE
+package codec
+
+import (
+	"github.com/cosmos/cosmos-sdk/client/keys"
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/codec/legacy"
+	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
+	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+
+	"github.com/evmos/evmos/v11/crypto/ethsecp256k1"
+)
+
+// RegisterCrypto registers all crypto dependency types with the provided Amino
+// codec.
+func RegisterCrypto(cdc *codec.LegacyAmino) {
+	cdc.RegisterConcrete(&ethsecp256k1.PubKey{},
+		ethsecp256k1.PubKeyName, nil)
+	cdc.RegisterConcrete(&ethsecp256k1.PrivKey{},
+		ethsecp256k1.PrivKeyName, nil)
+
+	keyring.RegisterLegacyAminoCodec(cdc)
+	cryptocodec.RegisterCrypto(cdc)
+
+	// NOTE: update SDK's amino codec to include the ethsecp256k1 keys.
+	// DO NOT REMOVE unless deprecated on the SDK.
+	legacy.Cdc = cdc
+	keys.KeysCdc = cdc
+}
diff --git a/crypto/codec/codec.go b/crypto/codec/codec.go
@@ -0,0 +1,29 @@
+// Copyright 2022 Evmos Foundation
+// This file is part of the Evmos Network packages.
+//
+// Evmos is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The Evmos packages are distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the Evmos packages. If not, see https://github.com/evmos/evmos/blob/main/LICENSE
+package codec
+
+import (
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+
+	"github.com/evmos/evmos/v11/crypto/ethsecp256k1"
+)
+
+// RegisterInterfaces register the Evmos key concrete types.
+func RegisterInterfaces(registry codectypes.InterfaceRegistry) {
+	registry.RegisterImplementations((*cryptotypes.PubKey)(nil), &ethsecp256k1.PubKey{})
+	registry.RegisterImplementations((*cryptotypes.PrivKey)(nil), &ethsecp256k1.PrivKey{})
+}
diff --git a/crypto/hd/algorithm.go b/crypto/hd/algorithm.go
@@ -0,0 +1,126 @@
+// Copyright 2022 Evmos Foundation
+// This file is part of the Evmos Network packages.
+//
+// Evmos is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The Evmos packages are distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the Evmos packages. If not, see https://github.com/evmos/evmos/blob/main/LICENSE
+package hd
+
+import (
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcutil/hdkeychain"
+	bip39 "github.com/tyler-smith/go-bip39"
+
+	"github.com/ethereum/go-ethereum/accounts"
+	"github.com/ethereum/go-ethereum/crypto"
+
+	"github.com/cosmos/cosmos-sdk/crypto/hd"
+	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+
+	"github.com/evmos/evmos/v11/crypto/ethsecp256k1"
+)
+
+const (
+	// EthSecp256k1Type defines the ECDSA secp256k1 used on Ethereum
+	EthSecp256k1Type = hd.PubKeyType(ethsecp256k1.KeyType)
+)
+
+var (
+	// SupportedAlgorithms defines the list of signing algorithms used on Evmos:
+	//  - eth_secp256k1 (Ethereum)
+	//  - secp256k1 (Tendermint)
+	SupportedAlgorithms = keyring.SigningAlgoList{EthSecp256k1, hd.Secp256k1}
+	// SupportedAlgorithmsLedger defines the list of signing algorithms used on Evmos for the Ledger device:
+	//  - eth_secp256k1 (Ethereum)
+	//  - secp256k1 (Tendermint)
+	SupportedAlgorithmsLedger = keyring.SigningAlgoList{EthSecp256k1, hd.Secp256k1}
+)
+
+// EthSecp256k1Option defines a function keys options for the ethereum Secp256k1 curve.
+// It supports eth_secp256k1 and secp256k1 keys for accounts.
+func EthSecp256k1Option() keyring.Option {
+	return func(options *keyring.Options) {
+		options.SupportedAlgos = SupportedAlgorithms
+		options.SupportedAlgosLedger = SupportedAlgorithmsLedger
+	}
+}
+
+var (
+	_ keyring.SignatureAlgo = EthSecp256k1
+
+	// EthSecp256k1 uses the Bitcoin secp256k1 ECDSA parameters.
+	EthSecp256k1 = ethSecp256k1Algo{}
+)
+
+type ethSecp256k1Algo struct{}
+
+// Name returns eth_secp256k1
+func (s ethSecp256k1Algo) Name() hd.PubKeyType {
+	return EthSecp256k1Type
+}
+
+// Derive derives and returns the eth_secp256k1 private key for the given mnemonic and HD path.
+func (s ethSecp256k1Algo) Derive() hd.DeriveFn {
+	return func(mnemonic, bip39Passphrase, path string) ([]byte, error) {
+		hdpath, err := accounts.ParseDerivationPath(path)
+		if err != nil {
+			return nil, err
+		}
+
+		seed, err := bip39.NewSeedWithErrorChecking(mnemonic, bip39Passphrase)
+		if err != nil {
+			return nil, err
+		}
+
+		// create a BTC-utils hd-derivation key chain
+		masterKey, err := hdkeychain.NewMaster(seed, &chaincfg.MainNetParams)
+		if err != nil {
+			return nil, err
+		}
+
+		key := masterKey
+		for _, n := range hdpath {
+			key, err = key.Derive(n)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		// btc-utils representation of a secp256k1 private key
+		privateKey, err := key.ECPrivKey()
+		if err != nil {
+			return nil, err
+		}
+
+		// cast private key to a convertible form (single scalar field element of secp256k1)
+		// and then load into ethcrypto private key format.
+		// TODO: add links to godocs of the two methods or implementations of them, to compare equivalency
+		privateKeyECDSA := privateKey.ToECDSA()
+		derivedKey := crypto.FromECDSA(privateKeyECDSA)
+
+		return derivedKey, nil
+	}
+}
+
+// Generate generates a eth_secp256k1 private key from the given bytes.
+func (s ethSecp256k1Algo) Generate() hd.GenerateFn {
+	return func(bz []byte) cryptotypes.PrivKey {
+		bzArr := make([]byte, ethsecp256k1.PrivKeySize)
+		copy(bzArr, bz)
+
+		// TODO: modulo P
+		return &ethsecp256k1.PrivKey{
+			Key: bzArr,
+		}
+	}
+}
diff --git a/crypto/hd/algorithm_test.go b/crypto/hd/algorithm_test.go
@@ -0,0 +1,132 @@
+package hd
+
+import (
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ethereum/go-ethereum/common"
+
+	hdwallet "github.com/miguelmota/go-ethereum-hdwallet"
+
+	amino "github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/codec/types"
+	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+
+	ethermint "github.com/evmos/ethermint/types"
+	cryptocodec "github.com/evmos/evmos/v11/crypto/codec"
+	enccodec "github.com/evmos/evmos/v11/encoding/codec"
+)
+
+var TestCodec amino.Codec
+
+func init() {
+	cdc := amino.NewLegacyAmino()
+	cryptocodec.RegisterCrypto(cdc)
+
+	interfaceRegistry := types.NewInterfaceRegistry()
+	TestCodec = amino.NewProtoCodec(interfaceRegistry)
+	enccodec.RegisterInterfaces(interfaceRegistry)
+}
+
+const (
+	mnemonic = "picnic rent average infant boat squirrel federal assault mercy purity very motor fossil wheel verify upset box fresh horse vivid copy predict square regret"
+
+	// hdWalletFixEnv defines whether the standard (correct) bip39
+	// derivation path was used, or if derivation was affected by
+	// https://github.com/btcsuite/btcutil/issues/179
+	hdWalletFixEnv = "GO_ETHEREUM_HDWALLET_FIX_ISSUE_179"
+)
+
+func TestKeyring(t *testing.T) {
+	dir := t.TempDir()
+	mockIn := strings.NewReader("")
+	kr, err := keyring.New("evmos", keyring.BackendTest, dir, mockIn, TestCodec, EthSecp256k1Option())
+	require.NoError(t, err)
+
+	// fail in retrieving key
+	info, err := kr.Key("foo")
+	require.Error(t, err)
+	require.Nil(t, info)
+
+	mockIn.Reset("password\npassword\n")
+	info, mnemonic, err := kr.NewMnemonic("foo", keyring.English, ethermint.BIP44HDPath, keyring.DefaultBIP39Passphrase, EthSecp256k1)
+	require.NoError(t, err)
+	require.NotEmpty(t, mnemonic)
+	require.Equal(t, "foo", info.Name)
+	require.Equal(t, "local", info.GetType().String())
+	pubKey, err := info.GetPubKey()
+	require.NoError(t, err)
+	require.Equal(t, string(EthSecp256k1Type), pubKey.Type())
+
+	hdPath := ethermint.BIP44HDPath
+
+	bz, err := EthSecp256k1.Derive()(mnemonic, keyring.DefaultBIP39Passphrase, hdPath)
+	require.NoError(t, err)
+	require.NotEmpty(t, bz)
+
+	wrongBz, err := EthSecp256k1.Derive()(mnemonic, keyring.DefaultBIP39Passphrase, "/wrong/hdPath")
+	require.Error(t, err)
+	require.Empty(t, wrongBz)
+
+	privkey := EthSecp256k1.Generate()(bz)
+	addr := common.BytesToAddress(privkey.PubKey().Address().Bytes())
+
+	os.Setenv(hdWalletFixEnv, "true")
+	wallet, err := hdwallet.NewFromMnemonic(mnemonic)
+	os.Setenv(hdWalletFixEnv, "")
+	require.NoError(t, err)
+
+	path := hdwallet.MustParseDerivationPath(hdPath)
+
+	account, err := wallet.Derive(path, false)
+	require.NoError(t, err)
+	require.Equal(t, addr.String(), account.Address.String())
+}
+
+func TestDerivation(t *testing.T) {
+	bz, err := EthSecp256k1.Derive()(mnemonic, keyring.DefaultBIP39Passphrase, ethermint.BIP44HDPath)
+	require.NoError(t, err)
+	require.NotEmpty(t, bz)
+
+	badBz, err := EthSecp256k1.Derive()(mnemonic, keyring.DefaultBIP39Passphrase, "44'/60'/0'/0/0")
+	require.NoError(t, err)
+	require.NotEmpty(t, badBz)
+
+	require.NotEqual(t, bz, badBz)
+
+	privkey := EthSecp256k1.Generate()(bz)
+	badPrivKey := EthSecp256k1.Generate()(badBz)
+
+	require.False(t, privkey.Equals(badPrivKey))
+
+	wallet, err := hdwallet.NewFromMnemonic(mnemonic)
+	require.NoError(t, err)
+
+	path := hdwallet.MustParseDerivationPath(ethermint.BIP44HDPath)
+	account, err := wallet.Derive(path, false)
+	require.NoError(t, err)
+
+	badPath := hdwallet.MustParseDerivationPath("44'/60'/0'/0/0")
+	badAccount, err := wallet.Derive(badPath, false)
+	require.NoError(t, err)
+
+	// Equality of Address BIP44
+	require.Equal(t, account.Address.String(), "0xA588C66983a81e800Db4dF74564F09f91c026351")
+	require.Equal(t, badAccount.Address.String(), "0xF8D6FDf2B8b488ea37e54903750dcd13F67E71cb")
+	// Inequality of wrong derivation path address
+	require.NotEqual(t, account.Address.String(), badAccount.Address.String())
+	// Equality of Evmos implementation
+	require.Equal(t, common.BytesToAddress(privkey.PubKey().Address().Bytes()).String(), "0xA588C66983a81e800Db4dF74564F09f91c026351")
+	require.Equal(t, common.BytesToAddress(badPrivKey.PubKey().Address().Bytes()).String(), "0xF8D6FDf2B8b488ea37e54903750dcd13F67E71cb")
+
+	// Equality of Eth and Evmos implementation
+	require.Equal(t, common.BytesToAddress(privkey.PubKey().Address()).String(), account.Address.String())
+	require.Equal(t, common.BytesToAddress(badPrivKey.PubKey().Address()).String(), badAccount.Address.String())
+
+	// Inequality of wrong derivation path of Eth and Evmos implementation
+	require.NotEqual(t, common.BytesToAddress(privkey.PubKey().Address()).String(), badAccount.Address.String())
+	require.NotEqual(t, common.BytesToAddress(badPrivKey.PubKey().Address()).String(), account.Address.Hex())
+}
diff --git a/crypto/hd/benchmark_test.go b/crypto/hd/benchmark_test.go
@@ -0,0 +1,31 @@
+package hd
+
+import (
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+	ethermint "github.com/evmos/ethermint/types"
+)
+
+func BenchmarkEthSecp256k1Algo_Derive(b *testing.B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		deriveFn := EthSecp256k1.Derive()
+		if _, err := deriveFn(mnemonic, keyring.DefaultBIP39Passphrase, ethermint.BIP44HDPath); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkEthSecp256k1Algo_Generate(b *testing.B) {
+	bz, err := EthSecp256k1.Derive()(mnemonic, keyring.DefaultBIP39Passphrase, ethermint.BIP44HDPath)
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	b.ResetTimer()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		(&ethSecp256k1Algo{}).Generate()(bz)
+	}
+}