Refactor EVM bridge module to integrate AccountKeeper and BankKeeper, enhancing token locking functionality. Implement validation for creator address and token amounts in LockTokens method, and introduce event emission for token locking. Add error handling for insufficient funds and invalid EVM addresses. Update expected keeper interfaces accordingly.

Author: ComputerKeeda

testutil/keeper/evmbridge.go

@@ -10,17 +10,27 @@ import (
 	cmtproto "github.com/cometbft/cometbft/proto/tendermint/types"
 	dbm "github.com/cosmos/cosmos-db"
 	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/codec/address" // Import address codec
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	"github.com/cosmos/cosmos-sdk/runtime"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
 	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
 	"github.com/stretchr/testify/require"
 
 	"github.com/airchains-network/junction/x/evmbridge/keeper"
 	"github.com/airchains-network/junction/x/evmbridge/types"
 )
 
+// Define necessary module account permissions for the test setup
+var ModuleAccountPerms = []*authtypes.ModuleAccount{
+	// Add module accounts used by your module or dependencies if any
+	// For example: {Name: types.ModuleName, Permissions: []string{authtypes.Minter, authtypes.Burner}},
+	{Name: types.ModuleName, Permissions: []string{authtypes.Minter, authtypes.Burner, authtypes.Staking}},
+}
+
 func EvmbridgeKeeper(t testing.TB) (keeper.Keeper, sdk.Context) {
 	storeKey := storetypes.NewKVStoreKey(types.StoreKey)
 
@@ -33,12 +43,53 @@ func EvmbridgeKeeper(t testing.TB) (keeper.Keeper, sdk.Context) {
 	cdc := codec.NewProtoCodec(registry)
 	authority := authtypes.NewModuleAddress(govtypes.ModuleName)
 
+	// Bech32 Prefix (Ensure this is set for your tests, e.g., in TestMain)
+	// sdk.GetConfig().SetBech32Prefix("yourprefix")
+	bech32Prefix := sdk.GetConfig().GetBech32AccountAddrPrefix()
+	if bech32Prefix == "" {
+		// Set a default if not configured for the test run
+		bech32Prefix = "air"
+		config := sdk.GetConfig()
+		config.SetBech32PrefixForAccount(bech32Prefix, bech32Prefix+"pub")
+		config.SetBech32PrefixForValidator(bech32Prefix+"val", bech32Prefix+"valpub")
+		config.SetBech32PrefixForConsensusNode(bech32Prefix+"cons", bech32Prefix+"conspub")
+		config.Seal()
+	}
+
+	// Account Keeper (Needs authStoreKey, proper ModuleAccountPerms)
+	// Create a map from the ModuleAccountPerms slice
+	maccPerms := make(map[string][]string)
+	for _, perm := range ModuleAccountPerms {
+		maccPerms[perm.Name] = perm.Permissions
+	}
+	// If your module has its own module account, add it here too
+	maccPerms[types.ModuleName] = nil // Example: No special permissions needed by default
+
+	accountKeeper := authkeeper.NewAccountKeeper(
+		cdc,
+		runtime.NewKVStoreService(storeKey),
+		authtypes.ProtoBaseAccount,
+		maccPerms,
+		address.NewBech32Codec(bech32Prefix),
+		bech32Prefix,
+		authority.String(),
+	)
+
+	bankKeeper := bankkeeper.NewBaseKeeper(
+		cdc,
+		runtime.NewKVStoreService(storeKey),
+		accountKeeper,
+		map[string]bool{},
+		authority.String(),
+		log.NewNopLogger())
+
 	k := keeper.NewKeeper(
 		cdc,
 		runtime.NewKVStoreService(storeKey),
 		log.NewNopLogger(),
 		authority.String(),
-		nil,
+		accountKeeper,
+		bankKeeper,
 	)
 
 	ctx := sdk.NewContext(stateStore, cmtproto.Header{}, false, log.NewNopLogger())

x/evmbridge/keeper/keeper.go

@@ -21,7 +21,8 @@ type (
 		// should be the x/gov module account.
 		authority string
 
-		bankKeeper types.BankKeeper
+		accountKeeper types.AccountKeeper
+		bankKeeper    types.BankKeeper
 	}
 )
 
@@ -30,20 +31,20 @@ func NewKeeper(
 	storeService store.KVStoreService,
 	logger log.Logger,
 	authority string,
-
+	accountKeeper types.AccountKeeper,
 	bankKeeper types.BankKeeper,
 ) Keeper {
 	if _, err := sdk.AccAddressFromBech32(authority); err != nil {
 		panic(fmt.Sprintf("invalid authority address: %s", authority))
 	}
 
 	return Keeper{
-		cdc:          cdc,
-		storeService: storeService,
-		authority:    authority,
-		logger:       logger,
-
-		bankKeeper: bankKeeper,
+		cdc:           cdc,
+		storeService:  storeService,
+		authority:     authority,
+		logger:        logger,
+		accountKeeper: accountKeeper,
+		bankKeeper:    bankKeeper,
 	}
 }
 

x/evmbridge/keeper/msg_server_lock_tokens.go

@@ -2,16 +2,112 @@ package keeper
 
 import (
 	"context"
+	"fmt"
+	"strconv"
+	"time"
 
 	"github.com/airchains-network/junction/x/evmbridge/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 )
 
 func (k msgServer) LockTokens(goCtx context.Context, msg *types.MsgLockTokens) (*types.MsgLockTokensResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
-	// TODO: Handling the message
-	_ = ctx
+	// Validate creator address
+	creatorAddr, err := sdk.AccAddressFromBech32(msg.Creator)
+	if err != nil {
+		return nil, status.Error(codes.InvalidArgument, fmt.Sprintf("invalid creator address: %s", err))
+	}
+
+	// Validate amount
+	if msg.Amount == "" {
+		return nil, status.Error(codes.InvalidArgument, "amount is required")
+	}
+
+	// Parse amount as coins
+	amount, err := sdk.ParseCoinsNormalized(msg.Amount)
+	if err != nil {
+		return nil, types.ErrInvalidAmount.Wrap(err.Error())
+	}
+
+	if !amount.IsValid() || amount.IsZero() {
+		return nil, types.ErrInvalidAmount.Wrap("amount must be positive")
+	}
+
+	// Validate EVM address format
+	if err := k.validateEVMAddress(msg.ToAddress); err != nil {
+		return nil, err
+	}
+
+	// Check if user has sufficient balance
+	userBalance := k.bankKeeper.SpendableCoins(ctx, creatorAddr)
+	if !userBalance.IsAllGTE(amount) {
+		return nil, types.ErrInsufficientFunds.Wrapf("required: %s, available: %s", amount.String(), userBalance.String())
+	}
+	// Get module account
+	moduleAccount := k.accountKeeper.GetModuleAccount(ctx, types.ModuleName)
+	if moduleAccount == nil {
+		return nil, types.ErrModuleAccount.Wrap("module account not found")
+	}
+
+	// Transfer tokens from user to module account (this locks them)
+	if err := k.bankKeeper.SendCoinsFromAccountToModule(ctx, creatorAddr, types.ModuleName, amount); err != nil {
+		return nil, types.ErrFailedToLockTokens.Wrap(err.Error())
+	}
+
+	// Get current block info
+	sdkCtx := sdk.UnwrapSDKContext(ctx)
+	blockHeight := sdkCtx.BlockHeight()
+	blockTime := sdkCtx.BlockTime()
+
+	amountUint64, err := strconv.ParseUint(msg.Amount, 10, 64)
+	if err != nil {
+		return nil, status.Error(codes.InvalidArgument, fmt.Sprintf("invalid amount: %s", err))
+	}
+
+	if err := k.SetAddressLockedAmount(ctx, msg.Creator, amountUint64); err != nil {
+		return nil, types.ErrFailedToLockTokens.Wrap(err.Error())
+	}
+
+	// Emit simple event for bridge relayer
+	sdkCtx.EventManager().EmitEvent(
+		sdk.NewEvent(
+			types.EventTypeTokensLocked,
+			sdk.NewAttribute(types.AttributeKeyCreator, msg.Creator),
+			sdk.NewAttribute(types.AttributeKeyAmount, amount.String()),
+			sdk.NewAttribute(types.AttributeKeyToAddress, msg.ToAddress),
+			sdk.NewAttribute(types.AttributeKeyBlockHeight, fmt.Sprintf("%d", blockHeight)),
+			sdk.NewAttribute(types.AttributeKeyTimestamp, blockTime.Format(time.RFC3339)),
+		),
+	)
 
 	return &types.MsgLockTokensResponse{}, nil
 }
+
+// validateEVMAddress performs basic EVM address validation
+func (k msgServer) validateEVMAddress(address string) error {
+	if address == "" {
+		return types.ErrInvalidEVMAddr.Wrap("address cannot be empty")
+	}
+
+	// Basic EVM address validation (0x prefix + 40 hex chars)
+	if len(address) != 42 {
+		return types.ErrInvalidEVMAddr.Wrap("address must be 42 characters long")
+	}
+
+	if address[:2] != "0x" {
+		return types.ErrInvalidEVMAddr.Wrap("address must start with 0x")
+	}
+
+	// Validate hex characters
+	for i := 2; i < len(address); i++ {
+		c := address[i]
+		if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) {
+			return types.ErrInvalidEVMAddr.Wrap("address contains invalid hex characters")
+		}
+	}
+
+	return nil
+}

x/evmbridge/module/module.go

@@ -202,6 +202,7 @@ func ProvideModule(in ModuleInputs) ModuleOutputs {
 		in.StoreService,
 		in.Logger,
 		authority.String(),
+		in.AccountKeeper,
 		in.BankKeeper,
 	)
 	m := NewAppModule(

x/evmbridge/types/errors.go

@@ -8,6 +8,14 @@ import (
 
 // x/evmbridge module sentinel errors
 var (
-	ErrInvalidSigner = sdkerrors.Register(ModuleName, 1100, "expected gov account as only signer for proposal message")
-	ErrSample        = sdkerrors.Register(ModuleName, 1101, "sample error")
+	ErrInvalidSigner           = sdkerrors.Register(ModuleName, 1100, "expected gov account as only signer for proposal message")
+	ErrSample                  = sdkerrors.Register(ModuleName, 1101, "sample error")
+	ErrInvalidAmount           = sdkerrors.Register(ModuleName, 1101, "invalid token amount")
+	ErrInvalidEVMAddr          = sdkerrors.Register(ModuleName, 1102, "invalid EVM address")
+	ErrInsufficientFunds       = sdkerrors.Register(ModuleName, 1103, "insufficient funds")
+	ErrModuleAccount           = sdkerrors.Register(ModuleName, 1104, "module account error")
+	ErrUnauthorized            = sdkerrors.Register(ModuleName, 1105, "unauthorized operation")
+	ErrInvalidRecipient        = sdkerrors.Register(ModuleName, 1106, "invalid recipient address")
+	ErrInsufficientUserBalance = sdkerrors.Register(ModuleName, 1107, "user has insufficient locked balance")
+	ErrFailedToLockTokens      = sdkerrors.Register(ModuleName, 1108, "failed to lock tokens")
 )

x/evmbridge/types/events.go

@@ -0,0 +1,27 @@
+package types
+
+// Event types for the evmbridge module
+const (
+	// EventTypeTokensLocked is emitted when tokens are locked in the bridge
+	EventTypeTokensLocked = "tokens_locked"
+	// EventTypeTokensUnlocked is emitted when tokens are unlocked from the bridge
+	EventTypeTokensUnlocked = "tokens_unlocked"
+)
+
+// Event attribute keys
+const (
+	// AttributeKeyCreator is the address that initiated the lock
+	AttributeKeyCreator = "creator"
+	// AttributeKeyAmount is the amount of tokens locked/unlocked
+	AttributeKeyAmount = "amount"
+	// AttributeKeyToAddress is the EVM address to mint tokens to
+	AttributeKeyToAddress = "to_address"
+	// AttributeKeyBlockHeight is the block height when operation occurred
+	AttributeKeyBlockHeight = "block_height"
+	// AttributeKeyTimestamp is the timestamp when operation occurred
+	AttributeKeyTimestamp = "timestamp"
+	// AttributeKeyRecipient is the recipient address for unlock operations
+	AttributeKeyRecipient = "recipient"
+	// AttributeKeyEVMTxHash is the EVM transaction hash that triggered the unlock
+	AttributeKeyEVMTxHash = "evm_tx_hash"
+)

x/evmbridge/types/expected_keepers.go

@@ -10,12 +10,15 @@ import (
 type AccountKeeper interface {
 	GetAccount(context.Context, sdk.AccAddress) sdk.AccountI // only used for simulation
 	// Methods imported from account should be defined here
+	GetModuleAccount(ctx context.Context, moduleName string) sdk.ModuleAccountI
 }
 
 // BankKeeper defines the expected interface for the Bank module.
 type BankKeeper interface {
 	SpendableCoins(context.Context, sdk.AccAddress) sdk.Coins
 	// Methods imported from bank should be defined here
+	SendCoinsFromAccountToModule(ctx context.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error
+	SendCoinsFromModuleToAccount(ctx context.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error
 }
 
 // ParamSubspace defines the expected Subspace interface for parameters.