Refactor MsgUnlockTokens in EVM bridge module to replace toAddress with fromEvmAddress, updating related protobuf and Go files. Enhance address mapping functionality by adding methods for setting and retrieving mappings between EVM and Cosmos addresses. Implement validation for authorized workers and improve error handling in UnlockTokens method.

Author: ComputerKeeda

api/junction/evmbridge/tx.pulsar.go

@@ -50,7 +50,7 @@ message MsgLockTokensResponse {}
 message MsgUnlockTokens {
   option (cosmos.msg.v1.signer) = "creator";
   string creator   = 1;
-  string toAddress = 2;
+  string fromEvmAddress = 2;
   string amount    = 3;
   string evmTxHash = 4;
 }

proto/junction/evmbridge/tx.proto

@@ -14,24 +14,24 @@ import (
 	"google.golang.org/grpc/status"
 )
 
-func (k Keeper) GetAddressLockedAmount(ctx sdk.Context, address string) (uint64, error) {
+func (k Keeper) GetAddressLockedAmount(ctx sdk.Context, cosmos_address string) (uint64, error) {
 	storeAdapter := runtime.KVStoreAdapter(k.storeService.OpenKVStore(ctx))
-	rollupRegistryStore := prefix.NewStore(storeAdapter, types.KeyPrefix(types.EVMLedgerKey))
+	ledgerStore := prefix.NewStore(storeAdapter, types.KeyPrefix(types.EVMLedgerKey))
 
-	amountBytes := rollupRegistryStore.Get([]byte(address))
+	amountBytes := ledgerStore.Get([]byte(cosmos_address))
 	if amountBytes == nil {
 		return 0, nil
 	}
 	amount := binary.BigEndian.Uint64(amountBytes)
 	return amount, nil
 }
 
-func (k Keeper) AddAddressLockedAmount(ctx sdk.Context, address string, amountToAdd uint64) (uint64, error) {
+func (k Keeper) AddAddressLockedAmount(ctx sdk.Context, cosmos_address string, amountToAdd uint64) (uint64, error) {
 	storeAdapter := runtime.KVStoreAdapter(k.storeService.OpenKVStore(ctx))
-	rollupRegistryStore := prefix.NewStore(storeAdapter, types.KeyPrefix(types.EVMLedgerKey))
+	ledgerStore := prefix.NewStore(storeAdapter, types.KeyPrefix(types.EVMLedgerKey))
 
 	// Get current amount
-	currentAmount, err := k.GetAddressLockedAmount(ctx, address)
+	currentAmount, err := k.GetAddressLockedAmount(ctx, cosmos_address)
 	if err != nil {
 		return 0, err
 	}
@@ -42,17 +42,17 @@ func (k Keeper) AddAddressLockedAmount(ctx sdk.Context, address string, amountTo
 	// Convert to bytes and store
 	amountBytes := make([]byte, 8)
 	binary.BigEndian.PutUint64(amountBytes, newAmount)
-	rollupRegistryStore.Set([]byte(address), amountBytes)
+	ledgerStore.Set([]byte(cosmos_address), amountBytes)
 
 	return newAmount, nil
 }
 
-func (k Keeper) SubtractAddressLockedAmount(ctx sdk.Context, address string, amountToSubtract uint64) (uint64, error) {
+func (k Keeper) SubtractAddressLockedAmount(ctx sdk.Context, cosmos_address string, amountToSubtract uint64) (uint64, error) {
 	storeAdapter := runtime.KVStoreAdapter(k.storeService.OpenKVStore(ctx))
-	rollupRegistryStore := prefix.NewStore(storeAdapter, types.KeyPrefix(types.EVMLedgerKey))
+	ledgerStore := prefix.NewStore(storeAdapter, types.KeyPrefix(types.EVMLedgerKey))
 
 	// Get current amount
-	currentAmount, err := k.GetAddressLockedAmount(ctx, address)
+	currentAmount, err := k.GetAddressLockedAmount(ctx, cosmos_address)
 	if err != nil {
 		return 0, err
 	}
@@ -68,19 +68,39 @@ func (k Keeper) SubtractAddressLockedAmount(ctx sdk.Context, address string, amo
 	// Convert to bytes and store
 	amountBytes := make([]byte, 8)
 	binary.BigEndian.PutUint64(amountBytes, newAmount)
-	rollupRegistryStore.Set([]byte(address), amountBytes)
+	ledgerStore.Set([]byte(cosmos_address), amountBytes)
 
 	return newAmount, nil
 }
 
-func (k Keeper) SetAddressLockedAmount(ctx sdk.Context, address string, amount uint64) error {
+func (k Keeper) SetAddressLockedAmount(ctx sdk.Context, cosmos_address string, amount uint64) error {
 	storeAdapter := runtime.KVStoreAdapter(k.storeService.OpenKVStore(ctx))
-	rollupRegistryStore := prefix.NewStore(storeAdapter, types.KeyPrefix(types.EVMLedgerKey))
+	ledgerStore := prefix.NewStore(storeAdapter, types.KeyPrefix(types.EVMLedgerKey))
 
 	// Convert to bytes and store
 	amountBytes := make([]byte, 8)
 	binary.BigEndian.PutUint64(amountBytes, amount)
-	rollupRegistryStore.Set([]byte(address), amountBytes)
+	ledgerStore.Set([]byte(cosmos_address), amountBytes)
 
 	return nil
 }
+
+// Store address mapping (evm address -> cosmos address)
+func (k Keeper) SetAddressMapping(ctx sdk.Context, evm_address string, cosmos_address string) error {
+	storeAdapter := runtime.KVStoreAdapter(k.storeService.OpenKVStore(ctx))
+	ledgerMappingStore := prefix.NewStore(storeAdapter, types.KeyPrefix(types.EVMMappingKey))
+
+	ledgerMappingStore.Set([]byte(evm_address), []byte(cosmos_address))
+	return nil
+}
+
+func (k Keeper) GetCosmosAddressMapping(ctx sdk.Context, evm_address string) (string, error) {
+	storeAdapter := runtime.KVStoreAdapter(k.storeService.OpenKVStore(ctx))
+	ledgerMappingStore := prefix.NewStore(storeAdapter, types.KeyPrefix(types.EVMMappingKey))
+
+	cosmos_address := ledgerMappingStore.Get([]byte(evm_address))
+	if cosmos_address == nil {
+		return "", status.Error(codes.NotFound, "address mapping not found")
+	}
+	return string(cosmos_address), nil
+}

x/evmbridge/keeper/ledger.go

@@ -70,6 +70,9 @@ func (k msgServer) LockTokens(goCtx context.Context, msg *types.MsgLockTokens) (
 	if err := k.SetAddressLockedAmount(ctx, msg.Creator, amountUint64); err != nil {
 		return nil, types.ErrFailedToLockTokens.Wrap(err.Error())
 	}
+	if err := k.SetAddressMapping(ctx, msg.ToAddress, msg.Creator); err != nil {
+		return nil, types.ErrFailedToMapAddress.Wrap(err.Error())
+	}
 
 	// Emit simple event for bridge relayer
 	sdkCtx.EventManager().EmitEvent(

x/evmbridge/keeper/msg_server_lock_tokens.go

@@ -2,6 +2,9 @@ package keeper
 
 import (
 	"context"
+	"fmt"
+	"strconv"
+	"time"
 
 	"github.com/airchains-network/junction/x/evmbridge/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -10,8 +13,99 @@ import (
 func (k msgServer) UnlockTokens(goCtx context.Context, msg *types.MsgUnlockTokens) (*types.MsgUnlockTokensResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
-	// TODO: Handling the message
-	_ = ctx
+	allowedWorkers := k.GetParams(ctx).BridgeWorkers
+	var isAllowedWorker bool
+	for _, worker := range allowedWorkers {
+		if worker == msg.Creator {
+			isAllowedWorker = true
+			break
+		}
+	}
+	if !isAllowedWorker {
+		return nil, types.ErrUnauthorized.Wrapf("creator %s is not authorized to unlock tokens", msg.Creator)
+	}
+
+	// get the cosmos address from the evm address
+	cosmosAddress, err := k.GetCosmosAddressMapping(ctx, msg.FromEvmAddress)
+	if err != nil {
+		return nil, types.ErrInvalidAddress.Wrap(err.Error())
+	}
+
+	// check if the to address is a valid cosmos address
+	_, err = sdk.AccAddressFromBech32(cosmosAddress)
+	if err != nil {
+		return nil, types.ErrInvalidAddress.Wrapf("invalid to address: %s", err)
+	}
+
+	// Validate evm tx hash
+	if msg.EvmTxHash == "" {
+		return nil, types.ErrInvalidEvmTxHash.Wrap("evm tx hash is required")
+	}
+
+	// we need to check if the passed amount is a valid number or not
+	_, err = strconv.ParseUint(msg.Amount, 10, 64)
+	if err != nil {
+		return nil, types.ErrInvalidAmount.Wrapf("invalid amount: %s", err)
+	}
+	// now we need to check if the amount is less than or equal to the locked amount
+	lockedAmount, err := k.GetAddressLockedAmount(ctx, cosmosAddress)
+	if err != nil {
+		return nil, types.ErrInvalidAddress.Wrap(err.Error())
+	}
+	// Parse string amount to sdk.Coins first
+	amount, err := sdk.ParseCoinsNormalized(msg.Amount)
+	if err != nil {
+		return nil, types.ErrInvalidAmount.Wrap(err.Error())
+	}
+	amountUint64, err := strconv.ParseUint(msg.Amount, 10, 64)
+	if err != nil {
+		return nil, types.ErrInvalidAmount.Wrapf("invalid amount: %s", err)
+	}
+	if amountUint64 > lockedAmount {
+		return nil, types.ErrInsufficientUserBalance.Wrapf("insufficient locked amount: %d", amountUint64)
+	}
+
+	// Get module account
+	moduleAccount := k.accountKeeper.GetModuleAccount(ctx, types.ModuleName)
+	if moduleAccount == nil {
+		return nil, types.ErrModuleAccount.Wrap("module account not found")
+	}
+
+	// Check if module has sufficient balance
+	moduleBalance := k.bankKeeper.SpendableCoins(ctx, moduleAccount.GetAddress())
+	if !moduleBalance.IsAllGTE(amount) {
+		return nil, types.ErrInsufficientFunds.Wrapf("module insufficient funds: required %s, available %s", amount.String(), moduleBalance.String())
+	}
+
+	// transfer the amount from the module account to the to address
+	err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, sdk.MustAccAddressFromBech32(cosmosAddress), amount)
+	if err != nil {
+		return nil, types.ErrFailedToUnlockTokens.Wrap(err.Error())
+	}
+
+	// now we need to subtract the amount from the locked amount
+	_, err = k.SubtractAddressLockedAmount(ctx, cosmosAddress, amountUint64)
+	if err != nil {
+		return nil, types.ErrFailedToUnlockTokens.Wrap(err.Error())
+	}
+
+	// Get current block info for event
+	sdkCtx := sdk.UnwrapSDKContext(ctx)
+	blockHeight := sdkCtx.BlockHeight()
+	blockTime := sdkCtx.BlockTime()
+
+	// Emit simple unlock event
+	sdkCtx.EventManager().EmitEvent(
+		sdk.NewEvent(
+			types.EventTypeTokensUnlocked,
+			sdk.NewAttribute(types.AttributeKeyRecipient, cosmosAddress),
+			sdk.NewAttribute(types.AttributeKeyFromEvmAddress, msg.FromEvmAddress),
+			sdk.NewAttribute(types.AttributeKeyAmount, amount.String()),
+			sdk.NewAttribute(types.AttributeKeyEVMTxHash, msg.EvmTxHash),
+			sdk.NewAttribute(types.AttributeKeyBlockHeight, fmt.Sprintf("%d", blockHeight)),
+			sdk.NewAttribute(types.AttributeKeyTimestamp, blockTime.Format(time.RFC3339)),
+		),
+	)
 
 	return &types.MsgUnlockTokensResponse{}, nil
 }

x/evmbridge/keeper/msg_server_unlock_tokens.go

@@ -36,9 +36,9 @@ func (am AppModule) AutoCLIOptions() *autocliv1.ModuleOptions {
 				},
 				{
 					RpcMethod:      "UnlockTokens",
-					Use:            "unlock-tokens [to-address] [amount] [evm-tx-hash]",
+					Use:            "unlock-tokens [from-evm-address] [amount] [evm-tx-hash]",
 					Short:          "Send a unlock-tokens tx",
-					PositionalArgs: []*autocliv1.PositionalArgDescriptor{{ProtoField: "toAddress"}, {ProtoField: "amount"}, {ProtoField: "evmTxHash"}},
+					PositionalArgs: []*autocliv1.PositionalArgDescriptor{{ProtoField: "fromEvmAddress"}, {ProtoField: "amount"}, {ProtoField: "evmTxHash"}},
 				},
 				// this line is used by ignite scaffolding # autocli/tx
 			},

x/evmbridge/module/autocli.go

@@ -18,4 +18,8 @@ var (
 	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")
+	ErrFailedToMapAddress      = sdkerrors.Register(ModuleName, 1109, "failed to map address")
+	ErrInvalidAddress          = sdkerrors.Register(ModuleName, 1109, "invalid address")
+	ErrInvalidEvmTxHash        = sdkerrors.Register(ModuleName, 1110, "invalid evm tx hash")
+	ErrFailedToUnlockTokens    = sdkerrors.Register(ModuleName, 1111, "failed to unlock tokens")
 )

x/evmbridge/types/errors.go

@@ -24,4 +24,6 @@ const (
 	AttributeKeyRecipient = "recipient"
 	// AttributeKeyEVMTxHash is the EVM transaction hash that triggered the unlock
 	AttributeKeyEVMTxHash = "evm_tx_hash"
+	// AttributeKeyFromEvmAddress is the EVM address that triggered the unlock
+	AttributeKeyFromEvmAddress = "from_evm_address"
 )

x/evmbridge/types/events.go

@@ -11,6 +11,8 @@ const (
 	MemStoreKey = "mem_evmbridge"
 
 	EVMLedgerKey = "evm_ledger"
+
+	EVMMappingKey = "evm_mapping"
 )
 
 var (

x/evmbridge/types/keys.go

@@ -8,10 +8,10 @@ import (
 
 var _ sdk.Msg = &MsgUnlockTokens{}
 
-func NewMsgUnlockTokens(creator string, toAddress string, amount string, evmTxHash string) *MsgUnlockTokens {
+func NewMsgUnlockTokens(creator string, fromEvmAddress string, amount string, evmTxHash string) *MsgUnlockTokens {
 	return &MsgUnlockTokens{
 		Creator:   creator,
-		ToAddress: toAddress,
+		FromEvmAddress: fromEvmAddress,
 		Amount:    amount,
 		EvmTxHash: evmTxHash,
 	}