cerc-io/laconicd
18
0
Fork 2
Code Issues 1 Pull Requests 1 Actions Packages Projects Releases 10 Wiki Activity

crypto: refactor for stargate (#559)

Browse Source 
* changelog

* update changelog

* crypto: refactor for stargate

* fixes

* fix keys

* changelog
This commit is contained in:
Federico Kunze 2020-10-06 20:57:55 +02:00 committed by GitHub
parent e7a19a1c0a
commit 4e01da905a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
32 changed files with 165 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
CHANGELOG.md
View File

@ -35,7 +35,13 @@ Ref: https://keepachangelog.com/en/1.0.0/
# Changelog
## Unreleased
### API Breaking
* (crypto) [\#559](https://github.com/ChainSafe/ethermint/pull/559) Refactored crypto package in preparation for the SDK's Stargate release:
* `crypto.PubKeySecp256k1` and `crypto.PrivKeySecp256k1` are now `ethsecp256k1.PubKey` and `ethsecp256k1.PrivKey`, respectively
* Moved SDK `SigningAlgo` implementation for Ethermint's Secp256k1 key to `crypto/hd` package.
## [v0.2.1] - 2020-09-30
### Features

6
app/ante/ante.go
View File

@ -8,14 +8,14 @@ import (
"github.com/cosmos/cosmos-sdk/x/auth/keeper"
"github.com/cosmos/cosmos-sdk/x/auth/types"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
evmtypes "github.com/cosmos/ethermint/x/evm/types"
tmcrypto "github.com/tendermint/tendermint/crypto"
)
func init() {
crypto.RegisterCodec(types.ModuleCdc)
ethsecp256k1.RegisterCodec(types.ModuleCdc)
}
const (
@ -76,7 +76,7 @@ func sigGasConsumer(
meter sdk.GasMeter, _ []byte, pubkey tmcrypto.PubKey, _ types.Params,
) error {
switch pubkey.(type) {
case crypto.PubKeySecp256k1:
case ethsecp256k1.PubKey:
meter.ConsumeGas(secp256k1VerifyCost, "ante verify: secp256k1")
return nil
case tmcrypto.PubKey:

6
app/ante/utils_test.go
View File

@ -12,7 +12,7 @@ import (
"github.com/cosmos/ethermint/app"
ante "github.com/cosmos/ethermint/app/ante"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
ethermint "github.com/cosmos/ethermint/types"
evmtypes "github.com/cosmos/ethermint/x/evm/types"
@ -60,7 +60,7 @@ func newTestStdFee() auth.StdFee {
// GenerateAddress generates an Ethereum address.
func newTestAddrKey() (sdk.AccAddress, tmcrypto.PrivKey) {
privkey, _ := crypto.GenerateKey()
privkey, _ := ethsecp256k1.GenerateKey()
addr := ethcrypto.PubkeyToAddress(privkey.ToECDSA().PublicKey)
return sdk.AccAddress(addr.Bytes()), privkey
@ -95,7 +95,7 @@ func newTestEthTx(ctx sdk.Context, msg evmtypes.MsgEthereumTx, priv tmcrypto.Pri
return nil, err
}
privkey, ok := priv.(crypto.PrivKeySecp256k1)
privkey, ok := priv.(ethsecp256k1.PrivKey)
if !ok {
return nil, fmt.Errorf("invalid private key type: %T", priv)
}

8
client/export.go
View File

@ -15,8 +15,8 @@ import (
"github.com/cosmos/cosmos-sdk/client/input"
"github.com/cosmos/cosmos-sdk/crypto/keys"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
"github.com/cosmos/ethermint/crypto/hd"
)
// UnsafeExportEthKeyCommand exports a key with the given name as a private key in hex format.
@ -34,7 +34,7 @@ func UnsafeExportEthKeyCommand() *cobra.Command {
viper.GetString(flags.FlagKeyringBackend),
viper.GetString(flags.FlagHome),
inBuf,
crypto.EthSecp256k1Options()...,
hd.EthSecp256k1Options()...,
)
if err != nil {
return err
@ -64,7 +64,7 @@ func UnsafeExportEthKeyCommand() *cobra.Command {
}
// Converts key to Ethermint secp256 implementation
emintKey, ok := privKey.(crypto.PrivKeySecp256k1)
emintKey, ok := privKey.(ethsecp256k1.PrivKey)
if !ok {
return fmt.Errorf("invalid private key type, must be Ethereum key: %T", privKey)
}

10
client/keys.go
View File

@ -12,7 +12,7 @@ import (
"github.com/cosmos/cosmos-sdk/crypto/keys"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/hd"
)
const (
@ -37,8 +37,8 @@ func KeyCommands() *cobra.Command {
// update the default signing algorithm value to "eth_secp256k1"
algoFlag := addCmd.Flag("algo")
algoFlag.DefValue = string(crypto.EthSecp256k1)
err := algoFlag.Value.Set(string(crypto.EthSecp256k1))
algoFlag.DefValue = string(hd.EthSecp256k1)
err := algoFlag.Value.Set(string(hd.EthSecp256k1))
if err != nil {
panic(err)
}
@ -74,7 +74,7 @@ func runAddCmd(cmd *cobra.Command, args []string) error {
func getKeybase(transient bool, buf io.Reader) (keys.Keybase, error) {
if transient {
return keys.NewInMemory(
crypto.EthSecp256k1Options()...,
hd.EthSecp256k1Options()...,
), nil
}
@ -83,6 +83,6 @@ func getKeybase(transient bool, buf io.Reader) (keys.Keybase, error) {
viper.GetString(flags.FlagKeyringBackend),
viper.GetString(flags.FlagHome),
buf,
crypto.EthSecp256k1Options()...,
hd.EthSecp256k1Options()...,
)
}

6
client/testnet.go
View File

@ -36,7 +36,7 @@ import (
"github.com/cosmos/cosmos-sdk/x/mint"
stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/hd"
ethermint "github.com/cosmos/ethermint/types"
evmtypes "github.com/cosmos/ethermint/x/evm/types"
)
@ -102,7 +102,7 @@ Note, strict routability for addresses is turned off in the config file.`,
cmd.Flags().String(flagCoinDenom, ethermint.AttoPhoton, "Coin denomination used for staking, governance, mint, crisis and evm parameters")
cmd.Flags().String(server.FlagMinGasPrices, fmt.Sprintf("0.000006%s", ethermint.AttoPhoton), "Minimum gas prices to accept for transactions; All fees in a tx must meet this minimum (e.g. 0.01aphoton,0.001stake)")
cmd.Flags().String(flags.FlagKeyringBackend, flags.DefaultKeyringBackend, "Select keyring's backend (os|file|test)")
cmd.Flags().String(flagKeyAlgo, string(crypto.EthSecp256k1), "Key signing algorithm to generate keys for")
cmd.Flags().String(flagKeyAlgo, string(hd.EthSecp256k1), "Key signing algorithm to generate keys for")
return cmd
}
@ -203,7 +203,7 @@ func InitTestnet(
keyringBackend,
clientDir,
inBuf,
crypto.EthSecp256k1Options()...,
hd.EthSecp256k1Options()...,
)
if err != nil {
return err

6
cmd/ethermintcli/main.go
View File

@ -24,7 +24,7 @@ import (
"github.com/cosmos/ethermint/app"
"github.com/cosmos/ethermint/client"
"github.com/cosmos/ethermint/codec"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
"github.com/cosmos/ethermint/rpc"
ethermint "github.com/cosmos/ethermint/types"
)
@ -37,8 +37,8 @@ func main() {
// Configure cobra to sort commands
cobra.EnableCommandSorting = false
tmamino.RegisterKeyType(crypto.PubKeySecp256k1{}, crypto.PubKeyAminoName)
tmamino.RegisterKeyType(crypto.PrivKeySecp256k1{}, crypto.PrivKeyAminoName)
tmamino.RegisterKeyType(ethsecp256k1.PubKey{}, ethsecp256k1.PubKeyName)
tmamino.RegisterKeyType(ethsecp256k1.PrivKey{}, ethsecp256k1.PrivKeyName)
keys.CryptoCdc = cdc
clientkeys.KeysCdc = cdc

4
cmd/ethermintd/genaccounts.go
View File

@ -20,7 +20,7 @@ import (
authvesting "github.com/cosmos/cosmos-sdk/x/auth/vesting"
"github.com/cosmos/cosmos-sdk/x/genutil"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/hd"
ethermint "github.com/cosmos/ethermint/types"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
@ -60,7 +60,7 @@ contain valid denominations. Accounts may optionally be supplied with vesting pa
viper.GetString(flags.FlagKeyringBackend),
viper.GetString(flagClientHome),
inBuf,
crypto.EthSecp256k1Options()...,
hd.EthSecp256k1Options()...,
)
if err != nil {
return err

6
cmd/ethermintd/main.go
View File

@ -30,7 +30,7 @@ import (
"github.com/cosmos/ethermint/app"
"github.com/cosmos/ethermint/client"
"github.com/cosmos/ethermint/codec"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
ethermint "github.com/cosmos/ethermint/types"
)
@ -43,8 +43,8 @@ func main() {
cdc := codec.MakeCodec(app.ModuleBasics)
tmamino.RegisterKeyType(crypto.PubKeySecp256k1{}, crypto.PubKeyAminoName)
tmamino.RegisterKeyType(crypto.PrivKeySecp256k1{}, crypto.PrivKeyAminoName)
tmamino.RegisterKeyType(ethsecp256k1.PubKey{}, ethsecp256k1.PubKeyName)
tmamino.RegisterKeyType(ethsecp256k1.PrivKey{}, ethsecp256k1.PrivKeyName)
keys.CryptoCdc = cdc
genutil.ModuleCdc = cdc

4
codec/codec.go
View File

@ -7,7 +7,7 @@ import (
"github.com/cosmos/cosmos-sdk/types/module"
"github.com/cosmos/cosmos-sdk/x/auth/vesting"
emintcrypto "github.com/cosmos/ethermint/crypto"
cryptocodec "github.com/cosmos/ethermint/crypto/ethsecp256k1"
ethermint "github.com/cosmos/ethermint/types"
)
@ -22,7 +22,7 @@ func MakeCodec(bm module.BasicManager) *codec.Codec {
bm.RegisterCodec(cdc)
vesting.RegisterCodec(cdc)
sdk.RegisterCodec(cdc)
emintcrypto.RegisterCodec(cdc)
cryptocodec.RegisterCodec(cdc)
codec.RegisterCrypto(cdc)
ethermint.RegisterCodec(cdc)
keys.RegisterCodec(cdc) // temporary. Used to register keyring.Info

12
crypto/codec.go → crypto/ethsecp256k1/codec.go
View File

@ -1,4 +1,4 @@
package crypto
package ethsecp256k1
import (
cryptoamino "github.com/tendermint/tendermint/crypto/encoding/amino"
@ -10,12 +10,6 @@ import (
// CryptoCodec is the default amino codec used by ethermint
var CryptoCodec = codec.New()
// Amino encoding names
const (
PrivKeyAminoName = "ethermint/PrivKeySecp256k1"
PubKeyAminoName = "ethermint/PubKeySecp256k1"
)
func init() {
// replace the keyring codec with the ethermint crypto codec to prevent
// amino panics because of unregistered Priv/PubKey
@ -28,6 +22,6 @@ func init() {
// RegisterCodec registers all the necessary types with amino for the given
// codec.
func RegisterCodec(cdc *codec.Codec) {
cdc.RegisterConcrete(PubKeySecp256k1{}, PubKeyAminoName, nil)
cdc.RegisterConcrete(PrivKeySecp256k1{}, PrivKeyAminoName, nil)
cdc.RegisterConcrete(PubKey{}, PubKeyName, nil)
cdc.RegisterConcrete(PrivKey{}, PrivKeyName, nil)
}

63
crypto/secp256k1.go → crypto/ethsecp256k1/ethsecp256k1.go
View File

@ -1,56 +1,71 @@
package crypto
package ethsecp256k1
import (
"bytes"
"crypto/ecdsa"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
ethsecp256k1 "github.com/ethereum/go-ethereum/crypto/secp256k1"
"github.com/ethereum/go-ethereum/crypto/secp256k1"
tmcrypto "github.com/tendermint/tendermint/crypto"
)
const (
// PrivKeySize defines the size of the PrivKey bytes
PrivKeySize = 32
// KeyType is the string constant for the EthSecp256k1 algorithm
KeyType = "eth_secp256k1"
)
// Amino encoding names
const (
// PrivKeyName defines the amino encoding name for the EthSecp256k1 private key
PrivKeyName = "ethermint/PrivKeyEthSecp256k1"
// PubKeyName defines the amino encoding name for the EthSecp256k1 public key
PubKeyName = "ethermint/PubKeyEthSecp256k1"
)
// ----------------------------------------------------------------------------
// secp256k1 Private Key
var _ tmcrypto.PrivKey = PrivKeySecp256k1{}
var _ tmcrypto.PrivKey = PrivKey{}
// PrivKeySecp256k1 defines a type alias for an ecdsa.PrivateKey that implements
// PrivKey defines a type alias for an ecdsa.PrivateKey that implements
// Tendermint's PrivateKey interface.
type PrivKeySecp256k1 []byte
type PrivKey []byte
// GenerateKey generates a new random private key. It returns an error upon
// failure.
func GenerateKey() (PrivKeySecp256k1, error) {
func GenerateKey() (PrivKey, error) {
priv, err := ethcrypto.GenerateKey()
if err != nil {
return PrivKeySecp256k1{}, err
return PrivKey{}, err
}
return PrivKeySecp256k1(ethcrypto.FromECDSA(priv)), nil
return PrivKey(ethcrypto.FromECDSA(priv)), nil
}
// PubKey returns the ECDSA private key's public key.
func (privkey PrivKeySecp256k1) PubKey() tmcrypto.PubKey {
func (privkey PrivKey) PubKey() tmcrypto.PubKey {
ecdsaPKey := privkey.ToECDSA()
return PubKeySecp256k1(ethcrypto.CompressPubkey(&ecdsaPKey.PublicKey))
return PubKey(ethcrypto.CompressPubkey(&ecdsaPKey.PublicKey))
}
// Bytes returns the raw ECDSA private key bytes.
func (privkey PrivKeySecp256k1) Bytes() []byte {
func (privkey PrivKey) Bytes() []byte {
return CryptoCodec.MustMarshalBinaryBare(privkey)
}
// Sign creates a recoverable ECDSA signature on the secp256k1 curve over the
// Keccak256 hash of the provided message. The produced signature is 65 bytes
// where the last byte contains the recovery ID.
func (privkey PrivKeySecp256k1) Sign(msg []byte) ([]byte, error) {
func (privkey PrivKey) Sign(msg []byte) ([]byte, error) {
return ethcrypto.Sign(ethcrypto.Keccak256Hash(msg).Bytes(), privkey.ToECDSA())
}
// Equals returns true if two ECDSA private keys are equal and false otherwise.
func (privkey PrivKeySecp256k1) Equals(other tmcrypto.PrivKey) bool {
if other, ok := other.(PrivKeySecp256k1); ok {
func (privkey PrivKey) Equals(other tmcrypto.PrivKey) bool {
if other, ok := other.(PrivKey); ok {
return bytes.Equal(privkey.Bytes(), other.Bytes())
}
@ -59,7 +74,7 @@ func (privkey PrivKeySecp256k1) Equals(other tmcrypto.PrivKey) bool {
// ToECDSA returns the ECDSA private key as a reference to ecdsa.PrivateKey type.
// The function will panic if the private key is invalid.
func (privkey PrivKeySecp256k1) ToECDSA() *ecdsa.PrivateKey {
func (privkey PrivKey) ToECDSA() *ecdsa.PrivateKey {
key, err := ethcrypto.ToECDSA(privkey)
if err != nil {
panic(err)
@ -70,15 +85,15 @@ func (privkey PrivKeySecp256k1) ToECDSA() *ecdsa.PrivateKey {
// ----------------------------------------------------------------------------
// secp256k1 Public Key
var _ tmcrypto.PubKey = (*PubKeySecp256k1)(nil)
var _ tmcrypto.PubKey = (*PubKey)(nil)
// PubKeySecp256k1 defines a type alias for an ecdsa.PublicKey that implements Tendermint's PubKey
// PubKey defines a type alias for an ecdsa.PublicKey that implements Tendermint's PubKey
// interface. It represents the 33-byte compressed public key format.
type PubKeySecp256k1 []byte
type PubKey []byte
// Address returns the address of the ECDSA public key.
// The function will panic if the public key is invalid.
func (key PubKeySecp256k1) Address() tmcrypto.Address {
func (key PubKey) Address() tmcrypto.Address {
pubk, err := ethcrypto.DecompressPubkey(key)
if err != nil {
panic(err)
@ -89,7 +104,7 @@ func (key PubKeySecp256k1) Address() tmcrypto.Address {
// Bytes returns the raw bytes of the ECDSA public key.
// The function panics if the key cannot be marshaled to bytes.
func (key PubKeySecp256k1) Bytes() []byte {
func (key PubKey) Bytes() []byte {
bz, err := CryptoCodec.MarshalBinaryBare(key)
if err != nil {
panic(err)
@ -100,19 +115,19 @@ func (key PubKeySecp256k1) Bytes() []byte {
// VerifyBytes verifies that the ECDSA public key created a given signature over
// the provided message. It will calculate the Keccak256 hash of the message
// prior to verification.
func (key PubKeySecp256k1) VerifyBytes(msg []byte, sig []byte) bool {
func (key PubKey) VerifyBytes(msg []byte, sig []byte) bool {
if len(sig) == 65 {
// remove recovery ID if contained in the signature
sig = sig[:len(sig)-1]
}
// the signature needs to be in [R || S] format when provided to VerifySignature
return ethsecp256k1.VerifySignature(key, ethcrypto.Keccak256Hash(msg).Bytes(), sig)
return secp256k1.VerifySignature(key, ethcrypto.Keccak256Hash(msg).Bytes(), sig)
}
// Equals returns true if two ECDSA public keys are equal and false otherwise.
func (key PubKeySecp256k1) Equals(other tmcrypto.PubKey) bool {
if other, ok := other.(PubKeySecp256k1); ok {
func (key PubKey) Equals(other tmcrypto.PubKey) bool {
if other, ok := other.(PubKey); ok {
return bytes.Equal(key.Bytes(), other.Bytes())
}

8
crypto/secp256k1_test.go → crypto/ethsecp256k1/ethsecp256k1_test.go
View File

@ -1,4 +1,4 @@
package crypto
package ethsecp256k1
import (
"testing"
@ -11,7 +11,7 @@ import (
tmcrypto "github.com/tendermint/tendermint/crypto"
)
func TestPrivKeySecp256k1PrivKey(t *testing.T) {
func TestPrivKeyPrivKey(t *testing.T) {
// validate type and equality
privKey, err := GenerateKey()
require.NoError(t, err)
@ -38,12 +38,12 @@ func TestPrivKeySecp256k1PrivKey(t *testing.T) {
require.Equal(t, expectedSig, sig)
}
func TestPrivKeySecp256k1PubKey(t *testing.T) {
func TestPrivKeyPubKey(t *testing.T) {
privKey, err := GenerateKey()
require.NoError(t, err)
// validate type and equality
pubKey := privKey.PubKey().(PubKeySecp256k1)
pubKey := privKey.PubKey().(PubKey)
require.Implements(t, (*tmcrypto.PubKey)(nil), pubKey)
// validate inequality

12
crypto/algorithm.go → crypto/hd/algorithm.go
View File

@ -1,4 +1,4 @@
package crypto
package hd
import (
"fmt"
@ -15,13 +15,13 @@ import (
tmcrypto "github.com/tendermint/tendermint/crypto"
"github.com/cosmos/cosmos-sdk/crypto/keys"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
)
const (
// EthSecp256k1Type string constant for the EthSecp256k1 algorithm
EthSecp256k1Type = "eth_secp256k1"
// EthSecp256k1 defines the ECDSA secp256k1 used on Ethereum
EthSecp256k1 = keys.SigningAlgo(EthSecp256k1Type)
EthSecp256k1 = keys.SigningAlgo(ethsecp256k1.KeyType)
)
// SupportedAlgorithms defines the list of signing algorithms used on Ethermint:
@ -57,7 +57,7 @@ func EthermintKeygenFunc(bz []byte, algo keys.SigningAlgo) (tmcrypto.PrivKey, er
return nil, fmt.Errorf("signing algorithm must be %s, got %s", EthSecp256k1, algo)
}
return PrivKeySecp256k1(bz), nil
return ethsecp256k1.PrivKey(bz), nil
}
// DeriveSecp256k1 derives and returns the eth_secp256k1 private key for the given mnemonic and HD path.
@ -91,6 +91,6 @@ func DeriveSecp256k1(mnemonic, bip39Passphrase, path string) ([]byte, error) {
}
privateKeyECDSA := privateKey.ToECDSA()
derivedKey := PrivKeySecp256k1(ethcrypto.FromECDSA(privateKeyECDSA))
derivedKey := ethsecp256k1.PrivKey(ethcrypto.FromECDSA(privateKeyECDSA))
return derivedKey, nil
}

7
crypto/algorithm_test.go → crypto/hd/algorithm_test.go
View File

@ -1,4 +1,4 @@
package crypto
package hd
import (
"strings"
@ -15,11 +15,12 @@ import (
"github.com/cosmos/cosmos-sdk/crypto/keys/hd"
"github.com/cosmos/cosmos-sdk/tests"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
ethermint "github.com/cosmos/ethermint/types"
)
func TestEthermintKeygenFunc(t *testing.T) {
privkey, err := GenerateKey()
privkey, err := ethsecp256k1.GenerateKey()
require.NoError(t, err)
testCases := []struct {
@ -109,7 +110,7 @@ func TestKeyring(t *testing.T) {
require.NoError(t, err)
require.NotEmpty(t, bz)
privkey := PrivKeySecp256k1(bz)
privkey := ethsecp256k1.PrivKey(bz)
addr := common.BytesToAddress(privkey.PubKey().Address().Bytes())
wallet, err := hdwallet.NewFromMnemonic(mnemonic)

4
importer/importer_test.go
View File

@ -24,7 +24,7 @@ import (
"github.com/cosmos/cosmos-sdk/x/params"
"github.com/cosmos/ethermint/core"
emintcrypto "github.com/cosmos/ethermint/crypto"
cryptocodec "github.com/cosmos/ethermint/crypto/ethsecp256k1"
"github.com/cosmos/ethermint/types"
"github.com/cosmos/ethermint/x/evm"
evmtypes "github.com/cosmos/ethermint/x/evm/types"
@ -72,7 +72,7 @@ func newTestCodec() *sdkcodec.Codec {
auth.RegisterCodec(cdc)
bank.RegisterCodec(cdc)
sdk.RegisterCodec(cdc)
emintcrypto.RegisterCodec(cdc)
cryptocodec.RegisterCodec(cdc)
sdkcodec.RegisterCrypto(cdc)
return cdc

8
rpc/apis.go
View File

@ -3,9 +3,11 @@
package rpc
import (
"github.com/cosmos/cosmos-sdk/client/context"
emintcrypto "github.com/cosmos/ethermint/crypto"
"github.com/ethereum/go-ethereum/rpc"
"github.com/cosmos/cosmos-sdk/client/context"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
)
// RPC namespaces and API version
@ -19,7 +21,7 @@ const (
)
// GetRPCAPIs returns the list of all APIs
func GetRPCAPIs(cliCtx context.CLIContext, keys []emintcrypto.PrivKeySecp256k1) []rpc.API {
func GetRPCAPIs(cliCtx context.CLIContext, keys []ethsecp256k1.PrivKey) []rpc.API {
nonceLock := new(AddrLocker)
backend := NewEthermintBackend(cliCtx)
ethAPI := NewPublicEthAPI(cliCtx, backend, nonceLock, keys)

17
rpc/config.go
View File

@ -19,7 +19,8 @@ import (
authrest "github.com/cosmos/cosmos-sdk/x/auth/client/rest"
"github.com/cosmos/ethermint/app"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
"github.com/cosmos/ethermint/crypto/hd"
"github.com/ethereum/go-ethereum/rpc"
)
@ -45,7 +46,7 @@ func registerRoutes(rs *lcd.RestServer) {
accountName := viper.GetString(flagUnlockKey)
accountNames := strings.Split(accountName, ",")
var privkeys []crypto.PrivKeySecp256k1
var privkeys []ethsecp256k1.PrivKey
if len(accountName) > 0 {
var err error
inBuf := bufio.NewReader(os.Stdin)
@ -102,31 +103,31 @@ func registerRoutes(rs *lcd.RestServer) {
ws.start()
}
func unlockKeyFromNameAndPassphrase(accountNames []string, passphrase string) ([]crypto.PrivKeySecp256k1, error) {
func unlockKeyFromNameAndPassphrase(accountNames []string, passphrase string) ([]ethsecp256k1.PrivKey, error) {
keybase, err := keys.NewKeyring(
sdk.KeyringServiceName(),
viper.GetString(flags.FlagKeyringBackend),
viper.GetString(flags.FlagHome),
os.Stdin,
crypto.EthSecp256k1Options()...,
hd.EthSecp256k1Options()...,
)
if err != nil {
return []crypto.PrivKeySecp256k1{}, err
return []ethsecp256k1.PrivKey{}, err
}
// try the for loop with array []string accountNames
// run through the bottom code inside the for loop
keys := make([]crypto.PrivKeySecp256k1, len(accountNames))
keys := make([]ethsecp256k1.PrivKey, len(accountNames))
for i, acc := range accountNames {
// With keyring keybase, password is not required as it is pulled from the OS prompt
privKey, err := keybase.ExportPrivateKeyObject(acc, passphrase)
if err != nil {
return []crypto.PrivKeySecp256k1{}, err
return []ethsecp256k1.PrivKey{}, err
}
var ok bool
keys[i], ok = privKey.(crypto.PrivKeySecp256k1)
keys[i], ok = privKey.(ethsecp256k1.PrivKey)
if !ok {
panic(fmt.Sprintf("invalid private key type %T at index %d", privKey, i))
}

13
rpc/eth_api.go
View File

@ -10,7 +10,8 @@ import (
"github.com/spf13/viper"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
"github.com/cosmos/ethermint/crypto/hd"
params "github.com/cosmos/ethermint/rpc/args"
ethermint "github.com/cosmos/ethermint/types"
"github.com/cosmos/ethermint/utils"
@ -46,14 +47,14 @@ type PublicEthAPI struct {
chainIDEpoch *big.Int
logger log.Logger
backend Backend
keys []crypto.PrivKeySecp256k1 // unlocked keys
keys []ethsecp256k1.PrivKey // unlocked keys
nonceLock *AddrLocker
keybaseLock sync.Mutex
}
// NewPublicEthAPI creates an instance of the public ETH Web3 API.
func NewPublicEthAPI(cliCtx context.CLIContext, backend Backend, nonceLock *AddrLocker,
key []crypto.PrivKeySecp256k1) *PublicEthAPI {
key []ethsecp256k1.PrivKey) *PublicEthAPI {
epoch, err := ethermint.ParseChainID(cliCtx.ChainID)
if err != nil {
@ -86,7 +87,7 @@ func (e *PublicEthAPI) getKeybaseInfo() error {
viper.GetString(flags.FlagKeyringBackend),
viper.GetString(flags.FlagHome),
e.cliCtx.Input,
crypto.EthSecp256k1Options()...,
hd.EthSecp256k1Options()...,
)
if err != nil {
return err
@ -181,7 +182,7 @@ func (e *PublicEthAPI) Accounts() ([]common.Address, error) {
viper.GetString(flags.FlagKeyringBackend),
viper.GetString(flags.FlagHome),
e.cliCtx.Input,
crypto.EthSecp256k1Options()...,
hd.EthSecp256k1Options()...,
)
if err != nil {
return addresses, err
@ -342,7 +343,7 @@ func (e *PublicEthAPI) ExportAccount(address common.Address, blockNumber BlockNu
return string(res), nil
}
func checkKeyInKeyring(keys []crypto.PrivKeySecp256k1, address common.Address) (key crypto.PrivKeySecp256k1, exist bool) {
func checkKeyInKeyring(keys []ethsecp256k1.PrivKey, address common.Address) (key ethsecp256k1.PrivKey, exist bool) {
if len(keys) > 0 {
for _, key := range keys {
if bytes.Equal(key.PubKey().Address().Bytes(), address.Bytes()) {

15
rpc/personal_api.go
View File

@ -19,7 +19,8 @@ import (
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/crypto"
emintcrypto "github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
"github.com/cosmos/ethermint/crypto/hd"
params "github.com/cosmos/ethermint/rpc/args"
)
@ -54,7 +55,7 @@ func (e *PersonalEthAPI) getKeybaseInfo() ([]keys.Info, error) {
viper.GetString(flags.FlagKeyringBackend),
viper.GetString(flags.FlagHome),
e.ethAPI.cliCtx.Input,
emintcrypto.EthSecp256k1Options()...,
hd.EthSecp256k1Options()...,
)
if err != nil {
return nil, err
@ -77,9 +78,9 @@ func (e *PersonalEthAPI) ImportRawKey(privkey, password string) (common.Address,
return common.Address{}, err
}
privKey := emintcrypto.PrivKeySecp256k1(crypto.FromECDSA(priv))
privKey := ethsecp256k1.PrivKey(crypto.FromECDSA(priv))
armor := mintkey.EncryptArmorPrivKey(privKey, password, emintcrypto.EthSecp256k1Type)
armor := mintkey.EncryptArmorPrivKey(privKey, password, ethsecp256k1.KeyType)
// ignore error as we only care about the length of the list
list, _ := e.ethAPI.cliCtx.Keybase.List()
@ -126,7 +127,7 @@ func (e *PersonalEthAPI) LockAccount(address common.Address) bool {
continue
}
tmp := make([]emintcrypto.PrivKeySecp256k1, len(e.ethAPI.keys)-1)
tmp := make([]ethsecp256k1.PrivKey, len(e.ethAPI.keys)-1)
copy(tmp[:i], e.ethAPI.keys[:i])
copy(tmp[i:], e.ethAPI.keys[i+1:])
e.ethAPI.keys = tmp
@ -147,7 +148,7 @@ func (e *PersonalEthAPI) NewAccount(password string) (common.Address, error) {
}
name := "key_" + time.Now().UTC().Format(time.RFC3339)
info, _, err := e.ethAPI.cliCtx.Keybase.CreateMnemonic(name, keys.English, password, emintcrypto.EthSecp256k1)
info, _, err := e.ethAPI.cliCtx.Keybase.CreateMnemonic(name, keys.English, password, hd.EthSecp256k1)
if err != nil {
return common.Address{}, err
}
@ -193,7 +194,7 @@ func (e *PersonalEthAPI) UnlockAccount(_ context.Context, addr common.Address, p
return false, err
}
emintKey, ok := privKey.(emintcrypto.PrivKeySecp256k1)
emintKey, ok := privKey.(ethsecp256k1.PrivKey)
if !ok {
return false, fmt.Errorf("invalid private key type: %T", privKey)
}

4
tests/personal_test.go
View File

@ -4,11 +4,11 @@ import (
"encoding/json"
"testing"
"github.com/stretchr/testify/require"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/stretchr/testify/require"
)
func TestPersonal_ListAccounts(t *testing.T) {

8
types/account_test.go
View File

@ -13,13 +13,13 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
"github.com/cosmos/ethermint/types"
)
func init() {
tmamino.RegisterKeyType(crypto.PubKeySecp256k1{}, crypto.PubKeyAminoName)
tmamino.RegisterKeyType(crypto.PrivKeySecp256k1{}, crypto.PrivKeyAminoName)
tmamino.RegisterKeyType(ethsecp256k1.PubKey{}, ethsecp256k1.PubKeyName)
tmamino.RegisterKeyType(ethsecp256k1.PrivKey{}, ethsecp256k1.PrivKeyName)
}
type AccountTestSuite struct {
@ -84,7 +84,7 @@ func (suite *AccountTestSuite) TestEthermintAccountJSON() {
}
func (suite *AccountTestSuite) TestEthermintPubKeyJSON() {
privkey, err := crypto.GenerateKey()
privkey, err := ethsecp256k1.GenerateKey()
suite.Require().NoError(err)
bz := privkey.PubKey().Bytes()

4
x/evm/genesis_test.go
View File

File diff suppressed because one or more lines are too long

12
x/evm/handler_test.go
View File

@ -20,7 +20,7 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/ethermint/app"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
ethermint "github.com/cosmos/ethermint/types"
"github.com/cosmos/ethermint/x/evm"
"github.com/cosmos/ethermint/x/evm/keeper"
@ -55,7 +55,7 @@ func TestEvmTestSuite(t *testing.T) {
}
func (suite *EvmTestSuite) TestHandleMsgEthereumTx() {
privkey, err := crypto.GenerateKey()
privkey, err := ethsecp256k1.GenerateKey()
suite.Require().NoError(err)
sender := ethcmn.HexToAddress(privkey.PubKey().Address().String())
@ -219,7 +219,7 @@ func (suite *EvmTestSuite) TestHandlerLogs() {
gasLimit := uint64(100000)
gasPrice := big.NewInt(1000000)
priv, err := crypto.GenerateKey()
priv, err := ethsecp256k1.GenerateKey()
suite.Require().NoError(err, "failed to create key")
bytecode := common.FromHex("0x6080604052348015600f57600080fd5b5060117f775a94827b8fd9b519d36cd827093c664f93347070a554f65e4a6f56cd73889860405160405180910390a2603580604b6000396000f3fe6080604052600080fdfea165627a7a723058206cab665f0f557620554bb45adf266708d2bd349b8a4314bdff205ee8440e3c240029")
@ -250,7 +250,7 @@ func (suite *EvmTestSuite) TestQueryTxLogs() {
gasLimit := uint64(100000)
gasPrice := big.NewInt(1000000)
priv, err := crypto.GenerateKey()
priv, err := ethsecp256k1.GenerateKey()
suite.Require().NoError(err, "failed to create key")
// send contract deployment transaction with an event in the constructor
@ -349,7 +349,7 @@ func (suite *EvmTestSuite) TestDeployAndCallContract() {
gasLimit := uint64(100000000)
gasPrice := big.NewInt(10000)
priv, err := crypto.GenerateKey()
priv, err := ethsecp256k1.GenerateKey()
suite.Require().NoError(err, "failed to create key")
bytecode := common.FromHex("0x608060405234801561001057600080fd5b50336000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167f342827c97908e5e2f71151c08502a66d44b6f758e3ac2f1de95f02eb95f0a73560405160405180910390a36102c4806100dc6000396000f3fe608060405234801561001057600080fd5b5060043610610053576000357c010000000000000000000000000000000000000000000000000000000090048063893d20e814610058578063a6f9dae1146100a2575b600080fd5b6100606100e6565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b6100e4600480360360208110156100b857600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919050505061010f565b005b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146101d1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260138152602001807f43616c6c6572206973206e6f74206f776e65720000000000000000000000000081525060200191505060405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff166000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f342827c97908e5e2f71151c08502a66d44b6f758e3ac2f1de95f02eb95f0a73560405160405180910390a3806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505056fea265627a7a72315820f397f2733a89198bc7fed0764083694c5b828791f39ebcbc9e414bccef14b48064736f6c63430005100032")
@ -400,7 +400,7 @@ func (suite *EvmTestSuite) TestSendTransaction() {
gasLimit := uint64(21000)
gasPrice := big.NewInt(0x55ae82600)
priv, err := crypto.GenerateKey()
priv, err := ethsecp256k1.GenerateKey()
suite.Require().NoError(err, "failed to create key")
pub := priv.ToECDSA().Public().(*ecdsa.PublicKey)

8
x/evm/keeper/statedb_test.go
View File

@ -10,7 +10,7 @@ import (
ethtypes "github.com/ethereum/go-ethereum/core/types"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
ethermint "github.com/cosmos/ethermint/types"
"github.com/cosmos/ethermint/x/evm/types"
)
@ -328,7 +328,7 @@ func (suite *KeeperTestSuite) TestStateDB_CreateAccount() {
}
func (suite *KeeperTestSuite) TestStateDB_ClearStateObj() {
priv, err := crypto.GenerateKey()
priv, err := ethsecp256k1.GenerateKey()
suite.Require().NoError(err)
addr := ethcrypto.PubkeyToAddress(priv.ToECDSA().PublicKey)
@ -341,7 +341,7 @@ func (suite *KeeperTestSuite) TestStateDB_ClearStateObj() {
}
func (suite *KeeperTestSuite) TestStateDB_Reset() {
priv, err := crypto.GenerateKey()
priv, err := ethsecp256k1.GenerateKey()
suite.Require().NoError(err)
addr := ethcrypto.PubkeyToAddress(priv.ToECDSA().PublicKey)
@ -444,7 +444,7 @@ func (suite *KeeperTestSuite) TestSuiteDB_Suicide() {
suite.Require().True(suite.app.EvmKeeper.HasSuicided(suite.ctx, suite.address), tc.name)
} else {
//Suicide only works for an account with non-zero balance/nonce
priv, err := crypto.GenerateKey()
priv, err := ethsecp256k1.GenerateKey()
suite.Require().NoError(err)
addr := ethcrypto.PubkeyToAddress(priv.ToECDSA().PublicKey)

5
x/evm/types/genesis_test.go
View File

@ -4,12 +4,13 @@ import (
"math/big"
"testing"
"github.com/cosmos/ethermint/crypto"
"github.com/stretchr/testify/require"
ethcmn "github.com/ethereum/go-ethereum/common"
ethtypes "github.com/ethereum/go-ethereum/core/types"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
)
func TestValidateGenesisAccount(t *testing.T) {
@ -77,7 +78,7 @@ func TestValidateGenesisAccount(t *testing.T) {
}
func TestValidateGenesis(t *testing.T) {
priv, err := crypto.GenerateKey()
priv, err := ethsecp256k1.GenerateKey()
require.NoError(t, err)
addr := ethcrypto.PubkeyToAddress(priv.ToECDSA().PublicKey)

6
x/evm/types/journal_test.go
View File

@ -22,7 +22,7 @@ import (
ethtypes "github.com/ethereum/go-ethereum/core/types"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
ethermint "github.com/cosmos/ethermint/types"
)
@ -40,7 +40,7 @@ func newTestCodec() *sdkcodec.Codec {
RegisterCodec(cdc)
sdk.RegisterCodec(cdc)
crypto.RegisterCodec(cdc)
ethsecp256k1.RegisterCodec(cdc)
sdkcodec.RegisterCrypto(cdc)
auth.RegisterCodec(cdc)
ethermint.RegisterCodec(cdc)
@ -51,7 +51,7 @@ func newTestCodec() *sdkcodec.Codec {
func (suite *JournalTestSuite) SetupTest() {
suite.setup()
privkey, err := crypto.GenerateKey()
privkey, err := ethsecp256k1.GenerateKey()
suite.Require().NoError(err)
suite.address = ethcmn.BytesToAddress(privkey.PubKey().Address().Bytes())

7
x/evm/types/logs_test.go
View File

@ -3,17 +3,16 @@ package types
import (
"testing"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
"github.com/stretchr/testify/require"
ethcmn "github.com/ethereum/go-ethereum/common"
ethtypes "github.com/ethereum/go-ethereum/core/types"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/cosmos/ethermint/crypto"
)
func TestTransactionLogsValidate(t *testing.T) {
priv, err := crypto.GenerateKey()
priv, err := ethsecp256k1.GenerateKey()
require.NoError(t, err)
addr := ethcrypto.PubkeyToAddress(priv.ToECDSA().PublicKey)
@ -91,7 +90,7 @@ func TestTransactionLogsValidate(t *testing.T) {
}
func TestValidateLog(t *testing.T) {
priv, err := crypto.GenerateKey()
priv, err := ethsecp256k1.GenerateKey()
require.NoError(t, err)
addr := ethcrypto.PubkeyToAddress(priv.ToECDSA().PublicKey)

7
x/evm/types/msg_test.go
View File

@ -10,8 +10,7 @@ import (
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
ethcmn "github.com/ethereum/go-ethereum/common"
ethtypes "github.com/ethereum/go-ethereum/core/types"
@ -164,8 +163,8 @@ func TestMsgEthereumTxRLPDecode(t *testing.T) {
func TestMsgEthereumTxSig(t *testing.T) {
chainID := big.NewInt(3)
priv1, _ := crypto.GenerateKey()
priv2, _ := crypto.GenerateKey()
priv1, _ := ethsecp256k1.GenerateKey()
priv2, _ := ethsecp256k1.GenerateKey()
addr1 := ethcmn.BytesToAddress(priv1.PubKey().Address().Bytes())
addr2 := ethcmn.BytesToAddress(priv2.PubKey().Address().Bytes())

4
x/evm/types/state_transition_test.go
View File

@ -5,7 +5,7 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
ethermint "github.com/cosmos/ethermint/types"
"github.com/cosmos/ethermint/x/evm/types"
@ -22,7 +22,7 @@ func (suite *StateDBTestSuite) TestTransitionDb() {
_ = acc.SetCoins(sdk.NewCoins(balance))
suite.app.AccountKeeper.SetAccount(suite.ctx, acc)
priv, err := crypto.GenerateKey()
priv, err := ethsecp256k1.GenerateKey()
suite.Require().NoError(err)
recipient := ethcrypto.PubkeyToAddress(priv.ToECDSA().PublicKey)

10
x/evm/types/statedb_test.go
View File

@ -15,7 +15,7 @@ import (
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/cosmos/ethermint/app"
"github.com/cosmos/ethermint/crypto"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
ethermint "github.com/cosmos/ethermint/types"
"github.com/cosmos/ethermint/x/evm/types"
@ -43,7 +43,7 @@ func (suite *StateDBTestSuite) SetupTest() {
suite.ctx = suite.app.BaseApp.NewContext(checkTx, abci.Header{Height: 1})
suite.stateDB = suite.app.EvmKeeper.CommitStateDB.WithContext(suite.ctx)
privkey, err := crypto.GenerateKey()
privkey, err := ethsecp256k1.GenerateKey()
suite.Require().NoError(err)
suite.address = ethcmn.BytesToAddress(privkey.PubKey().Address().Bytes())
@ -377,7 +377,7 @@ func (suite *StateDBTestSuite) TestStateDB_CreateAccount() {
}
func (suite *StateDBTestSuite) TestStateDB_ClearStateObj() {
priv, err := crypto.GenerateKey()
priv, err := ethsecp256k1.GenerateKey()
suite.Require().NoError(err)
addr := ethcrypto.PubkeyToAddress(priv.ToECDSA().PublicKey)
@ -390,7 +390,7 @@ func (suite *StateDBTestSuite) TestStateDB_ClearStateObj() {
}
func (suite *StateDBTestSuite) TestStateDB_Reset() {
priv, err := crypto.GenerateKey()
priv, err := ethsecp256k1.GenerateKey()
suite.Require().NoError(err)
addr := ethcrypto.PubkeyToAddress(priv.ToECDSA().PublicKey)
@ -497,7 +497,7 @@ func (suite *StateDBTestSuite) TestSuiteDB_Suicide() {
suite.Require().True(suite.stateDB.HasSuicided(suite.address), tc.name)
} else {
//Suicide only works for an account with non-zero balance/nonce
priv, err := crypto.GenerateKey()
priv, err := ethsecp256k1.GenerateKey()
suite.Require().NoError(err)
addr := ethcrypto.PubkeyToAddress(priv.ToECDSA().PublicKey)

13
x/evm/types/utils.go
View File

@ -5,7 +5,8 @@ import (
"math/big"
"strings"
"github.com/cosmos/ethermint/crypto"
"github.com/pkg/errors"
"golang.org/x/crypto/sha3"
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
@ -16,13 +17,12 @@ import (
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/rlp"
"github.com/pkg/errors"
"golang.org/x/crypto/sha3"
"github.com/cosmos/ethermint/crypto/ethsecp256k1"
)
// GenerateEthAddress generates an Ethereum address.
func GenerateEthAddress() ethcmn.Address {
priv, err := crypto.GenerateKey()
priv, err := ethsecp256k1.GenerateKey()
if err != nil {
panic(err)
}
@ -47,9 +47,8 @@ func ValidateSigner(signBytes, sig []byte, signer ethcmn.Address) error {
func rlpHash(x interface{}) (hash ethcmn.Hash) {
hasher := sha3.NewLegacyKeccak256()
//nolint:gosec,errcheck
rlp.Encode(hasher, x)
hasher.Sum(hash[:0])
_ = rlp.Encode(hasher, x)
_ = hasher.Sum(hash[:0])
return hash
}