cerc-io/laconicd-deprecated
19
0
Fork 1
Code Issues 21 Pull Requests Actions Packages Projects Releases 3 Wiki Activity

renaming from ethermint to laconic #69

Closed
0xmuralik wants to merge 3 commits from murali/minor-changes into main
pull from: murali/minor-changes
merge into: cerc-io:main
Conversation 2 Commits 3 Files Changed 88 +181 -181
52 changed files with 181 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 395b2dcde6 - Show all commits

8
app/ante/eip712.go
View File

@ -15,7 +15,7 @@ import (
"github.com/cerc-io/laconicd/crypto/ethsecp256k1"
"github.com/cerc-io/laconicd/ethereum/eip712"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/crypto/secp256k1"
@ -25,7 +25,7 @@ var ethermintCodec codec.ProtoCodecMarshaler
func init() {
registry := codectypes.NewInterfaceRegistry()
ethermint.RegisterInterfaces(registry)
laconicd.RegisterInterfaces(registry)
ethermintCodec = codec.NewProtoCodec(registry)
}
@ -178,7 +178,7 @@ func VerifySignature(
msgs, tx.GetMemo(), tx.GetTip(),
)
signerChainID, err := ethermint.ParseChainID(signerData.ChainID)
signerChainID, err := laconicd.ParseChainID(signerData.ChainID)
if err != nil {
return sdkerrors.Wrapf(err, "failed to parse chainID: %s", signerData.ChainID)
}
@ -192,7 +192,7 @@ func VerifySignature(
return sdkerrors.Wrap(sdkerrors.ErrUnknownExtensionOptions, "tx doesnt contain expected amount of extension options")
}
extOpt, ok := opts[0].GetCachedValue().(*ethermint.ExtensionOptionsWeb3Tx)
extOpt, ok := opts[0].GetCachedValue().(*laconicd.ExtensionOptionsWeb3Tx)
if !ok {
return sdkerrors.Wrap(sdkerrors.ErrInvalidChainID, "unknown extension option")
}

6
app/ante/eth.go
View File

@ -12,7 +12,7 @@ import (
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
authante "github.com/cosmos/cosmos-sdk/x/auth/ante"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
evmkeeper "github.com/cerc-io/laconicd/x/evm/keeper"
"github.com/cerc-io/laconicd/x/evm/statedb"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
@ -236,7 +236,7 @@ func (egcd EthGasConsumeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simula
ctx.EventManager().EmitEvents(events)
// TODO: deprecate after https://github.com/cosmos/cosmos-sdk/issues/9514 is fixed on SDK
blockGasLimit := ethermint.BlockGasLimit(ctx)
blockGasLimit := laconicd.BlockGasLimit(ctx)
// NOTE: safety check
if blockGasLimit > 0 {
@ -248,7 +248,7 @@ func (egcd EthGasConsumeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simula
// Set ctx.GasMeter with a limit of GasWanted (gasLimit)
gasConsumed := ctx.GasMeter().GasConsumed()
ctx = ctx.WithGasMeter(ethermint.NewInfiniteGasMeterWithLimit(gasWanted))
ctx = ctx.WithGasMeter(laconicd.NewInfiniteGasMeterWithLimit(gasWanted))
ctx.GasMeter().ConsumeGas(gasConsumed, "copy gas consumed")
newCtx := ctx.WithPriority(minPriority)

6
app/ante/fee_checker_test.go
View File

@ -7,7 +7,7 @@ import (
"github.com/stretchr/testify/require"
"github.com/cerc-io/laconicd/encoding"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
"github.com/cerc-io/laconicd/x/evm/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
@ -172,7 +172,7 @@ func TestSDKTxFeeChecker(t *testing.T) {
txBuilder.SetGasLimit(1)
txBuilder.SetFeeAmount(sdk.NewCoins(sdk.NewCoin("aphoton", sdk.NewInt(10).Mul(types.DefaultPriorityReduction))))
option, err := codectypes.NewAnyWithValue(&ethermint.ExtensionOptionDynamicFeeTx{})
option, err := codectypes.NewAnyWithValue(&laconicd.ExtensionOptionDynamicFeeTx{})
require.NoError(t, err)
txBuilder.SetExtensionOptions(option)
return txBuilder.GetTx()
@ -192,7 +192,7 @@ func TestSDKTxFeeChecker(t *testing.T) {
txBuilder.SetGasLimit(1)
txBuilder.SetFeeAmount(sdk.NewCoins(sdk.NewCoin("aphoton", sdk.NewInt(10).Mul(types.DefaultPriorityReduction).Add(sdk.NewInt(10)))))
option, err := codectypes.NewAnyWithValue(&ethermint.ExtensionOptionDynamicFeeTx{
option, err := codectypes.NewAnyWithValue(&laconicd.ExtensionOptionDynamicFeeTx{
MaxPriorityPrice: sdk.NewInt(5).Mul(types.DefaultPriorityReduction),
})
require.NoError(t, err)

4
app/app.go
View File

@ -102,7 +102,7 @@ import (
"github.com/cerc-io/laconicd/app/ante"
srvflags "github.com/cerc-io/laconicd/server/flags"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
"github.com/cerc-io/laconicd/x/evm"
evmkeeper "github.com/cerc-io/laconicd/x/evm/keeper"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
@ -343,7 +343,7 @@ func NewEthermintApp(
app.AccountKeeper = authkeeper.NewAccountKeeper(
appCodec, keys[authtypes.StoreKey],
app.GetSubspace(authtypes.ModuleName),
ethermint.ProtoAccount,
laconicd.ProtoAccount,
maccPerms,
sdk.GetConfig().GetBech32AccountAddrPrefix(),
)

4
app/utils.go
View File

@ -17,7 +17,7 @@ import (
stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
"github.com/cerc-io/laconicd/encoding"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
"github.com/cerc-io/laconicd/crypto/ethsecp256k1"
@ -102,7 +102,7 @@ func RandomGenesisAccounts(simState *module.SimulationState) authtypes.GenesisAc
for i, acc := range simState.Accounts {
bacc := authtypes.NewBaseAccountWithAddress(acc.Address)
ethacc := &ethermint.EthAccount{
ethacc := &laconicd.EthAccount{
BaseAccount: bacc,
CodeHash: common.BytesToHash(emptyCodeHash).String(),
}

6
app/utils_test.go
View File

@ -17,7 +17,7 @@ import (
stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
"github.com/cerc-io/laconicd/crypto/ethsecp256k1"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
@ -40,7 +40,7 @@ func TestRandomGenesisAccounts(t *testing.T) {
subSpace, find := paramsKeeper.GetSubspace(authtypes.ModuleName)
require.True(t, find)
accountKeeper := authkeeper.NewAccountKeeper(
appCodec, sdk.NewKVStoreKey(authtypes.StoreKey), subSpace, ethermint.ProtoAccount, maccPerms, sdk.GetConfig().GetBech32AccountAddrPrefix(),
appCodec, sdk.NewKVStoreKey(authtypes.StoreKey), subSpace, laconicd.ProtoAccount, maccPerms, sdk.GetConfig().GetBech32AccountAddrPrefix(),
)
authModule := auth.NewAppModule(appCodec, accountKeeper, RandomGenesisAccounts)
@ -56,7 +56,7 @@ func TestRandomGenesisAccounts(t *testing.T) {
accounts, err := authtypes.UnpackAccounts(authState.Accounts)
require.NoError(t, err)
for _, acc := range accounts {
_, ok := acc.(ethermint.EthAccountI)
_, ok := acc.(laconicd.EthAccountI)
require.True(t, ok)
}
}

4
client/config.go
View File

@ -12,7 +12,7 @@ import (
"github.com/cosmos/cosmos-sdk/client/flags"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
)
// InitConfig adds the chain-id, encoding and output flags to the persistent flag set.
@ -57,7 +57,7 @@ func ValidateChainID(baseCmd *cobra.Command) *cobra.Command {
validateFn := func(cmd *cobra.Command, args []string) error {
chainID, _ := cmd.Flags().GetString(flags.FlagChainID)
if !ethermint.IsValidChainID(chainID) {
if !laconicd.IsValidChainID(chainID) {
return fmt.Errorf("invalid chain-id format: %s", chainID)
}

4
client/keys/add.go
View File

@ -7,7 +7,7 @@ import (
"fmt"
"sort"
etherminthd "github.com/cerc-io/laconicd/crypto/hd"
laconicdhd "github.com/cerc-io/laconicd/crypto/hd"
bip39 "github.com/cosmos/go-bip39"
"github.com/spf13/cobra"
@ -68,7 +68,7 @@ func RunAddCmd(ctx client.Context, cmd *cobra.Command, args []string, inBuf *buf
if dryRun, _ := cmd.Flags().GetBool(flags.FlagDryRun); dryRun {
// use in memory keybase
kb = keyring.NewInMemory(ctx.Codec, etherminthd.EthSecp256k1Option())
kb = keyring.NewInMemory(ctx.Codec, laconicdhd.EthSecp256k1Option())
} else {
_, err = kb.Key(name)
if err == nil {

20
client/testnet.go
View File

@ -41,7 +41,7 @@ import (
"github.com/cerc-io/laconicd/crypto/hd"
"github.com/cerc-io/laconicd/server/config"
srvflags "github.com/cerc-io/laconicd/server/flags"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
"github.com/cerc-io/laconicd/testutil/network"
@ -91,7 +91,7 @@ func addTestnetFlagsToCmd(cmd *cobra.Command) {
cmd.Flags().String(flags.FlagChainID, "", "genesis file chain-id, if left blank will be randomly created")
cmd.Flags().String(sdkserver.FlagMinGasPrices,
fmt.Sprintf("0.000006%s",
ethermint.AttoPhoton),
laconicd.AttoPhoton),
"Minimum gas prices to accept for transactions; All fees in a tx must meet this minimum (e.g. 0.01photino,0.001stake)")
cmd.Flags().String(flags.FlagKeyAlgorithm, string(hd.EthSecp256k1Type), "Key signing algorithm to generate keys for")
}
@ -215,7 +215,7 @@ func initTestnetFiles(
args initArgs,
) error {
if args.chainID == "" {
args.chainID = fmt.Sprintf("ethermint_%d-1", tmrand.Int63n(9999999999999)+1)
args.chainID = fmt.Sprintf("laconic_%d-1", tmrand.Int63n(9999999999999)+1)
}
nodeIDs := make([]string, args.numValidators)
@ -296,22 +296,22 @@ func initTestnetFiles(
return err
}
accStakingTokens := sdk.TokensFromConsensusPower(5000, ethermint.PowerReduction)
accStakingTokens := sdk.TokensFromConsensusPower(5000, laconicd.PowerReduction)
coins := sdk.Coins{
sdk.NewCoin(ethermint.AttoPhoton, accStakingTokens),
sdk.NewCoin(laconicd.AttoPhoton, accStakingTokens),
}
genBalances = append(genBalances, banktypes.Balance{Address: addr.String(), Coins: coins.Sort()})
genAccounts = append(genAccounts, &ethermint.EthAccount{
genAccounts = append(genAccounts, &laconicd.EthAccount{
BaseAccount: authtypes.NewBaseAccount(addr, nil, 0, 0),
CodeHash: common.BytesToHash(evmtypes.EmptyCodeHash).Hex(),
})
valTokens := sdk.TokensFromConsensusPower(100, ethermint.PowerReduction)
valTokens := sdk.TokensFromConsensusPower(100, laconicd.PowerReduction)
createValMsg, err := stakingtypes.NewMsgCreateValidator(
sdk.ValAddress(addr),
valPubKeys[i],
sdk.NewCoin(ethermint.AttoPhoton, valTokens),
sdk.NewCoin(laconicd.AttoPhoton, valTokens),
stakingtypes.NewDescription(nodeDirName, "", "", "", ""),
stakingtypes.NewCommissionRates(sdk.OneDec(), sdk.OneDec(), sdk.OneDec()),
sdk.OneInt(),
@ -347,7 +347,7 @@ func initTestnetFiles(
return err
}
customAppTemplate, customAppConfig := config.AppConfig(ethermint.AttoPhoton)
customAppTemplate, customAppConfig := config.AppConfig(laconicd.AttoPhoton)
srvconfig.SetConfigTemplate(customAppTemplate)
if err := sdkserver.InterceptConfigsPreRunHandler(cmd, customAppTemplate, customAppConfig, tmconfig.DefaultConfig()); err != nil {
return err
@ -356,7 +356,7 @@ func initTestnetFiles(
srvconfig.WriteConfigFile(filepath.Join(nodeDir, "config/app.toml"), appConfig)
}
if err := initGenFiles(clientCtx, mbm, args.chainID, ethermint.AttoPhoton, genAccounts, genBalances, genFiles, args.numValidators); err != nil {
if err := initGenFiles(clientCtx, mbm, args.chainID, laconicd.AttoPhoton, genAccounts, genBalances, genFiles, args.numValidators); err != nil {
return err
}

8
cmd/config/config.go
View File

@ -3,7 +3,7 @@ package config
import (
sdk "github.com/cosmos/cosmos-sdk/types"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
)
const (
@ -38,9 +38,9 @@ func SetBech32Prefixes(config *sdk.Config) {
// SetBip44CoinType sets the global coin type to be used in hierarchical deterministic wallets.
func SetBip44CoinType(config *sdk.Config) {
config.SetCoinType(ethermint.Bip44CoinType)
config.SetCoinType(laconicd.Bip44CoinType)
config.SetPurpose(sdk.Purpose) // Shared
config.SetFullFundraiserPath(ethermint.BIP44HDPath) //nolint: staticcheck
config.SetFullFundraiserPath(laconicd.BIP44HDPath) //nolint: staticcheck
}
// RegisterDenoms registers the base and display denominations to the SDK.
@ -49,7 +49,7 @@ func RegisterDenoms() {
panic(err)
}
if err := sdk.RegisterDenom(ethermint.AttoPhoton, sdk.NewDecWithPrec(1, ethermint.BaseDenomUnit)); err != nil {
if err := sdk.RegisterDenom(laconicd.AttoPhoton, sdk.NewDecWithPrec(1, laconicd.BaseDenomUnit)); err != nil {
panic(err)
}
}

8
cmd/config/config_test.go
View File

@ -3,7 +3,7 @@ package config
import (
"testing"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
"github.com/stretchr/testify/require"
"github.com/cosmos/cosmos-sdk/crypto/hd"
@ -42,14 +42,14 @@ func TestSetCoinType(t *testing.T) {
require.Equal(t, sdk.FullFundraiserPath, config.GetFullBIP44Path())
SetBip44CoinType(config)
require.Equal(t, int(ethermint.Bip44CoinType), int(config.GetCoinType()))
require.Equal(t, int(laconicd.Bip44CoinType), int(config.GetCoinType()))
require.Equal(t, sdk.GetConfig().GetCoinType(), config.GetCoinType())
require.Equal(t, sdk.GetConfig().GetFullBIP44Path(), config.GetFullBIP44Path())
}
func TestHDPath(t *testing.T) {
params := *hd.NewFundraiserParams(0, ethermint.Bip44CoinType, 0)
params := *hd.NewFundraiserParams(0, laconicd.Bip44CoinType, 0)
hdPath := params.String()
require.Equal(t, "m/44'/60'/0'/0/0", hdPath)
require.Equal(t, hdPath, ethermint.BIP44HDPath)
require.Equal(t, hdPath, laconicd.BIP44HDPath)
}

2
cmd/laconicd/cmd_test.go
View File

@ -18,7 +18,7 @@ func TestInitCmd(t *testing.T) {
rootCmd, _ := laconicd.NewRootCmd()
rootCmd.SetArgs([]string{
"init", // Test the init cmd
"etherminttest", // Moniker
"laconicdtest", // Moniker
fmt.Sprintf("--%s=%s", cli.FlagOverwrite, "true"), // Overwrite genesis.json, in case it already exists
fmt.Sprintf("--%s=%s", flags.FlagChainID, "laconic_9000-1"),
})

4
cmd/laconicd/genaccounts.go
View File

@ -19,7 +19,7 @@ import (
genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types"
"github.com/cerc-io/laconicd/crypto/hd"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
)
@ -114,7 +114,7 @@ contain valid denominations. Accounts may optionally be supplied with vesting pa
return errors.New("invalid vesting parameters; must supply start and end time or end time")
}
} else {
genAccount = &ethermint.EthAccount{
genAccount = &laconicd.EthAccount{
BaseAccount: baseAccount,
CodeHash: common.BytesToHash(evmtypes.EmptyCodeHash).Hex(),
}

14
cmd/laconicd/root.go
View File

@ -33,14 +33,14 @@ import (
genutilcli "github.com/cosmos/cosmos-sdk/x/genutil/client/cli"
"github.com/cerc-io/laconicd/app"
ethermintclient "github.com/cerc-io/laconicd/client"
laconicdclient "github.com/cerc-io/laconicd/client"
"github.com/cerc-io/laconicd/client/debug"
"github.com/cerc-io/laconicd/crypto/hd"
"github.com/cerc-io/laconicd/encoding"
"github.com/cerc-io/laconicd/server"
servercfg "github.com/cerc-io/laconicd/server/config"
srvflags "github.com/cerc-io/laconicd/server/flags"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
)
const EnvPrefix = "ETHERMINT"
@ -63,7 +63,7 @@ func NewRootCmd() (*cobra.Command, params.EncodingConfig) {
rootCmd := &cobra.Command{
Use: "laconicd",
Short: "Ethermint Daemon",
Short: "Laconic Daemon",
PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
// set the default command outputs
cmd.SetOut(cmd.OutOrStdout())
@ -84,7 +84,7 @@ func NewRootCmd() (*cobra.Command, params.EncodingConfig) {
}
// FIXME: replace AttoPhoton with bond denom
customAppTemplate, customAppConfig := servercfg.AppConfig(ethermint.AttoPhoton)
customAppTemplate, customAppConfig := servercfg.AppConfig(laconicd.AttoPhoton)
return sdkserver.InterceptConfigsPreRunHandler(cmd, customAppTemplate, customAppConfig, tmcfg.DefaultConfig())
},
@ -97,7 +97,7 @@ func NewRootCmd() (*cobra.Command, params.EncodingConfig) {
cfg.Seal()
rootCmd.AddCommand(
ethermintclient.ValidateChainID(
laconicdclient.ValidateChainID(
genutilcli.InitCmd(app.ModuleBasics, app.DefaultNodeHome),
),
genutilcli.CollectGenTxsCmd(banktypes.GenesisBalancesIterator{}, app.DefaultNodeHome),
@ -106,7 +106,7 @@ func NewRootCmd() (*cobra.Command, params.EncodingConfig) {
genutilcli.ValidateGenesisCmd(app.ModuleBasics),
AddGenesisAccountCmd(app.DefaultNodeHome),
tmcli.NewCompletionCmd(rootCmd, true),
ethermintclient.NewTestnetCmd(app.ModuleBasics, banktypes.GenesisBalancesIterator{}),
laconicdclient.NewTestnetCmd(app.ModuleBasics, banktypes.GenesisBalancesIterator{}),
debug.Cmd(),
config.Cmd(),
)
@ -119,7 +119,7 @@ func NewRootCmd() (*cobra.Command, params.EncodingConfig) {
rpc.StatusCommand(),
queryCommand(),
txCommand(),
ethermintclient.KeyCommands(app.DefaultNodeHome),
laconicdclient.KeyCommands(app.DefaultNodeHome),
)
rootCmd, err := srvflags.AddTxFlags(rootCmd)

10
crypto/hd/algorithm_test.go
View File

@ -17,7 +17,7 @@ import (
cryptocodec "github.com/cerc-io/laconicd/crypto/codec"
enccodec "github.com/cerc-io/laconicd/encoding/codec"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
)
var TestCodec codec.Codec
@ -46,7 +46,7 @@ func TestKeyring(t *testing.T) {
require.Nil(t, info)
mockIn.Reset("password\npassword\n")
info, mnemonic, err := kr.NewMnemonic("foo", keyring.English, ethermint.BIP44HDPath, keyring.DefaultBIP39Passphrase, EthSecp256k1)
info, mnemonic, err := kr.NewMnemonic("foo", keyring.English, laconicd.BIP44HDPath, keyring.DefaultBIP39Passphrase, EthSecp256k1)
require.NoError(t, err)
require.NotEmpty(t, mnemonic)
require.Equal(t, "foo", info.Name)
@ -55,7 +55,7 @@ func TestKeyring(t *testing.T) {
require.NoError(t, err)
require.Equal(t, string(EthSecp256k1Type), pubKey.Type())
hdPath := ethermint.BIP44HDPath
hdPath := laconicd.BIP44HDPath
bz, err := EthSecp256k1.Derive()(mnemonic, keyring.DefaultBIP39Passphrase, hdPath)
require.NoError(t, err)
@ -79,7 +79,7 @@ func TestKeyring(t *testing.T) {
}
func TestDerivation(t *testing.T) {
bz, err := EthSecp256k1.Derive()(mnemonic, keyring.DefaultBIP39Passphrase, ethermint.BIP44HDPath)
bz, err := EthSecp256k1.Derive()(mnemonic, keyring.DefaultBIP39Passphrase, laconicd.BIP44HDPath)
require.NoError(t, err)
require.NotEmpty(t, bz)
@ -97,7 +97,7 @@ func TestDerivation(t *testing.T) {
wallet, err := hdwallet.NewFromMnemonic(mnemonic)
require.NoError(t, err)
path := hdwallet.MustParseDerivationPath(ethermint.BIP44HDPath)
path := hdwallet.MustParseDerivationPath(laconicd.BIP44HDPath)
account, err := wallet.Derive(path, false)
require.NoError(t, err)

6
crypto/hd/benchmark_test.go
View File

@ -3,7 +3,7 @@ package hd
import (
"testing"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
"github.com/cosmos/cosmos-sdk/crypto/keyring"
)
@ -11,14 +11,14 @@ 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 {
if _, err := deriveFn(mnemonic, keyring.DefaultBIP39Passphrase, laconicd.BIP44HDPath); err != nil {
b.Fatal(err)
}
}
}
func BenchmarkEthSecp256k1Algo_Generate(b *testing.B) {
bz, err := EthSecp256k1.Derive()(mnemonic, keyring.DefaultBIP39Passphrase, ethermint.BIP44HDPath)
bz, err := EthSecp256k1.Derive()(mnemonic, keyring.DefaultBIP39Passphrase, laconicd.BIP44HDPath)
if err != nil {
b.Fatal(err)
}

4
encoding/codec/codec.go
View File

@ -7,7 +7,7 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
cryptocodec "github.com/cerc-io/laconicd/crypto/codec"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
)
// RegisterLegacyAminoCodec registers Interfaces from types, crypto, and SDK std.
@ -21,5 +21,5 @@ func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
func RegisterInterfaces(interfaceRegistry codectypes.InterfaceRegistry) {
std.RegisterInterfaces(interfaceRegistry)
cryptocodec.RegisterInterfaces(interfaceRegistry)
ethermint.RegisterInterfaces(interfaceRegistry)
laconicd.RegisterInterfaces(interfaceRegistry)
}

14
indexer/kv_indexer.go
View File

@ -15,7 +15,7 @@ import (
tmtypes "github.com/tendermint/tendermint/types"
dbm "github.com/tendermint/tm-db"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
)
@ -27,7 +27,7 @@ const (
TxIndexKeyLength = 1 + 8 + 8
)
var _ ethermint.EVMTxIndexer = &KVIndexer{}
var _ laconicd.EVMTxIndexer = &KVIndexer{}
// KVIndexer implements a eth tx indexer on a KV db.
type KVIndexer struct {
@ -81,7 +81,7 @@ func (kv *KVIndexer) IndexBlock(block *tmtypes.Block, txResults []*abci.Response
ethMsg := msg.(*evmtypes.MsgEthereumTx)
txHash := common.HexToHash(ethMsg.Hash)
txResult := ethermint.TxResult{
txResult := laconicd.TxResult{
Height: height,
TxIndex: uint32(txIndex),
MsgIndex: uint32(msgIndex),
@ -131,7 +131,7 @@ func (kv *KVIndexer) FirstIndexedBlock() (int64, error) {
}
// GetByTxHash finds eth tx by eth tx hash
func (kv *KVIndexer) GetByTxHash(hash common.Hash) (*ethermint.TxResult, error) {
func (kv *KVIndexer) GetByTxHash(hash common.Hash) (*laconicd.TxResult, error) {
bz, err := kv.db.Get(TxHashKey(hash))
if err != nil {
return nil, sdkerrors.Wrapf(err, "GetByTxHash %s", hash.Hex())
@ -139,7 +139,7 @@ func (kv *KVIndexer) GetByTxHash(hash common.Hash) (*ethermint.TxResult, error)
if len(bz) == 0 {
return nil, fmt.Errorf("tx not found, hash: %s", hash.Hex())
}
var txKey ethermint.TxResult
var txKey laconicd.TxResult
if err := kv.clientCtx.Codec.Unmarshal(bz, &txKey); err != nil {
return nil, sdkerrors.Wrapf(err, "GetByTxHash %s", hash.Hex())
}
@ -147,7 +147,7 @@ func (kv *KVIndexer) GetByTxHash(hash common.Hash) (*ethermint.TxResult, error)
}
// GetByBlockAndIndex finds eth tx by block number and eth tx index
func (kv *KVIndexer) GetByBlockAndIndex(blockNumber int64, txIndex int32) (*ethermint.TxResult, error) {
func (kv *KVIndexer) GetByBlockAndIndex(blockNumber int64, txIndex int32) (*laconicd.TxResult, error) {
bz, err := kv.db.Get(TxIndexKey(blockNumber, txIndex))
if err != nil {
return nil, sdkerrors.Wrapf(err, "GetByBlockAndIndex %d %d", blockNumber, txIndex)
@ -210,7 +210,7 @@ func isEthTx(tx sdk.Tx) bool {
}
// saveTxResult index the txResult into the kv db batch
func saveTxResult(codec codec.Codec, batch dbm.Batch, txHash common.Hash, txResult *ethermint.TxResult) error {
func saveTxResult(codec codec.Codec, batch dbm.Batch, txHash common.Hash, txResult *laconicd.TxResult) error {
bz := codec.MustMarshal(txResult)
if err := batch.Set(TxHashKey(txHash), bz); err != nil {
return sdkerrors.Wrap(err, "set tx-hash key")

20
rpc/apis.go
View File

@ -19,7 +19,7 @@ import (
"github.com/cerc-io/laconicd/rpc/namespaces/ethereum/personal"
"github.com/cerc-io/laconicd/rpc/namespaces/ethereum/txpool"
"github.com/cerc-io/laconicd/rpc/namespaces/ethereum/web3"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
rpcclient "github.com/tendermint/tendermint/rpc/jsonrpc/client"
)
@ -49,7 +49,7 @@ type APICreator = func(
clientCtx client.Context,
tendermintWebsocketClient *rpcclient.WSClient,
allowUnprotectedTxs bool,
indexer ethermint.EVMTxIndexer,
indexer laconicd.EVMTxIndexer,
) []rpc.API
// apiCreators defines the JSON-RPC API namespaces.
@ -61,7 +61,7 @@ func init() {
clientCtx client.Context,
tmWSClient *rpcclient.WSClient,
allowUnprotectedTxs bool,
indexer ethermint.EVMTxIndexer,
indexer laconicd.EVMTxIndexer,
) []rpc.API {
evmBackend := backend.NewBackend(ctx, ctx.Logger, clientCtx, allowUnprotectedTxs, indexer)
return []rpc.API{
@ -79,7 +79,7 @@ func init() {
},
}
},
Web3Namespace: func(*server.Context, client.Context, *rpcclient.WSClient, bool, ethermint.EVMTxIndexer) []rpc.API {
Web3Namespace: func(*server.Context, client.Context, *rpcclient.WSClient, bool, laconicd.EVMTxIndexer) []rpc.API {
return []rpc.API{
{
Namespace: Web3Namespace,
@ -89,7 +89,7 @@ func init() {
},
}
},
NetNamespace: func(_ *server.Context, clientCtx client.Context, _ *rpcclient.WSClient, _ bool, _ ethermint.EVMTxIndexer) []rpc.API {
NetNamespace: func(_ *server.Context, clientCtx client.Context, _ *rpcclient.WSClient, _ bool, _ laconicd.EVMTxIndexer) []rpc.API {
return []rpc.API{
{
Namespace: NetNamespace,
@ -103,7 +103,7 @@ func init() {
clientCtx client.Context,
_ *rpcclient.WSClient,
allowUnprotectedTxs bool,
indexer ethermint.EVMTxIndexer,
indexer laconicd.EVMTxIndexer,
) []rpc.API {
evmBackend := backend.NewBackend(ctx, ctx.Logger, clientCtx, allowUnprotectedTxs, indexer)
return []rpc.API{
@ -115,7 +115,7 @@ func init() {
},
}
},
TxPoolNamespace: func(ctx *server.Context, _ client.Context, _ *rpcclient.WSClient, _ bool, _ ethermint.EVMTxIndexer) []rpc.API {
TxPoolNamespace: func(ctx *server.Context, _ client.Context, _ *rpcclient.WSClient, _ bool, _ laconicd.EVMTxIndexer) []rpc.API {
return []rpc.API{
{
Namespace: TxPoolNamespace,
@ -129,7 +129,7 @@ func init() {
clientCtx client.Context,
_ *rpcclient.WSClient,
allowUnprotectedTxs bool,
indexer ethermint.EVMTxIndexer,
indexer laconicd.EVMTxIndexer,
) []rpc.API {
evmBackend := backend.NewBackend(ctx, ctx.Logger, clientCtx, allowUnprotectedTxs, indexer)
return []rpc.API{
@ -145,7 +145,7 @@ func init() {
clientCtx client.Context,
_ *rpcclient.WSClient,
allowUnprotectedTxs bool,
indexer ethermint.EVMTxIndexer,
indexer laconicd.EVMTxIndexer,
) []rpc.API {
evmBackend := backend.NewBackend(ctx, ctx.Logger, clientCtx, allowUnprotectedTxs, indexer)
return []rpc.API{
@ -165,7 +165,7 @@ func GetRPCAPIs(ctx *server.Context,
clientCtx client.Context,
tmWSClient *rpcclient.WSClient,
allowUnprotectedTxs bool,
indexer ethermint.EVMTxIndexer,
indexer laconicd.EVMTxIndexer,
selectedAPIs []string,
) []rpc.API {
var apis []rpc.API

12
rpc/backend/backend.go
View File

@ -8,7 +8,7 @@ import (
"github.com/cerc-io/laconicd/crypto/hd"
rpctypes "github.com/cerc-io/laconicd/rpc/types"
"github.com/cerc-io/laconicd/server/config"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/client/flags"
@ -103,8 +103,8 @@ type EVMBackend interface {
// Tx Info
GetTransactionByHash(txHash common.Hash) (*rpctypes.RPCTransaction, error)
GetTxByEthHash(txHash common.Hash) (*ethermint.TxResult, error)
GetTxByTxIndex(height int64, txIndex uint) (*ethermint.TxResult, error)
GetTxByEthHash(txHash common.Hash) (*laconicd.TxResult, error)
GetTxByTxIndex(height int64, txIndex uint) (*laconicd.TxResult, error)
GetTransactionByBlockAndIndex(block *tmrpctypes.ResultBlock, idx hexutil.Uint) (*rpctypes.RPCTransaction, error)
GetTransactionReceipt(hash common.Hash) (map[string]interface{}, error)
GetTransactionByBlockHashAndIndex(hash common.Hash, idx hexutil.Uint) (*rpctypes.RPCTransaction, error)
@ -141,7 +141,7 @@ type Backend struct {
chainID *big.Int
cfg config.Config
allowUnprotectedTxs bool
indexer ethermint.EVMTxIndexer
indexer laconicd.EVMTxIndexer
}
// NewBackend creates a new Backend instance for cosmos and ethereum namespaces
@ -150,9 +150,9 @@ func NewBackend(
logger log.Logger,
clientCtx client.Context,
allowUnprotectedTxs bool,
indexer ethermint.EVMTxIndexer,
indexer laconicd.EVMTxIndexer,
) *Backend {
chainID, err := ethermint.ParseChainID(clientCtx.ChainID)
chainID, err := laconicd.ParseChainID(clientCtx.ChainID)
if err != nil {
panic(err)
}

4
rpc/backend/call_tx.go
View File

@ -8,7 +8,7 @@ import (
"math/big"
rpctypes "github.com/cerc-io/laconicd/rpc/types"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
"github.com/cosmos/cosmos-sdk/client/flags"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
@ -35,7 +35,7 @@ func (b *Backend) Resend(args evmtypes.TransactionArgs, gasPrice *hexutil.Big, g
// The signer used should always be the 'latest' known one because we expect
// signers to be backwards-compatible with old transactions.
eip155ChainID, err := ethermint.ParseChainID(b.clientCtx.ChainID)
eip155ChainID, err := laconicd.ParseChainID(b.clientCtx.ChainID)
if err != nil {
return common.Hash{}, err
}

4
rpc/backend/chain_info.go
View File

@ -6,7 +6,7 @@ import (
"strconv"
rpctypes "github.com/cerc-io/laconicd/rpc/types"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
feemarkettypes "github.com/cerc-io/laconicd/x/feemarket/types"
sdk "github.com/cosmos/cosmos-sdk/types"
@ -19,7 +19,7 @@ import (
// ChainID is the EIP-155 replay-protection chain id for the current ethereum chain config.
func (b *Backend) ChainID() (*hexutil.Big, error) {
eip155ChainID, err := ethermint.ParseChainID(b.clientCtx.ChainID)
eip155ChainID, err := laconicd.ParseChainID(b.clientCtx.ChainID)
if err != nil {
panic(err)
}

6
rpc/backend/node_info.go
View File

@ -9,7 +9,7 @@ import (
"github.com/cerc-io/laconicd/crypto/ethsecp256k1"
rpctypes "github.com/cerc-io/laconicd/rpc/types"
"github.com/cerc-io/laconicd/server/config"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
"github.com/cosmos/cosmos-sdk/client/flags"
"github.com/cosmos/cosmos-sdk/client/tx"
@ -326,13 +326,13 @@ func (b *Backend) RPCBlockRangeCap() int32 {
func (b *Backend) RPCMinGasPrice() int64 {
evmParams, err := b.queryClient.Params(b.ctx, &evmtypes.QueryParamsRequest{})
if err != nil {
return ethermint.DefaultGasPrice
return laconicd.DefaultGasPrice
}
minGasPrice := b.cfg.GetMinGasPrices()
amt := minGasPrice.AmountOf(evmParams.Params.EvmDenom).TruncateInt64()
if amt == 0 {
return ethermint.DefaultGasPrice
return laconicd.DefaultGasPrice
}
return amt

8
rpc/backend/tx_info.go
View File

@ -4,7 +4,7 @@ import (
"fmt"
rpctypes "github.com/cerc-io/laconicd/rpc/types"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
@ -277,7 +277,7 @@ func (b *Backend) GetTransactionByBlockNumberAndIndex(blockNum rpctypes.BlockNum
// GetTxByEthHash uses `/tx_query` to find transaction by ethereum tx hash
// TODO: Don't need to convert once hashing is fixed on Tendermint
// https://github.com/tendermint/tendermint/issues/6539
func (b *Backend) GetTxByEthHash(hash common.Hash) (*ethermint.TxResult, error) {
func (b *Backend) GetTxByEthHash(hash common.Hash) (*laconicd.TxResult, error) {
if b.indexer != nil {
return b.indexer.GetByTxHash(hash)
}
@ -294,7 +294,7 @@ func (b *Backend) GetTxByEthHash(hash common.Hash) (*ethermint.TxResult, error)
}
// GetTxByTxIndex uses `/tx_query` to find transaction by tx index of valid ethereum txs
func (b *Backend) GetTxByTxIndex(height int64, index uint) (*ethermint.TxResult, error) {
func (b *Backend) GetTxByTxIndex(height int64, index uint) (*laconicd.TxResult, error) {
if b.indexer != nil {
return b.indexer.GetByBlockAndIndex(height, int32(index))
}
@ -314,7 +314,7 @@ func (b *Backend) GetTxByTxIndex(height int64, index uint) (*ethermint.TxResult,
}
// queryTendermintTxIndexer query tx in tendermint tx indexer
func (b *Backend) queryTendermintTxIndexer(query string, txGetter func(*rpctypes.ParsedTxs) *rpctypes.ParsedTx) (*ethermint.TxResult, error) {
func (b *Backend) queryTendermintTxIndexer(query string, txGetter func(*rpctypes.ParsedTxs) *rpctypes.ParsedTx) (*laconicd.TxResult, error) {
resTxs, err := b.clientCtx.Client.TxSearch(b.ctx, query, false, nil, nil, "")
if err != nil {
return nil, err

4
rpc/namespaces/ethereum/eth/api.go
View File

@ -16,7 +16,7 @@ import (
"github.com/cerc-io/laconicd/rpc/backend"
rpctypes "github.com/cerc-io/laconicd/rpc/types"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
)
@ -293,7 +293,7 @@ func (e *PublicAPI) Call(args evmtypes.TransactionArgs,
// ProtocolVersion returns the supported Ethereum protocol version.
func (e *PublicAPI) ProtocolVersion() hexutil.Uint {
e.logger.Debug("eth_protocolVersion")
return hexutil.Uint(ethermint.ProtocolVersion)
return hexutil.Uint(laconicd.ProtocolVersion)
}
// GasPrice returns the current gas price based on Ethermint's gas price oracle.

4
rpc/namespaces/ethereum/net/api.go
View File

@ -4,7 +4,7 @@ import (
"context"
"fmt"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
"github.com/cosmos/cosmos-sdk/client"
rpcclient "github.com/tendermint/tendermint/rpc/client"
)
@ -18,7 +18,7 @@ type PublicAPI struct {
// NewPublicAPI creates an instance of the public Net Web3 API.
func NewPublicAPI(clientCtx client.Context) *PublicAPI {
// parse the chainID from a integer string
chainIDEpoch, err := ethermint.ParseChainID(clientCtx.ChainID)
chainIDEpoch, err := laconicd.ParseChainID(clientCtx.ChainID)
if err != nil {
panic(err)
}

6
rpc/namespaces/ethereum/personal/api.go
View File

@ -9,7 +9,7 @@ import (
"github.com/cerc-io/laconicd/rpc/backend"
"github.com/cerc-io/laconicd/crypto/hd"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
"github.com/tendermint/tendermint/libs/log"
@ -28,7 +28,7 @@ import (
type PrivateAccountAPI struct {
backend backend.EVMBackend
logger log.Logger
hdPathIter ethermint.HDPathIterator
hdPathIter laconicd.HDPathIterator
}
// NewAPI creates an instance of the public Personal Eth API.
@ -39,7 +39,7 @@ func NewAPI(
cfg := sdk.GetConfig()
basePath := cfg.GetFullBIP44Path()
iterator, err := ethermint.NewHDPathIterator(basePath, true)
iterator, err := laconicd.NewHDPathIterator(basePath, true)
if err != nil {
panic(err)
}

4
rpc/types/block.go
View File

@ -17,7 +17,7 @@ import (
grpctypes "github.com/cosmos/cosmos-sdk/types/grpc"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
)
// BlockNumber represents decoding hex string to block values
@ -182,7 +182,7 @@ func (bnh *BlockNumberOrHash) decodeFromString(input string) error {
return err
}
bnInt, err := ethermint.SafeInt64(blockNumber)
bnInt, err := laconicd.SafeInt64(blockNumber)
if err != nil {
return err
}

6
rpc/types/events.go
View File

@ -4,7 +4,7 @@ import (
"fmt"
"strconv"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/ethereum/go-ethereum/common"
@ -137,7 +137,7 @@ func ParseTxResult(result *abci.ResponseDeliverTx, tx sdk.Tx) (*ParsedTxs, error
}
// ParseTxIndexerResult parse tm tx result to a format compatible with the custom tx indexer.
func ParseTxIndexerResult(txResult *tmrpctypes.ResultTx, tx sdk.Tx, getter func(*ParsedTxs) *ParsedTx) (*ethermint.TxResult, error) {
func ParseTxIndexerResult(txResult *tmrpctypes.ResultTx, tx sdk.Tx, getter func(*ParsedTxs) *ParsedTx) (*laconicd.TxResult, error) {
txs, err := ParseTxResult(&txResult.TxResult, tx)
if err != nil {
return nil, fmt.Errorf("failed to parse tx events: block %d, index %d, %v", txResult.Height, txResult.Index, err)
@ -148,7 +148,7 @@ func ParseTxIndexerResult(txResult *tmrpctypes.ResultTx, tx sdk.Tx, getter func(
return nil, fmt.Errorf("ethereum tx not found in msgs: block %d, index %d", txResult.Height, txResult.Index)
}
return &ethermint.TxResult{
return &laconicd.TxResult{
Height: txResult.Height,
TxIndex: txResult.Index,
MsgIndex: uint32(parsedTx.MsgIndex),

6
server/indexer_service.go
View File

@ -8,7 +8,7 @@ import (
rpcclient "github.com/tendermint/tendermint/rpc/client"
"github.com/tendermint/tendermint/types"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
)
const (
@ -21,13 +21,13 @@ const (
type EVMIndexerService struct {
service.BaseService
txIdxr ethermint.EVMTxIndexer
txIdxr laconicd.EVMTxIndexer
client rpcclient.Client
}
// NewEVMIndexerService returns a new service instance.
func NewEVMIndexerService(
txIdxr ethermint.EVMTxIndexer,
txIdxr laconicd.EVMTxIndexer,
client rpcclient.Client,
) *EVMIndexerService {
is := &EVMIndexerService{txIdxr: txIdxr, client: client}

4
server/json_rpc.go
View File

@ -15,7 +15,7 @@ import (
ethrpc "github.com/ethereum/go-ethereum/rpc"
"github.com/cerc-io/laconicd/server/config"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
)
// StartJSONRPC starts the JSON-RPC server
@ -24,7 +24,7 @@ func StartJSONRPC(ctx *server.Context,
tmRPCAddr,
tmEndpoint string,
config *config.Config,
indexer ethermint.EVMTxIndexer,
indexer laconicd.EVMTxIndexer,
) (*http.Server, chan struct{}, error) {
tmWsClient := ConnectTmWS(tmRPCAddr, tmEndpoint, ctx.Logger)

4
server/start.go
View File

@ -48,7 +48,7 @@ import (
ethdebug "github.com/cerc-io/laconicd/rpc/namespaces/ethereum/debug"
"github.com/cerc-io/laconicd/server/config"
srvflags "github.com/cerc-io/laconicd/server/flags"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
)
// StartCmd runs the service passed in, either stand-alone or in-process with
@ -341,7 +341,7 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty
app.RegisterTendermintService(clientCtx)
}
var idxer ethermint.EVMTxIndexer
var idxer laconicd.EVMTxIndexer
if config.JSONRPC.EnableIndexer {
idxDB, err := OpenIndexerDB(home, server.GetAppDBBackend(ctx.Viper))
if err != nil {

8
tests/e2e/integration_test.go
View File

@ -31,7 +31,7 @@ import (
"github.com/cerc-io/laconicd/server/config"
"github.com/cerc-io/laconicd/testutil/network"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
)
// var _ = Describe("E2e", func() {
@ -84,7 +84,7 @@ func (s *IntegrationTestSuite) SetupSuite() {
s.rpcClient = rpcClient
s.gethClient = gethclient.New(rpcClient)
s.Require().NotNil(s.gethClient)
chainId, err := ethermint.ParseChainID(s.cfg.ChainID)
chainId, err := laconicd.ParseChainID(s.cfg.ChainID)
s.Require().NoError(err)
s.ethSigner = ethtypes.LatestSignerForChainID(chainId)
}
@ -99,9 +99,9 @@ func (s *IntegrationTestSuite) TestChainID() {
s.T().Log(chainID.Int64())
eip155ChainID, err := ethermint.ParseChainID(s.network.Config.ChainID)
eip155ChainID, err := laconicd.ParseChainID(s.network.Config.ChainID)
s.Require().NoError(err)
eip155ChainIDGen, err := ethermint.ParseChainID(genesisRes.Genesis.ChainID)
eip155ChainIDGen, err := laconicd.ParseChainID(genesisRes.Genesis.ChainID)
s.Require().NoError(err)
s.Require().Equal(chainID, eip155ChainID)

4
tests/rpc/rpc_test.go
View File

@ -18,7 +18,7 @@ import (
"github.com/stretchr/testify/require"
rpctypes "github.com/cerc-io/laconicd/rpc/types"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
"github.com/ethereum/go-ethereum/common"
@ -134,7 +134,7 @@ func callWithError(method string, params interface{}) (*Response, error) {
}
func TestEth_protocolVersion(t *testing.T) {
expectedRes := hexutil.Uint(ethermint.ProtocolVersion)
expectedRes := hexutil.Uint(laconicd.ProtocolVersion)
rpcRes := call(t, "eth_protocolVersion", []string{})

20
testutil/network/network.go
View File

@ -52,7 +52,7 @@ import (
"github.com/cerc-io/laconicd/crypto/hd"
"github.com/cerc-io/laconicd/encoding"
"github.com/cerc-io/laconicd/server/config"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
"github.com/cerc-io/laconicd/app"
@ -122,13 +122,13 @@ func DefaultConfig() Config {
AppConstructor: NewAppConstructor(encCfg),
GenesisState: app.ModuleBasics.DefaultGenesis(encCfg.Codec),
TimeoutCommit: 2 * time.Second,
ChainID: fmt.Sprintf("ethermint_%d-1", tmrand.Int63n(9999999999999)+1),
ChainID: fmt.Sprintf("laconic_%d-1", tmrand.Int63n(9999999999999)+1),
NumValidators: 4,
BondDenom: ethermint.AttoPhoton,
MinGasPrices: fmt.Sprintf("0.000006%s", ethermint.AttoPhoton),
AccountTokens: sdk.TokensFromConsensusPower(1000, ethermint.PowerReduction),
StakingTokens: sdk.TokensFromConsensusPower(500, ethermint.PowerReduction),
BondedTokens: sdk.TokensFromConsensusPower(100, ethermint.PowerReduction),
BondDenom: laconicd.AttoPhoton,
MinGasPrices: fmt.Sprintf("0.000006%s", laconicd.AttoPhoton),
AccountTokens: sdk.TokensFromConsensusPower(1000, laconicd.PowerReduction),
StakingTokens: sdk.TokensFromConsensusPower(500, laconicd.PowerReduction),
BondedTokens: sdk.TokensFromConsensusPower(100, laconicd.PowerReduction),
PruningStrategy: pruningtypes.PruningOptionNothing,
CleanupDir: true,
SigningAlgo: string(hd.EthSecp256k1Type),
@ -218,7 +218,7 @@ func New(l Logger, baseDir string, cfg Config) (*Network, error) {
l.Log("acquiring test network lock")
lock.Lock()
if !ethermint.IsValidChainID(cfg.ChainID) {
if !laconicd.IsValidChainID(cfg.ChainID) {
return nil, fmt.Errorf("invalid chain-id: %s", cfg.ChainID)
}
@ -412,7 +412,7 @@ func New(l Logger, baseDir string, cfg Config) (*Network, error) {
genFiles = append(genFiles, tmCfg.GenesisFile())
genBalances = append(genBalances, banktypes.Balance{Address: addr.String(), Coins: balances.Sort()})
genAccounts = append(genAccounts, &ethermint.EthAccount{
genAccounts = append(genAccounts, &laconicd.EthAccount{
BaseAccount: authtypes.NewBaseAccount(addr, nil, 0, 0),
CodeHash: common.BytesToHash(evmtypes.EmptyCodeHash).Hex(),
})
@ -470,7 +470,7 @@ func New(l Logger, baseDir string, cfg Config) (*Network, error) {
return nil, err
}
customAppTemplate, _ := config.AppConfig(ethermint.AttoPhoton)
customAppTemplate, _ := config.AppConfig(laconicd.AttoPhoton)
srvconfig.SetConfigTemplate(customAppTemplate)
srvconfig.WriteConfigFile(filepath.Join(nodeDir, "config/app.toml"), appCfg)

4
types/account_test.go
View File

@ -14,7 +14,7 @@ import (
cryptocodec "github.com/cerc-io/laconicd/crypto/codec"
"github.com/cerc-io/laconicd/crypto/ethsecp256k1"
ethermintcodec "github.com/cerc-io/laconicd/encoding/codec"
laconicdcodec "github.com/cerc-io/laconicd/encoding/codec"
"github.com/cerc-io/laconicd/types"
)
@ -42,7 +42,7 @@ func (suite *AccountTestSuite) SetupTest() {
}
interfaceRegistry := codectypes.NewInterfaceRegistry()
ethermintcodec.RegisterInterfaces(interfaceRegistry)
laconicdcodec.RegisterInterfaces(interfaceRegistry)
suite.cdc = codec.NewProtoCodec(interfaceRegistry)
}

2
types/benchmark_test.go
View File

@ -9,7 +9,7 @@ func BenchmarkParseChainID(b *testing.B) {
b.ReportAllocs()
// Start at 1, for valid EIP155, see regexEIP155 variable.
for i := 1; i < b.N; i++ {
chainID := fmt.Sprintf("ethermint_1-%d", i)
chainID := fmt.Sprintf("laconic_1-%d", i)
if _, err := ParseChainID(chainID); err != nil {
b.Fatal(err)
}

6
types/chain_id.go
View File

@ -15,7 +15,7 @@ var (
regexEIP155 = `[1-9][0-9]*`
regexEpochSeparator = `-{1}`
regexEpoch = `[1-9][0-9]*`
ethermintChainID = regexp.MustCompile(fmt.Sprintf(`^(%s)%s(%s)%s(%s)$`,
laconicChainID = regexp.MustCompile(fmt.Sprintf(`^(%s)%s(%s)%s(%s)$`,
regexChainID,
regexEIP155Separator,
regexEIP155,
@ -29,7 +29,7 @@ func IsValidChainID(chainID string) bool {
return false
}
return ethermintChainID.MatchString(chainID)
return laconicChainID.MatchString(chainID)
}
// ParseChainID parses a string chain identifier's epoch to an Ethereum-compatible
@ -40,7 +40,7 @@ func ParseChainID(chainID string) (*big.Int, error) {
return nil, sdkerrors.Wrapf(ErrInvalidChainID, "chain-id '%s' cannot exceed 48 chars", chainID)
}
matches := ethermintChainID.FindStringSubmatch(chainID)
matches := laconicChainID.FindStringSubmatch(chainID)
if matches == nil || len(matches) != 4 || matches[1] == "" {
return nil, sdkerrors.Wrapf(ErrInvalidChainID, "%s: %v", chainID, matches)
}

14
types/chain_id_test.go
View File

@ -16,7 +16,7 @@ func TestParseChainID(t *testing.T) {
expInt *big.Int
}{
{
"valid chain-id, single digit", "ethermint_1-1", false, big.NewInt(1),
"valid chain-id, single digit", "laconic_1-1", false, big.NewInt(1),
},
{
"valid chain-id, multiple digits", "aragonchain_256-1", false, big.NewInt(256),
@ -37,25 +37,25 @@ func TestParseChainID(t *testing.T) {
"invalid chain-id, undefined identifier", "_1-1", true, nil,
},
{
"invalid chain-id, uppercases", "ETHERMINT_1-1", true, nil,
"invalid chain-id, uppercases", "LACONIC_1-1", true, nil,
},
{
"invalid chain-id, mixed cases", "Ethermint_1-1", true, nil,
"invalid chain-id, mixed cases", "Laconic_1-1", true, nil,
},
{
"invalid chain-id, special chars", "$&*#!_1-1", true, nil,
},
{
"invalid eip155 chain-id, cannot start with 0", "ethermint_001-1", true, nil,
"invalid eip155 chain-id, cannot start with 0", "laconic_001-1", true, nil,
},
{
"invalid eip155 chain-id, cannot invalid base", "ethermint_0x212-1", true, nil,
"invalid eip155 chain-id, cannot invalid base", "laconic_0x212-1", true, nil,
},
{
"invalid eip155 chain-id, non-integer", "ethermint_laconic_9000-1", true, nil,
},
{
"invalid epoch, undefined", "ethermint_-", true, nil,
"invalid epoch, undefined", "laconic_-", true, nil,
},
{
"blank chain ID", " ", true, nil,
@ -67,7 +67,7 @@ func TestParseChainID(t *testing.T) {
"empty content for chain id, eip155 and epoch numbers", "_-", true, nil,
},
{
"long chain-id", "ethermint_" + strings.Repeat("1", 40) + "-1", true, nil,
"long chain-id", "laconic_" + strings.Repeat("1", 40) + "-1", true, nil,
},
}

2
types/errors.go
View File

@ -6,7 +6,7 @@ import (
const (
// RootCodespace is the codespace for all errors defined in this package
RootCodespace = "ethermint"
RootCodespace = "laconicd"
)
// NOTE: We can't use 1 since that error code is reserved for internal errors.

6
x/evm/genesis.go
View File

@ -10,7 +10,7 @@ import (
"github.com/ethereum/go-ethereum/crypto"
abci "github.com/tendermint/tendermint/abci/types"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
"github.com/cerc-io/laconicd/x/evm/keeper"
"github.com/cerc-io/laconicd/x/evm/types"
)
@ -40,7 +40,7 @@ func InitGenesis(
panic(fmt.Errorf("account not found for address %s", account.Address))
}
ethAcct, ok := acc.(ethermint.EthAccountI)
ethAcct, ok := acc.(laconicd.EthAccountI)
if !ok {
panic(
fmt.Errorf("account %s must be an EthAccount interface, got %T",
@ -69,7 +69,7 @@ func InitGenesis(
func ExportGenesis(ctx sdk.Context, k *keeper.Keeper, ak types.AccountKeeper) *types.GenesisState {
var ethGenAccounts []types.GenesisAccount
ak.IterateAccounts(ctx, func(account authtypes.AccountI) bool {
ethAccount, ok := account.(ethermint.EthAccountI)
ethAccount, ok := account.(laconicd.EthAccountI)
if !ok {
// ignore non EthAccounts
return false

4
x/evm/handler_test.go
View File

@ -33,7 +33,7 @@ import (
"github.com/cerc-io/laconicd/app"
"github.com/cerc-io/laconicd/crypto/ethsecp256k1"
"github.com/cerc-io/laconicd/tests"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
"github.com/cerc-io/laconicd/x/evm"
"github.com/cerc-io/laconicd/x/evm/statedb"
"github.com/cerc-io/laconicd/x/evm/types"
@ -147,7 +147,7 @@ func (suite *EvmTestSuite) DoSetupTest(t require.TestingT) {
queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, suite.app.InterfaceRegistry())
types.RegisterQueryServer(queryHelper, suite.app.EvmKeeper)
acc := &ethermint.EthAccount{
acc := &laconicd.EthAccount{
BaseAccount: authtypes.NewBaseAccount(sdk.AccAddress(address.Bytes()), nil, 0, 0),
CodeHash: common.BytesToHash(crypto.Keccak256(nil)).String(),
}

6
x/evm/keeper/benchmark_test.go
View File

@ -11,7 +11,7 @@ import (
authante "github.com/cosmos/cosmos-sdk/x/auth/ante"
"github.com/ethereum/go-ethereum/common"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
"github.com/cerc-io/laconicd/x/evm/types"
ethtypes "github.com/ethereum/go-ethereum/core/types"
)
@ -20,7 +20,7 @@ func SetupContract(b *testing.B) (*KeeperTestSuite, common.Address) {
suite := KeeperTestSuite{}
suite.SetupTest()
amt := sdk.Coins{ethermint.NewPhotonCoinInt64(1000000000000000000)}
amt := sdk.Coins{laconicd.NewPhotonCoinInt64(1000000000000000000)}
err := suite.app.BankKeeper.MintCoins(suite.ctx, types.ModuleName, amt)
require.NoError(b, err)
err = suite.app.BankKeeper.SendCoinsFromModuleToAccount(suite.ctx, types.ModuleName, suite.address.Bytes(), amt)
@ -36,7 +36,7 @@ func SetupTestMessageCall(b *testing.B) (*KeeperTestSuite, common.Address) {
suite := KeeperTestSuite{}
suite.SetupTest()
amt := sdk.Coins{ethermint.NewPhotonCoinInt64(1000000000000000000)}
amt := sdk.Coins{laconicd.NewPhotonCoinInt64(1000000000000000000)}
err := suite.app.BankKeeper.MintCoins(suite.ctx, types.ModuleName, amt)
require.NoError(b, err)
err = suite.app.BankKeeper.SendCoinsFromModuleToAccount(suite.ctx, types.ModuleName, suite.address.Bytes(), amt)

12
x/evm/keeper/grpc_query.go
View File

@ -25,7 +25,7 @@ import (
"github.com/ethereum/go-ethereum/core/vm"
ethparams "github.com/ethereum/go-ethereum/params"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
"github.com/cerc-io/laconicd/x/evm/statedb"
"github.com/cerc-io/laconicd/x/evm/types"
)
@ -42,7 +42,7 @@ func (k Keeper) Account(c context.Context, req *types.QueryAccountRequest) (*typ
return nil, status.Error(codes.InvalidArgument, "empty request")
}
if err := ethermint.ValidateAddress(req.Address); err != nil {
if err := laconicd.ValidateAddress(req.Address); err != nil {
return nil, status.Error(
codes.InvalidArgument, err.Error(),
)
@ -65,7 +65,7 @@ func (k Keeper) CosmosAccount(c context.Context, req *types.QueryCosmosAccountRe
return nil, status.Error(codes.InvalidArgument, "empty request")
}
if err := ethermint.ValidateAddress(req.Address); err != nil {
if err := laconicd.ValidateAddress(req.Address); err != nil {
return nil, status.Error(
codes.InvalidArgument, err.Error(),
)
@ -130,7 +130,7 @@ func (k Keeper) Balance(c context.Context, req *types.QueryBalanceRequest) (*typ
return nil, status.Error(codes.InvalidArgument, "empty request")
}
if err := ethermint.ValidateAddress(req.Address); err != nil {
if err := laconicd.ValidateAddress(req.Address); err != nil {
return nil, status.Error(
codes.InvalidArgument,
types.ErrZeroAddress.Error(),
@ -152,7 +152,7 @@ func (k Keeper) Storage(c context.Context, req *types.QueryStorageRequest) (*typ
return nil, status.Error(codes.InvalidArgument, "empty request")
}
if err := ethermint.ValidateAddress(req.Address); err != nil {
if err := laconicd.ValidateAddress(req.Address); err != nil {
return nil, status.Error(
codes.InvalidArgument,
types.ErrZeroAddress.Error(),
@ -178,7 +178,7 @@ func (k Keeper) Code(c context.Context, req *types.QueryCodeRequest) (*types.Que
return nil, status.Error(codes.InvalidArgument, "empty request")
}
if err := ethermint.ValidateAddress(req.Address); err != nil {
if err := laconicd.ValidateAddress(req.Address); err != nil {
return nil, status.Error(
codes.InvalidArgument,
types.ErrZeroAddress.Error(),

6
x/evm/keeper/grpc_query_test.go
View File

@ -19,7 +19,7 @@ import (
"github.com/cerc-io/laconicd/crypto/ethsecp256k1"
"github.com/cerc-io/laconicd/server/config"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
"github.com/cerc-io/laconicd/x/evm/types"
)
@ -54,7 +54,7 @@ func (suite *KeeperTestSuite) TestQueryAccount() {
{
"success",
func() {
amt := sdk.Coins{ethermint.NewPhotonCoinInt64(100)}
amt := sdk.Coins{laconicd.NewPhotonCoinInt64(100)}
err := suite.app.BankKeeper.MintCoins(suite.ctx, types.ModuleName, amt)
suite.Require().NoError(err)
err = suite.app.BankKeeper.SendCoinsFromModuleToAccount(suite.ctx, types.ModuleName, suite.address.Bytes(), amt)
@ -195,7 +195,7 @@ func (suite *KeeperTestSuite) TestQueryBalance() {
{
"success",
func() {
amt := sdk.Coins{ethermint.NewPhotonCoinInt64(100)}
amt := sdk.Coins{laconicd.NewPhotonCoinInt64(100)}
err := suite.app.BankKeeper.MintCoins(suite.ctx, types.ModuleName, amt)
suite.Require().NoError(err)
err = suite.app.BankKeeper.SendCoinsFromModuleToAccount(suite.ctx, types.ModuleName, suite.address.Bytes(), amt)

6
x/evm/keeper/keeper.go
View File

@ -16,7 +16,7 @@ import (
"github.com/ethereum/go-ethereum/params"
"github.com/tendermint/tendermint/libs/log"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
"github.com/cerc-io/laconicd/x/evm/statedb"
"github.com/cerc-io/laconicd/x/evm/types"
evm "github.com/cerc-io/laconicd/x/evm/vm"
@ -109,7 +109,7 @@ func (k Keeper) Logger(ctx sdk.Context) log.Logger {
// WithChainID sets the chain id to the local variable in the keeper
func (k *Keeper) WithChainID(ctx sdk.Context) {
chainID, err := ethermint.ParseChainID(ctx.ChainID())
chainID, err := laconicd.ParseChainID(ctx.ChainID())
if err != nil {
panic(err)
}
@ -258,7 +258,7 @@ func (k *Keeper) GetAccountWithoutBalance(ctx sdk.Context, addr common.Address)
}
codeHash := types.EmptyCodeHash
ethAcct, ok := acct.(ethermint.EthAccountI)
ethAcct, ok := acct.(laconicd.EthAccountI)
if ok {
codeHash = ethAcct.GetCodeHash().Bytes()
}

4
x/evm/keeper/keeper_test.go
View File

@ -32,7 +32,7 @@ import (
"github.com/cerc-io/laconicd/encoding"
"github.com/cerc-io/laconicd/server/config"
"github.com/cerc-io/laconicd/tests"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
"github.com/cerc-io/laconicd/x/evm/statedb"
"github.com/cerc-io/laconicd/x/evm/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
@ -191,7 +191,7 @@ func (suite *KeeperTestSuite) SetupApp(checkTx bool) {
types.RegisterQueryServer(queryHelper, suite.app.EvmKeeper)
suite.queryClient = types.NewQueryClient(queryHelper)
acc := &ethermint.EthAccount{
acc := &laconicd.EthAccount{
BaseAccount: authtypes.NewBaseAccount(sdk.AccAddress(suite.address.Bytes()), nil, 0, 0),
CodeHash: common.BytesToHash(crypto.Keccak256(nil)).String(),
}

6
x/evm/keeper/state_transition.go
View File

@ -13,7 +13,7 @@ import (
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
"github.com/cerc-io/laconicd/x/evm/statedb"
"github.com/cerc-io/laconicd/x/evm/types"
evm "github.com/cerc-io/laconicd/x/evm/vm"
@ -84,7 +84,7 @@ func (k *Keeper) NewEVM(
Transfer: core.Transfer,
GetHash: k.GetHashFn(ctx),
Coinbase: cfg.CoinBase,
GasLimit: ethermint.BlockGasLimit(ctx),
GasLimit: laconicd.BlockGasLimit(ctx),
BlockNumber: big.NewInt(ctx.BlockHeight()),
Time: big.NewInt(ctx.BlockHeader().Time.Unix()),
Difficulty: big.NewInt(0), // unused. Only required in PoW context
@ -126,7 +126,7 @@ func (k Keeper) VMConfig(ctx sdk.Context, msg core.Message, cfg *types.EVMConfig
// 3. The requested height is from a height greater than the latest one
func (k Keeper) GetHashFn(ctx sdk.Context) vm.GetHashFunc {
return func(height uint64) common.Hash {
h, err := ethermint.SafeInt64(height)
h, err := laconicd.SafeInt64(height)
if err != nil {
k.Logger(ctx).Error("failed to cast height to int64", "error", err)
return common.Hash{}

6
x/evm/keeper/statedb.go
View File

@ -6,7 +6,7 @@ import (
sdkmath "cosmossdk.io/math"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
"github.com/cerc-io/laconicd/x/evm/statedb"
"github.com/cerc-io/laconicd/x/evm/types"
"github.com/cosmos/cosmos-sdk/store/prefix"
@ -117,7 +117,7 @@ func (k *Keeper) SetAccount(ctx sdk.Context, addr common.Address, account stated
codeHash := common.BytesToHash(account.CodeHash)
if ethAcct, ok := acct.(ethermint.EthAccountI); ok {
if ethAcct, ok := acct.(laconicd.EthAccountI); ok {
if err := ethAcct.SetCodeHash(codeHash); err != nil {
return err
}
@ -187,7 +187,7 @@ func (k *Keeper) DeleteAccount(ctx sdk.Context, addr common.Address) error {
}
// NOTE: only Ethereum accounts (contracts) can be selfdestructed
_, ok := acct.(ethermint.EthAccountI)
_, ok := acct.(laconicd.EthAccountI)
if !ok {
return sdkerrors.Wrapf(types.ErrInvalidAccount, "type %T, address %s", acct, addr)
}

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

@ -3,12 +3,12 @@ package types
import (
"fmt"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
)
// Validate performs a basic validation of a GenesisAccount fields.
func (ga GenesisAccount) Validate() error {
if err := ethermint.ValidateAddress(ga.Address); err != nil {
if err := laconicd.ValidateAddress(ga.Address); err != nil {
return err
}
return ga.Storage.Validate()

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

@ -7,7 +7,7 @@ import (
"github.com/ethereum/go-ethereum/common"
ethtypes "github.com/ethereum/go-ethereum/core/types"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
)
// NewTransactionLogs creates a new NewTransactionLogs instance.
@ -28,7 +28,7 @@ func NewTransactionLogsFromEth(hash common.Hash, ethlogs []*ethtypes.Log) Transa
// Validate performs a basic validation of a GenesisAccount fields.
func (tx TransactionLogs) Validate() error {
if ethermint.IsEmptyHash(tx.Hash) {
if laconicd.IsEmptyHash(tx.Hash) {
return fmt.Errorf("hash cannot be the empty %s", tx.Hash)
}
@ -53,16 +53,16 @@ func (tx TransactionLogs) EthLogs() []*ethtypes.Log {
// Validate performs a basic validation of an ethereum Log fields.
func (log *Log) Validate() error {
if err := ethermint.ValidateAddress(log.Address); err != nil {
if err := laconicd.ValidateAddress(log.Address); err != nil {
return fmt.Errorf("invalid log address %w", err)
}
if ethermint.IsEmptyHash(log.BlockHash) {
if laconicd.IsEmptyHash(log.BlockHash) {
return fmt.Errorf("block hash cannot be the empty %s", log.BlockHash)
}
if log.BlockNumber == 0 {
return errors.New("block number cannot be zero")
}
if ethermint.IsEmptyHash(log.TxHash) {
if laconicd.IsEmptyHash(log.TxHash) {
return fmt.Errorf("tx hash cannot be the empty %s", log.TxHash)
}
return nil

4
x/feemarket/keeper/keeper_test.go
View File

@ -25,7 +25,7 @@ import (
"github.com/cerc-io/laconicd/crypto/ethsecp256k1"
"github.com/cerc-io/laconicd/encoding"
"github.com/cerc-io/laconicd/tests"
ethermint "github.com/cerc-io/laconicd/types"
laconicd "github.com/cerc-io/laconicd/types"
evmtypes "github.com/cerc-io/laconicd/x/evm/types"
"github.com/cerc-io/laconicd/x/feemarket/types"
@ -117,7 +117,7 @@ func (suite *KeeperTestSuite) SetupApp(checkTx bool) {
types.RegisterQueryServer(queryHelper, suite.app.FeeMarketKeeper)
suite.queryClient = types.NewQueryClient(queryHelper)
acc := &ethermint.EthAccount{
acc := &laconicd.EthAccount{
BaseAccount: authtypes.NewBaseAccount(sdk.AccAddress(suite.address.Bytes()), nil, 0, 0),
CodeHash: common.BytesToHash(crypto.Keccak256(nil)).String(),
}