diff --git a/proto/feeabstraction/absfee/v1beta1/query.proto b/proto/feeabstraction/absfee/v1beta1/query.proto
index 7fcab196..93bb68f4 100644
--- a/proto/feeabstraction/absfee/v1beta1/query.proto
+++ b/proto/feeabstraction/absfee/v1beta1/query.proto
@@ -25,13 +25,13 @@ service Query {
   }
 
   rpc HostChainConfig(QueryHostChainConfigRequest)
-      returns (QueryHostChainConfigRespone) {
+      returns (QueryHostChainConfigResponse) {
     option (google.api.http).get =
         "/fee-abstraction/feeabs/v1/host-chain-config/{ibc_denom}";
   }
 
   rpc AllHostChainConfig(AllQueryHostChainConfigRequest)
-      returns (AllQueryHostChainConfigRespone) {
+      returns (AllQueryHostChainConfigResponse) {
     option (google.api.http).get =
         "/fee-abstraction/feeabs/v1/all-host-chain-config";
   }
@@ -39,7 +39,7 @@ service Query {
 
 message QueryHostChainConfigRequest { string ibc_denom = 1; }
 
-message QueryHostChainConfigRespone {
+message QueryHostChainConfigResponse {
   HostChainFeeAbsConfig host_chain_config = 1 [
     (gogoproto.moretags) = "yaml:\"host_chain_config\"",
     (gogoproto.nullable) = false
@@ -73,7 +73,7 @@ message QueryFeeabsModuleBalacesResponse {
 
 message AllQueryHostChainConfigRequest {}
 
-message AllQueryHostChainConfigRespone {
+message AllQueryHostChainConfigResponse {
   repeated HostChainFeeAbsConfig all_host_chain_config = 1 [
     (gogoproto.moretags) = "yaml:\"all_host_chain_config\"",
     (gogoproto.nullable) = false
diff --git a/tests/interchaintest/packet_foward_test.go b/tests/interchaintest/packet_foward_test.go
index e40f8059..6dfaf2ec 100644
--- a/tests/interchaintest/packet_foward_test.go
+++ b/tests/interchaintest/packet_foward_test.go
@@ -550,17 +550,17 @@ func TestPacketForwardMiddleware(t *testing.T) {
 	})
 }
 
-func QueryFeeabsHostZoneConfig(c *cosmos.CosmosChain, ctx context.Context) (*QueryHostChainConfigRespone, error) {
+func QueryFeeabsHostZoneConfig(c *cosmos.CosmosChain, ctx context.Context) (*QueryHostChainConfigResponse, error) {
 	cmd := []string{"feeabs", "all-host-chain-config"}
 	stdout, _, err := c.ExecQuery(ctx, cmd)
 	if err != nil {
-		return &QueryHostChainConfigRespone{}, err
+		return &QueryHostChainConfigResponse{}, err
 	}
 
-	var hostZoneConfig QueryHostChainConfigRespone
+	var hostZoneConfig QueryHostChainConfigResponse
 	err = json.Unmarshal(stdout, &hostZoneConfig)
 	if err != nil {
-		return &QueryHostChainConfigRespone{}, err
+		return &QueryHostChainConfigResponse{}, err
 	}
 
 	return &hostZoneConfig, nil
diff --git a/tests/interchaintest/setup.go b/tests/interchaintest/setup.go
index bb2b4671..a8bc4ff2 100644
--- a/tests/interchaintest/setup.go
+++ b/tests/interchaintest/setup.go
@@ -23,7 +23,7 @@ type QueryFeeabsModuleBalacesResponse struct {
 	Address  string
 }
 
-type QueryHostChainConfigRespone struct {
+type QueryHostChainConfigResponse struct {
 	HostChainConfig cosmos.HostChainFeeAbsConfig `protobuf:"bytes,1,opt,name=host_chain_config,json=hostChainConfig,proto3" json:"host_chain_config" yaml:"host_chain_config"`
 }
 
diff --git a/x/feeabs/ante/decorate.go b/x/feeabs/ante/decorate.go
index bd78f10f..f2fcd8b1 100644
--- a/x/feeabs/ante/decorate.go
+++ b/x/feeabs/ante/decorate.go
@@ -83,15 +83,15 @@ func (fadfd FeeAbstractionDeductFeeDecorate) normalDeductFeeAnteHandle(ctx sdk.C
 	}
 
 	// deduct the fees
-	if !feeTx.GetFee().IsZero() {
-		err = DeductFees(fadfd.bankKeeper, ctx, deductFeesFrom, feeTx.GetFee())
+	if !fee.IsZero() {
+		err = DeductFees(fadfd.bankKeeper, ctx, deductFeesFrom, fee)
 		if err != nil {
 			return ctx, err
 		}
 	}
 
 	events := sdk.Events{sdk.NewEvent(sdk.EventTypeTx,
-		sdk.NewAttribute(sdk.AttributeKeyFee, feeTx.GetFee().String()),
+		sdk.NewAttribute(sdk.AttributeKeyFee, fee.String()),
 	)}
 	ctx.EventManager().EmitEvents(events)
 
@@ -126,19 +126,18 @@ func (fadfd FeeAbstractionDeductFeeDecorate) abstractionDeductFeeHandler(ctx sdk
 	}
 
 	// calculate the native token can be swapped from ibc token
-	ibcFees := feeTx.GetFee()
-	if len(ibcFees) != 1 {
-		return ctx, sdkerrors.Wrapf(errorstypes.ErrInvalidCoins, "invalid ibc token: %s", ibcFees)
+	if len(fee) != 1 {
+		return ctx, sdkerrors.Wrapf(errorstypes.ErrInvalidCoins, "invalid ibc token: %s", fee)
 	}
 
-	nativeFees, err := fadfd.feeabsKeeper.CalculateNativeFromIBCCoins(ctx, ibcFees, hostChainConfig)
+	nativeFees, err := fadfd.feeabsKeeper.CalculateNativeFromIBCCoins(ctx, fee, hostChainConfig)
 	if err != nil {
 		return ctx, err
 	}
 
 	// deduct the fees
 	if !feeTx.GetFee().IsZero() {
-		err = fadfd.bankKeeper.SendCoinsFromAccountToModule(ctx, feeAbstractionPayer, feeabstypes.ModuleName, ibcFees)
+		err = fadfd.bankKeeper.SendCoinsFromAccountToModule(ctx, feeAbstractionPayer, feeabstypes.ModuleName, fee)
 		if err != nil {
 			return ctx, err
 		}
@@ -150,7 +149,7 @@ func (fadfd FeeAbstractionDeductFeeDecorate) abstractionDeductFeeHandler(ctx sdk
 	}
 
 	events := sdk.Events{sdk.NewEvent(sdk.EventTypeTx,
-		sdk.NewAttribute(sdk.AttributeKeyFee, feeTx.GetFee().String()),
+		sdk.NewAttribute(sdk.AttributeKeyFee, fee.String()),
 	)}
 	ctx.EventManager().EmitEvents(events)
 
@@ -159,12 +158,11 @@ func (fadfd FeeAbstractionDeductFeeDecorate) abstractionDeductFeeHandler(ctx sdk
 
 // DeductFees deducts fees from the given account.
 func DeductFees(bankKeeper types.BankKeeper, ctx sdk.Context, accAddress sdk.AccAddress, fees sdk.Coins) error {
-	if !fees.IsValid() {
+	if err := fees.Validate(); err != nil {
 		return sdkerrors.Wrapf(errorstypes.ErrInsufficientFee, "invalid fee amount: %s", fees)
 	}
 
-	err := bankKeeper.SendCoinsFromAccountToModule(ctx, accAddress, types.FeeCollectorName, fees)
-	if err != nil {
+	if err := bankKeeper.SendCoinsFromAccountToModule(ctx, accAddress, types.FeeCollectorName, fees); err != nil {
 		return sdkerrors.Wrapf(errorstypes.ErrInsufficientFunds, err.Error())
 	}
 
@@ -266,27 +264,20 @@ func (famfd FeeAbstrationMempoolFeeDecorator) AnteHandle(ctx sdk.Context, tx sdk
 			return ctx, sdkerrors.Wrapf(errorstypes.ErrInsufficientFee, "fee is not a subset of required fees; got %s, required: %s", feeCoins.String(), feeRequired.String())
 		}
 
-		if byPass {
-			return next(ctx, tx, simulate)
-		}
-
 		// if the msg does not satisfy bypass condition and the feeCoins denoms are subset of fezeRequired,
 		// check the feeCoins amount against feeRequired
 		//
 		// when feeCoins=[]
-		// special case: and there is zero coin in fee requirement, pass,
-		// otherwise, err
-		if feeCoinsLen == 0 {
-			if len(zeroCoinFeesDenomReq) != 0 {
-				return next(ctx, tx, simulate)
-			}
-			return ctx, sdkerrors.Wrapf(errorstypes.ErrInsufficientFee, "insufficient fees; got: %s required 12: %s", feeCoins, feeRequired)
-		}
+		// special case: and there is zero coin in fee requirement, pass, otherwise, err
 		// when feeCoins != []
 		// special case: if TX has at least one of the zeroCoinFeesDenomReq, then it should pass
-		if len(feeCoinsZeroDenom) > 0 {
+		if byPass || (feeCoinsLen == 0 && len(zeroCoinFeesDenomReq) != 0) || len(feeCoinsZeroDenom) > 0 {
 			return next(ctx, tx, simulate)
 		}
+
+		if feeCoinsLen == 0 {
+			return ctx, sdkerrors.Wrapf(errorstypes.ErrInsufficientFee, "insufficient fees; got: %s required 12: %s", feeCoins, feeRequired)
+		}
 		// After all the checks, the tx is confirmed:
 		// feeCoins denoms subset off feeRequired (or replaced with fee-abstraction)
 		// Not bypass
diff --git a/x/feeabs/keeper/config.go b/x/feeabs/keeper/config.go
index 13a7a49d..88bda0ab 100644
--- a/x/feeabs/keeper/config.go
+++ b/x/feeabs/keeper/config.go
@@ -81,15 +81,10 @@ func (k Keeper) GetAllHostZoneConfig(ctx sdk.Context) (allChainConfigs []types.H
 	return allChainConfigs, nil
 }
 
-func (k Keeper) IteratorHostZone(ctx sdk.Context) sdk.Iterator {
-	store := ctx.KVStore(k.storeKey)
-	return sdk.KVStorePrefixIterator(store, types.KeyHostChainChainConfigByFeeAbs)
-}
-
 // IterateHostZone iterates over the hostzone .
 func (k Keeper) IterateHostZone(ctx sdk.Context, cb func(hostZoneConfig types.HostChainFeeAbsConfig) (stop bool)) {
 	store := ctx.KVStore(k.storeKey)
-	iterator := sdk.KVStorePrefixIterator(store, types.KeyHostChainChainConfigByFeeAbs)
+	iterator := sdk.KVStorePrefixIterator(store, types.KeyHostChainConfigByFeeAbs)
 
 	defer iterator.Close()
 	for ; iterator.Valid(); iterator.Next() {
@@ -101,7 +96,7 @@ func (k Keeper) IterateHostZone(ctx sdk.Context, cb func(hostZoneConfig types.Ho
 	}
 }
 
-func (k Keeper) FrozenHostZoneByIBCDenom(ctx sdk.Context, ibcDenom string) error {
+func (k Keeper) FreezeHostZoneByIBCDenom(ctx sdk.Context, ibcDenom string) error {
 	hostChainConfig, found := k.GetHostZoneConfig(ctx, ibcDenom)
 	if !found {
 		return types.ErrHostZoneConfigNotFound
@@ -115,7 +110,7 @@ func (k Keeper) FrozenHostZoneByIBCDenom(ctx sdk.Context, ibcDenom string) error
 	return nil
 }
 
-func (k Keeper) UnFrozenHostZoneByIBCDenom(ctx sdk.Context, ibcDenom string) error {
+func (k Keeper) UnFreezeHostZoneByIBCDenom(ctx sdk.Context, ibcDenom string) error {
 	hostChainConfig, found := k.GetHostZoneConfig(ctx, ibcDenom)
 	if !found {
 		return types.ErrHostZoneConfigNotFound
diff --git a/x/feeabs/keeper/epoch.go b/x/feeabs/keeper/epoch.go
index 49426665..9614ebfd 100644
--- a/x/feeabs/keeper/epoch.go
+++ b/x/feeabs/keeper/epoch.go
@@ -64,12 +64,6 @@ func (k Keeper) setEpochInfo(ctx sdk.Context, epoch types.EpochInfo) {
 	store.Set(append(types.KeyPrefixEpoch, []byte(epoch.Identifier)...), value)
 }
 
-// DeleteEpochInfo delete epoch info.
-func (k Keeper) DeleteEpochInfo(ctx sdk.Context, identifier string) {
-	store := ctx.KVStore(k.storeKey)
-	store.Delete(append(types.KeyPrefixEpoch, []byte(identifier)...))
-}
-
 // IterateEpochInfo iterate through epochs.
 func (k Keeper) IterateEpochInfo(ctx sdk.Context, fn func(index int64, epochInfo types.EpochInfo) (stop bool)) {
 	store := ctx.KVStore(k.storeKey)
@@ -104,18 +98,6 @@ func (k Keeper) AllEpochInfos(ctx sdk.Context) []types.EpochInfo {
 	return epochs
 }
 
-// NumBlocksSinceEpochStart returns the number of blocks since the epoch started.
-// if the epoch started on block N, then calling this during block N (after BeforeEpochStart)
-// would return 0.
-// Calling it any point in block N+1 (assuming the epoch doesn't increment) would return 1.
-func (k Keeper) NumBlocksSinceEpochStart(ctx sdk.Context, identifier string) (int64, error) {
-	epoch := k.GetEpochInfo(ctx, identifier)
-	if (epoch == types.EpochInfo{}) {
-		return 0, fmt.Errorf("epoch with identifier %s not found", identifier)
-	}
-	return ctx.BlockHeight() - epoch.CurrentEpochStartHeight, nil
-}
-
 func (k Keeper) AfterEpochEnd(ctx sdk.Context, epochIdentifier string) {
 	switch epochIdentifier {
 	case types.DefaultQueryEpochIdentifier:
diff --git a/x/feeabs/keeper/grpc_query.go b/x/feeabs/keeper/grpc_query.go
index 6dddb780..bfb39f78 100644
--- a/x/feeabs/keeper/grpc_query.go
+++ b/x/feeabs/keeper/grpc_query.go
@@ -58,7 +58,7 @@ func (q Querier) FeeabsModuleBalances(goCtx context.Context, req *types.QueryFee
 	}, nil
 }
 
-func (q Querier) HostChainConfig(goCtx context.Context, req *types.QueryHostChainConfigRequest) (*types.QueryHostChainConfigRespone, error) {
+func (q Querier) HostChainConfig(goCtx context.Context, req *types.QueryHostChainConfigRequest) (*types.QueryHostChainConfigResponse, error) {
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "empty request")
 	}
@@ -70,12 +70,12 @@ func (q Querier) HostChainConfig(goCtx context.Context, req *types.QueryHostChai
 		return nil, types.ErrHostZoneConfigNotFound
 	}
 
-	return &types.QueryHostChainConfigRespone{
+	return &types.QueryHostChainConfigResponse{
 		HostChainConfig: hostChainConfig,
 	}, nil
 }
 
-func (q Querier) AllHostChainConfig(goCtx context.Context, req *types.AllQueryHostChainConfigRequest) (*types.AllQueryHostChainConfigRespone, error) {
+func (q Querier) AllHostChainConfig(goCtx context.Context, req *types.AllQueryHostChainConfigRequest) (*types.AllQueryHostChainConfigResponse, error) {
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "empty request")
 	}
@@ -87,7 +87,7 @@ func (q Querier) AllHostChainConfig(goCtx context.Context, req *types.AllQueryHo
 		return nil, err
 	}
 
-	return &types.AllQueryHostChainConfigRespone{
+	return &types.AllQueryHostChainConfigResponse{
 		AllHostChainConfig: allHostChainConfig,
 	}, nil
 }
diff --git a/x/feeabs/keeper/grpc_query_test.go b/x/feeabs/keeper/grpc_query_test.go
index 30478370..4781ece1 100644
--- a/x/feeabs/keeper/grpc_query_test.go
+++ b/x/feeabs/keeper/grpc_query_test.go
@@ -70,7 +70,7 @@ func (s *KeeperTestSuite) TestHostChainConfig() {
 	for _, tc := range []struct {
 		desc      string
 		req       *types.QueryHostChainConfigRequest
-		res       *types.QueryHostChainConfigRespone
+		res       *types.QueryHostChainConfigResponse
 		shouldErr bool
 	}{
 		{
@@ -78,7 +78,7 @@ func (s *KeeperTestSuite) TestHostChainConfig() {
 			req: &types.QueryHostChainConfigRequest{
 				IbcDenom: chainConfig.IbcDenom,
 			},
-			res: &types.QueryHostChainConfigRespone{
+			res: &types.QueryHostChainConfigResponse{
 				HostChainConfig: chainConfig,
 			},
 			shouldErr: false,
@@ -88,7 +88,7 @@ func (s *KeeperTestSuite) TestHostChainConfig() {
 			req: &types.QueryHostChainConfigRequest{
 				IbcDenom: "Invalid",
 			},
-			res: &types.QueryHostChainConfigRespone{
+			res: &types.QueryHostChainConfigResponse{
 				HostChainConfig: chainConfig,
 			},
 			shouldErr: true,
diff --git a/x/feeabs/keeper/ibc.go b/x/feeabs/keeper/ibc.go
index b633a43e..55a5414a 100644
--- a/x/feeabs/keeper/ibc.go
+++ b/x/feeabs/keeper/ibc.go
@@ -19,6 +19,10 @@ import (
 	"github.com/osmosis-labs/fee-abstraction/v7/x/feeabs/types"
 )
 
+const (
+	timeoutDuration = 5 * time.Minute
+)
+
 // GetPort returns the portID for the module. Used in ExportGenesis.
 func (k Keeper) GetPort(ctx sdk.Context) string {
 	store := ctx.KVStore(k.storeKey)
@@ -84,7 +88,7 @@ func (k Keeper) SendInterchainQuery(
 	sourcePort string,
 	sourceChannel string,
 ) (uint64, error) {
-	timeoutTimestamp := ctx.BlockTime().Add(time.Minute * 5).UnixNano()
+	timeoutTimestamp := ctx.BlockTime().Add(timeoutDuration).UnixNano()
 	channelCap, ok := k.scopedKeeper.GetCapability(ctx, host.ChannelCapabilityPath(sourcePort, sourceChannel))
 	if !ok {
 		return 0, sdkerrors.Wrap(channeltypes.ErrChannelCapabilityNotFound, "module does not own channel capability")
@@ -135,7 +139,7 @@ func (k Keeper) OnAcknowledgementPacket(ctx sdk.Context, ack channeltypes.Acknow
 
 			if icqRes.Code != 0 {
 				k.Logger(ctx).Error(fmt.Sprintf("Failed to send interchain query code %d", icqRes.Code))
-				err := k.FrozenHostZoneByIBCDenom(ctx, hostZoneConfig.IbcDenom)
+				err := k.FreezeHostZoneByIBCDenom(ctx, hostZoneConfig.IbcDenom)
 				if err != nil {
 					// should never happen
 					k.Logger(ctx).Error(fmt.Sprintf("Failed to frozen host zone %s", err.Error()))
@@ -151,7 +155,7 @@ func (k Keeper) OnAcknowledgementPacket(ctx sdk.Context, ack channeltypes.Acknow
 			k.Logger(ctx).Info(fmt.Sprintf("TwapRate %v", twapRate))
 			k.SetTwapRate(ctx, hostZoneConfig.IbcDenom, twapRate)
 
-			err = k.UnFrozenHostZoneByIBCDenom(ctx, hostZoneConfig.IbcDenom)
+			err = k.UnFreezeHostZoneByIBCDenom(ctx, hostZoneConfig.IbcDenom)
 			if err != nil {
 				// should never happen
 				k.Logger(ctx).Error(fmt.Sprintf("Failed to frozen host zone %s", err.Error()))
@@ -168,7 +172,7 @@ func (k Keeper) OnAcknowledgementPacket(ctx sdk.Context, ack channeltypes.Acknow
 		)
 	case *channeltypes.Acknowledgement_Error:
 		k.IterateHostZone(ctx, func(hostZoneConfig types.HostChainFeeAbsConfig) (stop bool) {
-			err := k.FrozenHostZoneByIBCDenom(ctx, hostZoneConfig.IbcDenom)
+			err := k.FreezeHostZoneByIBCDenom(ctx, hostZoneConfig.IbcDenom)
 			if err != nil {
 				k.Logger(ctx).Error(fmt.Sprintf("Failed to frozen host zone %s", err.Error()))
 			}
@@ -224,7 +228,7 @@ func (k Keeper) transferOsmosisCrosschainSwap(ctx sdk.Context, hostChainConfig t
 		return err
 	}
 
-	timeoutTimestamp := ctx.BlockTime().Add(time.Minute * 5).UnixNano()
+	timeoutTimestamp := ctx.BlockTime().Add(timeoutDuration).UnixNano()
 
 	transferMsg := transfertypes.MsgTransfer{
 		SourcePort:       transfertypes.PortID,
@@ -306,7 +310,7 @@ func (k Keeper) executeAllHostChainSwap(ctx sdk.Context) {
 
 		if err != nil {
 			k.Logger(ctx).Error(fmt.Sprintf("Failed to transfer IBC token %s", err.Error()))
-			err = k.FrozenHostZoneByIBCDenom(ctx, hostZoneConfig.IbcDenom)
+			err = k.FreezeHostZoneByIBCDenom(ctx, hostZoneConfig.IbcDenom)
 			if err != nil {
 				k.Logger(ctx).Error(fmt.Sprintf("Failed to frozem host zone %s", err.Error()))
 			}
diff --git a/x/feeabs/keeper/keeper.go b/x/feeabs/keeper/keeper.go
index eebe9a5f..93eaddf5 100644
--- a/x/feeabs/keeper/keeper.go
+++ b/x/feeabs/keeper/keeper.go
@@ -107,10 +107,6 @@ func (k Keeper) SendAbstractionFeeToModuleAccount(ctx sdk.Context, ibcCoins sdk.
 
 // return err if IBC token isn't in allowed_list
 func (k Keeper) verifyIBCCoins(ctx sdk.Context, ibcCoins sdk.Coins) error {
-	if ibcCoins.Len() != 1 {
-		return types.ErrInvalidIBCFees
-	}
-
 	if k.HasHostZoneConfig(ctx, ibcCoins[0].Denom) {
 		return nil
 	}
diff --git a/x/feeabs/types/keys.go b/x/feeabs/types/keys.go
index ecbb7659..e1a3ac0b 100644
--- a/x/feeabs/types/keys.go
+++ b/x/feeabs/types/keys.go
@@ -27,20 +27,20 @@ type (
 )
 
 var (
-	OsmosisTwapExchangeRate          = []byte{0x01} // Key for the exchange rate of osmosis (to native token)
-	KeyChannelID                     = []byte{0x02} // Key for IBC channel to osmosis
-	KeyHostChainChainConfigByFeeAbs  = []byte{0x03} // Key for IBC channel to osmosis
-	KeyHostChainChainConfigByOsmosis = []byte{0x04} // Key for IBC channel to osmosis
-	KeyPrefixEpoch                   = []byte{0x05} // KeyPrefixEpoch defines prefix key for storing epochs.
-	KeyTokenDenomPair                = []byte{0x06} // Key store token denom pair on feeabs and osmosis
+	OsmosisTwapExchangeRate     = []byte{0x01} // Key for the exchange rate of osmosis (to native token)
+	KeyChannelID                = []byte{0x02} // Key for IBC channel to osmosis
+	KeyHostChainConfigByFeeAbs  = []byte{0x03} // Key for IBC channel to osmosis
+	KeyHostChainConfigByOsmosis = []byte{0x04} // Key for IBC channel to osmosis
+	KeyPrefixEpoch              = []byte{0x05} // KeyPrefixEpoch defines prefix key for storing epochs.
+	KeyTokenDenomPair           = []byte{0x06} // Key store token denom pair on feeabs and osmosis
 )
 
 func GetKeyHostZoneConfigByFeeabsIBCDenom(feeabsIbcDenom string) []byte {
-	return append(KeyHostChainChainConfigByFeeAbs, []byte(feeabsIbcDenom)...)
+	return append(KeyHostChainConfigByFeeAbs, []byte(feeabsIbcDenom)...)
 }
 
 func GetKeyHostZoneConfigByOsmosisIBCDenom(osmosisIbcDenom string) []byte {
-	return append(KeyHostChainChainConfigByOsmosis, []byte(osmosisIbcDenom)...)
+	return append(KeyHostChainConfigByOsmosis, []byte(osmosisIbcDenom)...)
 }
 
 func GetKeyTwapExchangeRate(ibcDenom string) []byte {
diff --git a/x/feeabs/types/query.pb.go b/x/feeabs/types/query.pb.go
index b5814748..7b213661 100644
--- a/x/feeabs/types/query.pb.go
+++ b/x/feeabs/types/query.pb.go
@@ -75,22 +75,22 @@ func (m *QueryHostChainConfigRequest) GetIbcDenom() string {
 	return ""
 }
 
-type QueryHostChainConfigRespone struct {
+type QueryHostChainConfigResponse struct {
 	HostChainConfig HostChainFeeAbsConfig `protobuf:"bytes,1,opt,name=host_chain_config,json=hostChainConfig,proto3" json:"host_chain_config" yaml:"host_chain_config"`
 }
 
-func (m *QueryHostChainConfigRespone) Reset()         { *m = QueryHostChainConfigRespone{} }
-func (m *QueryHostChainConfigRespone) String() string { return proto.CompactTextString(m) }
-func (*QueryHostChainConfigRespone) ProtoMessage()    {}
-func (*QueryHostChainConfigRespone) Descriptor() ([]byte, []int) {
+func (m *QueryHostChainConfigResponse) Reset()         { *m = QueryHostChainConfigResponse{} }
+func (m *QueryHostChainConfigResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryHostChainConfigResponse) ProtoMessage()    {}
+func (*QueryHostChainConfigResponse) Descriptor() ([]byte, []int) {
 	return fileDescriptor_0a3dde61db3cbb0e, []int{1}
 }
-func (m *QueryHostChainConfigRespone) XXX_Unmarshal(b []byte) error {
+func (m *QueryHostChainConfigResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *QueryHostChainConfigRespone) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *QueryHostChainConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_QueryHostChainConfigRespone.Marshal(b, m, deterministic)
+		return xxx_messageInfo_QueryHostChainConfigResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -100,19 +100,19 @@ func (m *QueryHostChainConfigRespone) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
-func (m *QueryHostChainConfigRespone) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryHostChainConfigRespone.Merge(m, src)
+func (m *QueryHostChainConfigResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryHostChainConfigResponse.Merge(m, src)
 }
-func (m *QueryHostChainConfigRespone) XXX_Size() int {
+func (m *QueryHostChainConfigResponse) XXX_Size() int {
 	return m.Size()
 }
-func (m *QueryHostChainConfigRespone) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryHostChainConfigRespone.DiscardUnknown(m)
+func (m *QueryHostChainConfigResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryHostChainConfigResponse.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_QueryHostChainConfigRespone proto.InternalMessageInfo
+var xxx_messageInfo_QueryHostChainConfigResponse proto.InternalMessageInfo
 
-func (m *QueryHostChainConfigRespone) GetHostChainConfig() HostChainFeeAbsConfig {
+func (m *QueryHostChainConfigResponse) GetHostChainConfig() HostChainFeeAbsConfig {
 	if m != nil {
 		return m.HostChainConfig
 	}
@@ -328,22 +328,22 @@ func (m *AllQueryHostChainConfigRequest) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_AllQueryHostChainConfigRequest proto.InternalMessageInfo
 
-type AllQueryHostChainConfigRespone struct {
+type AllQueryHostChainConfigResponse struct {
 	AllHostChainConfig []HostChainFeeAbsConfig `protobuf:"bytes,1,rep,name=all_host_chain_config,json=allHostChainConfig,proto3" json:"all_host_chain_config" yaml:"all_host_chain_config"`
 }
 
-func (m *AllQueryHostChainConfigRespone) Reset()         { *m = AllQueryHostChainConfigRespone{} }
-func (m *AllQueryHostChainConfigRespone) String() string { return proto.CompactTextString(m) }
-func (*AllQueryHostChainConfigRespone) ProtoMessage()    {}
-func (*AllQueryHostChainConfigRespone) Descriptor() ([]byte, []int) {
+func (m *AllQueryHostChainConfigResponse) Reset()         { *m = AllQueryHostChainConfigResponse{} }
+func (m *AllQueryHostChainConfigResponse) String() string { return proto.CompactTextString(m) }
+func (*AllQueryHostChainConfigResponse) ProtoMessage()    {}
+func (*AllQueryHostChainConfigResponse) Descriptor() ([]byte, []int) {
 	return fileDescriptor_0a3dde61db3cbb0e, []int{7}
 }
-func (m *AllQueryHostChainConfigRespone) XXX_Unmarshal(b []byte) error {
+func (m *AllQueryHostChainConfigResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *AllQueryHostChainConfigRespone) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *AllQueryHostChainConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_AllQueryHostChainConfigRespone.Marshal(b, m, deterministic)
+		return xxx_messageInfo_AllQueryHostChainConfigResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -353,19 +353,19 @@ func (m *AllQueryHostChainConfigRespone) XXX_Marshal(b []byte, deterministic boo
 		return b[:n], nil
 	}
 }
-func (m *AllQueryHostChainConfigRespone) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_AllQueryHostChainConfigRespone.Merge(m, src)
+func (m *AllQueryHostChainConfigResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_AllQueryHostChainConfigResponse.Merge(m, src)
 }
-func (m *AllQueryHostChainConfigRespone) XXX_Size() int {
+func (m *AllQueryHostChainConfigResponse) XXX_Size() int {
 	return m.Size()
 }
-func (m *AllQueryHostChainConfigRespone) XXX_DiscardUnknown() {
-	xxx_messageInfo_AllQueryHostChainConfigRespone.DiscardUnknown(m)
+func (m *AllQueryHostChainConfigResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_AllQueryHostChainConfigResponse.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_AllQueryHostChainConfigRespone proto.InternalMessageInfo
+var xxx_messageInfo_AllQueryHostChainConfigResponse proto.InternalMessageInfo
 
-func (m *AllQueryHostChainConfigRespone) GetAllHostChainConfig() []HostChainFeeAbsConfig {
+func (m *AllQueryHostChainConfigResponse) GetAllHostChainConfig() []HostChainFeeAbsConfig {
 	if m != nil {
 		return m.AllHostChainConfig
 	}
@@ -374,13 +374,13 @@ func (m *AllQueryHostChainConfigRespone) GetAllHostChainConfig() []HostChainFeeA
 
 func init() {
 	proto.RegisterType((*QueryHostChainConfigRequest)(nil), "feeabstraction.absfee.v1beta1.QueryHostChainConfigRequest")
-	proto.RegisterType((*QueryHostChainConfigRespone)(nil), "feeabstraction.absfee.v1beta1.QueryHostChainConfigRespone")
+	proto.RegisterType((*QueryHostChainConfigResponse)(nil), "feeabstraction.absfee.v1beta1.QueryHostChainConfigResponse")
 	proto.RegisterType((*QueryOsmosisArithmeticTwapRequest)(nil), "feeabstraction.absfee.v1beta1.QueryOsmosisArithmeticTwapRequest")
 	proto.RegisterType((*QueryOsmosisArithmeticTwapResponse)(nil), "feeabstraction.absfee.v1beta1.QueryOsmosisArithmeticTwapResponse")
 	proto.RegisterType((*QueryFeeabsModuleBalacesRequest)(nil), "feeabstraction.absfee.v1beta1.QueryFeeabsModuleBalacesRequest")
 	proto.RegisterType((*QueryFeeabsModuleBalacesResponse)(nil), "feeabstraction.absfee.v1beta1.QueryFeeabsModuleBalacesResponse")
 	proto.RegisterType((*AllQueryHostChainConfigRequest)(nil), "feeabstraction.absfee.v1beta1.AllQueryHostChainConfigRequest")
-	proto.RegisterType((*AllQueryHostChainConfigRespone)(nil), "feeabstraction.absfee.v1beta1.AllQueryHostChainConfigRespone")
+	proto.RegisterType((*AllQueryHostChainConfigResponse)(nil), "feeabstraction.absfee.v1beta1.AllQueryHostChainConfigResponse")
 }
 
 func init() {
@@ -388,55 +388,55 @@ func init() {
 }
 
 var fileDescriptor_0a3dde61db3cbb0e = []byte{
-	// 756 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0xcf, 0x4f, 0xdb, 0x48,
-	0x18, 0xcd, 0x80, 0x96, 0x85, 0x41, 0xda, 0x68, 0x47, 0xb0, 0xca, 0x06, 0xd6, 0x09, 0xa3, 0xd5,
-	0x8a, 0x45, 0xd8, 0x2e, 0x69, 0xa5, 0xd2, 0x48, 0xa5, 0xf9, 0x81, 0x10, 0x97, 0xaa, 0x6a, 0xda,
-	0x53, 0x2f, 0xd1, 0xd8, 0x99, 0x24, 0x56, 0x27, 0x1e, 0x93, 0x71, 0xa0, 0xb4, 0xea, 0x85, 0x7b,
-	0xa5, 0x4a, 0x3d, 0xf4, 0xde, 0x63, 0x4f, 0x3d, 0xf6, 0x4f, 0x40, 0xa2, 0x07, 0xa4, 0x5e, 0xda,
-	0x1e, 0xd2, 0x0a, 0xf8, 0x0b, 0xf8, 0x0b, 0x2a, 0xcf, 0x38, 0x81, 0x84, 0xe0, 0x44, 0xe9, 0x29,
-	0xb1, 0xe6, 0x7d, 0xef, 0x7b, 0xef, 0xfb, 0x9e, 0xc7, 0xf0, 0xff, 0x2a, 0xa5, 0xc4, 0x12, 0x7e,
-	0x93, 0xd8, 0xbe, 0xc3, 0x5d, 0x93, 0x58, 0xa2, 0x4a, 0xa9, 0xb9, 0xbb, 0x66, 0x51, 0x9f, 0xac,
-	0x99, 0x3b, 0x2d, 0xda, 0xdc, 0x37, 0xbc, 0x26, 0xf7, 0x39, 0xfa, 0xa7, 0x17, 0x6a, 0x28, 0xa8,
-	0x11, 0x42, 0x93, 0x73, 0x35, 0x5e, 0xe3, 0x12, 0x69, 0x06, 0xff, 0x54, 0x51, 0x72, 0xb1, 0xc6,
-	0x79, 0x8d, 0x51, 0x93, 0x78, 0x8e, 0x49, 0x5c, 0x97, 0xfb, 0x24, 0xa8, 0x15, 0xe1, 0xe9, 0x4a,
-	0x74, 0x77, 0x8f, 0x34, 0x49, 0xa3, 0x83, 0x35, 0xa2, 0xb1, 0x5c, 0x34, 0xb8, 0x70, 0x84, 0x63,
-	0xd9, 0x21, 0x7e, 0x75, 0x08, 0x77, 0x93, 0x7b, 0x5c, 0x10, 0x16, 0xa2, 0x35, 0x5b, 0x12, 0x98,
-	0x16, 0x11, 0x17, 0x18, 0x9b, 0x3b, 0xae, 0x3a, 0xc7, 0x59, 0xb8, 0xf0, 0x30, 0x98, 0xc5, 0x36,
-	0x17, 0x7e, 0xb1, 0x4e, 0x1c, 0xb7, 0xc8, 0xdd, 0xaa, 0x53, 0x2b, 0xd1, 0x9d, 0x16, 0x15, 0x3e,
-	0x5a, 0x80, 0x33, 0x8e, 0x65, 0x97, 0x2b, 0xd4, 0xe5, 0x8d, 0x04, 0x48, 0x83, 0xe5, 0x99, 0xd2,
-	0xb4, 0x63, 0xd9, 0x9b, 0xc1, 0x33, 0x7e, 0x07, 0xae, 0x2b, 0x16, 0x1e, 0x77, 0x29, 0x3a, 0x00,
-	0xf0, 0xcf, 0x3a, 0x17, 0x7e, 0xd9, 0x0e, 0xce, 0xca, 0xb6, 0x3c, 0x94, 0x2c, 0xb3, 0x99, 0x5b,
-	0x46, 0xe4, 0xd4, 0x8d, 0x2e, 0xe5, 0x16, 0xa5, 0x79, 0x4b, 0x28, 0xe2, 0x42, 0xfa, 0xb0, 0x9d,
-	0x8a, 0x9d, 0xb7, 0x53, 0x89, 0x7d, 0xd2, 0x60, 0x59, 0x7c, 0x85, 0x1c, 0x97, 0xe2, 0xf5, 0x5e,
-	0x2d, 0x38, 0x07, 0x97, 0xa4, 0xc6, 0x07, 0x6a, 0x8e, 0xf9, 0xa6, 0xe3, 0xd7, 0x1b, 0xd4, 0x77,
-	0xec, 0xc7, 0x7b, 0xc4, 0x1b, 0xc9, 0xe6, 0x5b, 0x00, 0x71, 0x14, 0x45, 0x60, 0x56, 0x50, 0xb4,
-	0x03, 0xe3, 0xa4, 0x7b, 0x52, 0xf6, 0xf7, 0x88, 0xa7, 0x98, 0x0a, 0xdb, 0x81, 0xe8, 0x6f, 0xed,
-	0xd4, 0x7f, 0x35, 0xc7, 0xaf, 0xb7, 0x2c, 0xc3, 0xe6, 0x0d, 0x33, 0xdc, 0x8a, 0xfa, 0xd1, 0x45,
-	0xe5, 0xa9, 0xe9, 0xef, 0x7b, 0x54, 0x18, 0x9b, 0xd4, 0x3e, 0x6f, 0xa7, 0xfe, 0x52, 0xf6, 0xfa,
-	0xe8, 0x70, 0xe9, 0x0f, 0xd2, 0xd3, 0x1a, 0x2f, 0xc1, 0x94, 0x14, 0xb6, 0x25, 0x47, 0x79, 0x9f,
-	0x57, 0x5a, 0x8c, 0x16, 0x08, 0x23, 0x36, 0x15, 0xa1, 0x33, 0xfc, 0x11, 0xc0, 0xf4, 0xf5, 0x98,
-	0x50, 0xfa, 0x73, 0x38, 0x6d, 0x11, 0x46, 0x5c, 0x9b, 0x8a, 0x04, 0x48, 0x4f, 0x2e, 0xcf, 0x66,
-	0xfe, 0x36, 0x94, 0x34, 0x23, 0xc8, 0x4d, 0x77, 0x29, 0x45, 0xee, 0xb8, 0x85, 0x62, 0xb8, 0x83,
-	0xb8, 0x12, 0xd9, 0x29, 0xc4, 0xef, 0xbf, 0xa7, 0x96, 0x47, 0x70, 0x18, 0x70, 0x88, 0x52, 0xb7,
-	0x1f, 0x4a, 0xc0, 0xdf, 0x49, 0xa5, 0xd2, 0xa4, 0x42, 0x24, 0x26, 0xe4, 0xe0, 0x3b, 0x8f, 0x38,
-	0x0d, 0xb5, 0x3c, 0x63, 0x11, 0xe9, 0xc4, 0x1f, 0x40, 0x04, 0x44, 0x65, 0xf0, 0x15, 0x80, 0xf3,
-	0x84, 0xb1, 0xf2, 0xa0, 0x1c, 0x4e, 0x8e, 0x9d, 0xc3, 0x7f, 0xc3, 0x19, 0x2c, 0x86, 0x8b, 0x1a,
-	0xd4, 0x00, 0x97, 0x10, 0x61, 0xac, 0x4f, 0x56, 0xe6, 0xeb, 0x14, 0xfc, 0x4d, 0xea, 0x45, 0x67,
-	0x00, 0xce, 0x0f, 0x4c, 0x14, 0xca, 0x0d, 0xd1, 0x34, 0x34, 0xcf, 0xc9, 0xfc, 0x2f, 0x30, 0xa8,
-	0x4c, 0xe0, 0xad, 0x83, 0xcf, 0x67, 0x6f, 0x26, 0x72, 0x68, 0xc3, 0xac, 0x52, 0xaa, 0x5f, 0xbe,
-	0x70, 0x14, 0xb5, 0xb9, 0xdb, 0xbd, 0x9b, 0xf4, 0x8b, 0x58, 0xea, 0x41, 0x50, 0xcd, 0x17, 0xdd,
-	0x97, 0xe9, 0x25, 0x3a, 0x02, 0x70, 0xae, 0x3f, 0x7b, 0x72, 0xf1, 0x1b, 0xa3, 0x68, 0xbc, 0x3e,
-	0xd9, 0xc9, 0x7b, 0x63, 0xd7, 0x87, 0x0e, 0x33, 0xd2, 0xe1, 0x2a, 0x5a, 0x89, 0x70, 0xd8, 0x90,
-	0x95, 0x7a, 0x37, 0xad, 0x47, 0x00, 0xc6, 0xfb, 0x56, 0x8a, 0xb2, 0xa3, 0x08, 0x19, 0x9c, 0xe0,
-	0xe4, 0x78, 0xb5, 0x32, 0xda, 0x38, 0x27, 0xf5, 0x67, 0xd1, 0x7a, 0x84, 0xfe, 0x20, 0x95, 0xba,
-	0x4c, 0xa5, 0xae, 0x52, 0xd9, 0xb3, 0x9b, 0x4f, 0x00, 0xa2, 0xfc, 0x95, 0x8c, 0xa2, 0xbb, 0x43,
-	0x44, 0x45, 0xbf, 0x95, 0xc9, 0xb1, 0xcb, 0x95, 0xad, 0x75, 0x69, 0x2b, 0x83, 0x6e, 0x44, 0xd8,
-	0x22, 0x8c, 0xe9, 0x57, 0xac, 0x15, 0x1e, 0x1d, 0x9e, 0x68, 0xe0, 0xf8, 0x44, 0x03, 0x3f, 0x4e,
-	0x34, 0xf0, 0xfa, 0x54, 0x8b, 0x1d, 0x9f, 0x6a, 0xb1, 0x2f, 0xa7, 0x5a, 0xec, 0xc9, 0x9d, 0x4b,
-	0x17, 0x53, 0x27, 0xb4, 0x2c, 0xe0, 0xea, 0x6f, 0xb1, 0x7b, 0xdb, 0x7c, 0xd6, 0xe9, 0x23, 0xef,
-	0x2b, 0x6b, 0x4a, 0x7e, 0x27, 0x6f, 0xfe, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xce, 0xd8, 0xd5, 0x08,
-	0x51, 0x08, 0x00, 0x00,
+	// 758 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0x4f, 0x6b, 0x13, 0x4d,
+	0x1c, 0xce, 0xb4, 0xbc, 0x7d, 0xdb, 0x29, 0xbc, 0xe1, 0x1d, 0x5a, 0x89, 0x69, 0xdd, 0xa4, 0x8b,
+	0x48, 0x2d, 0xdd, 0x5d, 0x1b, 0x05, 0x6b, 0xc4, 0x9a, 0x3f, 0xa5, 0xf4, 0x22, 0x62, 0xf4, 0xe4,
+	0x25, 0xcc, 0x6e, 0x26, 0xc9, 0xe2, 0x64, 0x67, 0x9b, 0xd9, 0xb4, 0x56, 0xf1, 0xd2, 0xbb, 0x20,
+	0x78, 0xf0, 0x03, 0x78, 0xf3, 0xe6, 0xcd, 0x8f, 0x50, 0x50, 0xa1, 0xe0, 0x45, 0x14, 0xa2, 0xb4,
+	0xfd, 0x04, 0xfd, 0x04, 0xb2, 0xb3, 0x93, 0x6d, 0x93, 0xa6, 0x9b, 0x10, 0x4f, 0xc9, 0x32, 0xcf,
+	0xef, 0xf9, 0x3d, 0xcf, 0xef, 0xf7, 0xec, 0x2c, 0xbc, 0x5e, 0x25, 0x04, 0x9b, 0xdc, 0x6b, 0x62,
+	0xcb, 0xb3, 0x99, 0x63, 0x60, 0x93, 0x57, 0x09, 0x31, 0xb6, 0x57, 0x4c, 0xe2, 0xe1, 0x15, 0x63,
+	0xab, 0x45, 0x9a, 0xbb, 0xba, 0xdb, 0x64, 0x1e, 0x43, 0x57, 0xba, 0xa1, 0x7a, 0x00, 0xd5, 0x25,
+	0x34, 0x39, 0x53, 0x63, 0x35, 0x26, 0x90, 0x86, 0xff, 0x2f, 0x28, 0x4a, 0xce, 0xd7, 0x18, 0xab,
+	0x51, 0x62, 0x60, 0xd7, 0x36, 0xb0, 0xe3, 0x30, 0x0f, 0xfb, 0xb5, 0x5c, 0x9e, 0x2e, 0x45, 0x77,
+	0x77, 0x71, 0x13, 0x37, 0x3a, 0x58, 0x3d, 0x1a, 0xcb, 0x78, 0x83, 0x71, 0x9b, 0xdb, 0xa6, 0x25,
+	0xf1, 0xcb, 0x03, 0xb8, 0x9b, 0xcc, 0x65, 0x1c, 0x53, 0x89, 0x56, 0x2c, 0x41, 0x60, 0x98, 0x98,
+	0x9f, 0x62, 0x2c, 0x66, 0x3b, 0xc1, 0xb9, 0x9a, 0x85, 0x73, 0x8f, 0xfc, 0x59, 0x6c, 0x32, 0xee,
+	0x15, 0xeb, 0xd8, 0x76, 0x8a, 0xcc, 0xa9, 0xda, 0xb5, 0x12, 0xd9, 0x6a, 0x11, 0xee, 0xa1, 0x39,
+	0x38, 0x65, 0x9b, 0x56, 0xb9, 0x42, 0x1c, 0xd6, 0x48, 0x80, 0x34, 0x58, 0x9c, 0x2a, 0x4d, 0xda,
+	0xa6, 0xb5, 0xee, 0x3f, 0xab, 0xef, 0x01, 0x9c, 0xef, 0x5f, 0xcc, 0x5d, 0xe6, 0x70, 0x82, 0xf6,
+	0x00, 0xfc, 0xbf, 0xce, 0xb8, 0x57, 0xb6, 0xfc, 0xc3, 0xb2, 0x25, 0x4e, 0x05, 0xcd, 0x74, 0xe6,
+	0x96, 0x1e, 0x39, 0x76, 0x3d, 0xe4, 0xdc, 0x20, 0x24, 0x6f, 0xf2, 0x80, 0xb9, 0x90, 0xde, 0x6f,
+	0xa7, 0x62, 0x27, 0xed, 0x54, 0x62, 0x17, 0x37, 0x68, 0x56, 0x3d, 0x47, 0xae, 0x96, 0xe2, 0xf5,
+	0x6e, 0x31, 0x6a, 0x0e, 0x2e, 0x08, 0x91, 0x0f, 0x83, 0x41, 0xe6, 0x9b, 0xb6, 0x57, 0x6f, 0x10,
+	0xcf, 0xb6, 0x9e, 0xec, 0x60, 0x77, 0x28, 0x9f, 0xef, 0x00, 0x54, 0xa3, 0x28, 0xa4, 0xdb, 0x2d,
+	0x18, 0xc7, 0xe1, 0x49, 0xd9, 0xdb, 0xc1, 0x6e, 0xc0, 0x54, 0xd8, 0xf4, 0x45, 0xff, 0x68, 0xa7,
+	0xae, 0xd5, 0x6c, 0xaf, 0xde, 0x32, 0x75, 0x8b, 0x35, 0x0c, 0xb9, 0x96, 0xe0, 0x47, 0xe3, 0x95,
+	0x67, 0x86, 0xb7, 0xeb, 0x12, 0xae, 0xaf, 0x13, 0xeb, 0xa4, 0x9d, 0xba, 0x14, 0xd8, 0xeb, 0xa1,
+	0x53, 0x4b, 0xff, 0xe1, 0xae, 0xd6, 0xea, 0x02, 0x4c, 0x09, 0x61, 0x1b, 0x62, 0x94, 0x0f, 0x58,
+	0xa5, 0x45, 0x49, 0x01, 0x53, 0x6c, 0x11, 0x2e, 0x9d, 0xa9, 0x9f, 0x00, 0x4c, 0x5f, 0x8c, 0x91,
+	0xd2, 0x5f, 0xc0, 0x49, 0x13, 0x53, 0xec, 0x58, 0x84, 0x27, 0x40, 0x7a, 0x7c, 0x71, 0x3a, 0x73,
+	0x59, 0x0f, 0xa4, 0xe9, 0x7e, 0x70, 0xc2, 0xa5, 0x14, 0x99, 0xed, 0x14, 0x8a, 0x72, 0x07, 0xf1,
+	0x40, 0x64, 0xa7, 0x50, 0xfd, 0xf0, 0x2b, 0xb5, 0x38, 0x84, 0x43, 0x9f, 0x83, 0x97, 0xc2, 0x7e,
+	0x28, 0x01, 0xff, 0xc5, 0x95, 0x4a, 0x93, 0x70, 0x9e, 0x18, 0x13, 0x83, 0xef, 0x3c, 0xaa, 0x69,
+	0xa8, 0xe4, 0x29, 0x8d, 0x88, 0xa7, 0xfa, 0x11, 0xc0, 0xd4, 0x85, 0x10, 0xe9, 0xed, 0x35, 0x80,
+	0xb3, 0x98, 0xd2, 0x72, 0xbf, 0x20, 0x8e, 0x8f, 0x1c, 0xc4, 0xab, 0x72, 0x08, 0xf3, 0x72, 0x53,
+	0xfd, 0x1a, 0xa8, 0x25, 0x84, 0x29, 0xed, 0xd1, 0x95, 0xf9, 0x39, 0x01, 0xff, 0x11, 0x82, 0xd1,
+	0x31, 0x80, 0xb3, 0x7d, 0x23, 0x85, 0x72, 0x03, 0x34, 0x0d, 0x0c, 0x74, 0x32, 0xff, 0x17, 0x0c,
+	0xc1, 0xe0, 0xd4, 0x8d, 0xbd, 0x6f, 0xc7, 0x6f, 0xc7, 0x72, 0x68, 0xcd, 0xa8, 0x12, 0xa2, 0x9d,
+	0xbd, 0x72, 0x02, 0x6a, 0x63, 0x3b, 0xbc, 0x9d, 0xb4, 0xd3, 0x5c, 0x6a, 0x7e, 0x52, 0x8d, 0x97,
+	0xe1, 0xdb, 0xf4, 0x0a, 0x7d, 0x06, 0x70, 0xa6, 0x37, 0x7c, 0x62, 0xf3, 0x6b, 0xc3, 0x68, 0xbc,
+	0x38, 0xda, 0xc9, 0xfb, 0x23, 0xd7, 0x4b, 0x87, 0x19, 0xe1, 0x70, 0x19, 0x2d, 0x45, 0x38, 0x6c,
+	0x88, 0x4a, 0x2d, 0x8c, 0xeb, 0x17, 0x00, 0xe3, 0x3d, 0x2b, 0x45, 0xd9, 0x61, 0x84, 0xf4, 0x8f,
+	0x70, 0xf2, 0xee, 0x48, 0xb5, 0xd2, 0x40, 0x4e, 0x18, 0xc8, 0xa2, 0xd5, 0x08, 0x03, 0x7e, 0x2c,
+	0x35, 0x11, 0x4b, 0x2d, 0x88, 0x65, 0xd7, 0x72, 0xbe, 0x02, 0x88, 0xf2, 0xe7, 0x42, 0x8a, 0xee,
+	0x0d, 0x50, 0x15, 0xfd, 0x5e, 0x26, 0xd7, 0x46, 0x2d, 0x97, 0xbe, 0x56, 0x85, 0xaf, 0x0c, 0xba,
+	0x11, 0xe1, 0x0b, 0x53, 0xaa, 0x9d, 0xf3, 0x56, 0x78, 0xbc, 0x7f, 0xa8, 0x80, 0x83, 0x43, 0x05,
+	0xfc, 0x3e, 0x54, 0xc0, 0x9b, 0x23, 0x25, 0x76, 0x70, 0xa4, 0xc4, 0xbe, 0x1f, 0x29, 0xb1, 0xa7,
+	0x77, 0xce, 0xdc, 0x4d, 0x9d, 0xd8, 0x52, 0x9f, 0xab, 0xb7, 0xc5, 0xf6, 0x6d, 0xe3, 0x79, 0xa7,
+	0x8f, 0xb8, 0xb2, 0xcc, 0x09, 0xf1, 0xad, 0xbc, 0xf9, 0x27, 0x00, 0x00, 0xff, 0xff, 0x61, 0xcb,
+	0xd5, 0x08, 0x55, 0x08, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -455,8 +455,8 @@ type QueryClient interface {
 	OsmosisArithmeticTwap(ctx context.Context, in *QueryOsmosisArithmeticTwapRequest, opts ...grpc.CallOption) (*QueryOsmosisArithmeticTwapResponse, error)
 	// FeeabsModuleBalances return total balances of feeabs module
 	FeeabsModuleBalances(ctx context.Context, in *QueryFeeabsModuleBalacesRequest, opts ...grpc.CallOption) (*QueryFeeabsModuleBalacesResponse, error)
-	HostChainConfig(ctx context.Context, in *QueryHostChainConfigRequest, opts ...grpc.CallOption) (*QueryHostChainConfigRespone, error)
-	AllHostChainConfig(ctx context.Context, in *AllQueryHostChainConfigRequest, opts ...grpc.CallOption) (*AllQueryHostChainConfigRespone, error)
+	HostChainConfig(ctx context.Context, in *QueryHostChainConfigRequest, opts ...grpc.CallOption) (*QueryHostChainConfigResponse, error)
+	AllHostChainConfig(ctx context.Context, in *AllQueryHostChainConfigRequest, opts ...grpc.CallOption) (*AllQueryHostChainConfigResponse, error)
 }
 
 type queryClient struct {
@@ -485,8 +485,8 @@ func (c *queryClient) FeeabsModuleBalances(ctx context.Context, in *QueryFeeabsM
 	return out, nil
 }
 
-func (c *queryClient) HostChainConfig(ctx context.Context, in *QueryHostChainConfigRequest, opts ...grpc.CallOption) (*QueryHostChainConfigRespone, error) {
-	out := new(QueryHostChainConfigRespone)
+func (c *queryClient) HostChainConfig(ctx context.Context, in *QueryHostChainConfigRequest, opts ...grpc.CallOption) (*QueryHostChainConfigResponse, error) {
+	out := new(QueryHostChainConfigResponse)
 	err := c.cc.Invoke(ctx, "/feeabstraction.absfee.v1beta1.Query/HostChainConfig", in, out, opts...)
 	if err != nil {
 		return nil, err
@@ -494,8 +494,8 @@ func (c *queryClient) HostChainConfig(ctx context.Context, in *QueryHostChainCon
 	return out, nil
 }
 
-func (c *queryClient) AllHostChainConfig(ctx context.Context, in *AllQueryHostChainConfigRequest, opts ...grpc.CallOption) (*AllQueryHostChainConfigRespone, error) {
-	out := new(AllQueryHostChainConfigRespone)
+func (c *queryClient) AllHostChainConfig(ctx context.Context, in *AllQueryHostChainConfigRequest, opts ...grpc.CallOption) (*AllQueryHostChainConfigResponse, error) {
+	out := new(AllQueryHostChainConfigResponse)
 	err := c.cc.Invoke(ctx, "/feeabstraction.absfee.v1beta1.Query/AllHostChainConfig", in, out, opts...)
 	if err != nil {
 		return nil, err
@@ -509,8 +509,8 @@ type QueryServer interface {
 	OsmosisArithmeticTwap(context.Context, *QueryOsmosisArithmeticTwapRequest) (*QueryOsmosisArithmeticTwapResponse, error)
 	// FeeabsModuleBalances return total balances of feeabs module
 	FeeabsModuleBalances(context.Context, *QueryFeeabsModuleBalacesRequest) (*QueryFeeabsModuleBalacesResponse, error)
-	HostChainConfig(context.Context, *QueryHostChainConfigRequest) (*QueryHostChainConfigRespone, error)
-	AllHostChainConfig(context.Context, *AllQueryHostChainConfigRequest) (*AllQueryHostChainConfigRespone, error)
+	HostChainConfig(context.Context, *QueryHostChainConfigRequest) (*QueryHostChainConfigResponse, error)
+	AllHostChainConfig(context.Context, *AllQueryHostChainConfigRequest) (*AllQueryHostChainConfigResponse, error)
 }
 
 // UnimplementedQueryServer can be embedded to have forward compatible implementations.
@@ -523,10 +523,10 @@ func (*UnimplementedQueryServer) OsmosisArithmeticTwap(ctx context.Context, req
 func (*UnimplementedQueryServer) FeeabsModuleBalances(ctx context.Context, req *QueryFeeabsModuleBalacesRequest) (*QueryFeeabsModuleBalacesResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method FeeabsModuleBalances not implemented")
 }
-func (*UnimplementedQueryServer) HostChainConfig(ctx context.Context, req *QueryHostChainConfigRequest) (*QueryHostChainConfigRespone, error) {
+func (*UnimplementedQueryServer) HostChainConfig(ctx context.Context, req *QueryHostChainConfigRequest) (*QueryHostChainConfigResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method HostChainConfig not implemented")
 }
-func (*UnimplementedQueryServer) AllHostChainConfig(ctx context.Context, req *AllQueryHostChainConfigRequest) (*AllQueryHostChainConfigRespone, error) {
+func (*UnimplementedQueryServer) AllHostChainConfig(ctx context.Context, req *AllQueryHostChainConfigRequest) (*AllQueryHostChainConfigResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method AllHostChainConfig not implemented")
 }
 
@@ -661,7 +661,7 @@ func (m *QueryHostChainConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, er
 	return len(dAtA) - i, nil
 }
 
-func (m *QueryHostChainConfigRespone) Marshal() (dAtA []byte, err error) {
+func (m *QueryHostChainConfigResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -671,12 +671,12 @@ func (m *QueryHostChainConfigRespone) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *QueryHostChainConfigRespone) MarshalTo(dAtA []byte) (int, error) {
+func (m *QueryHostChainConfigResponse) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *QueryHostChainConfigRespone) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *QueryHostChainConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -847,7 +847,7 @@ func (m *AllQueryHostChainConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int,
 	return len(dAtA) - i, nil
 }
 
-func (m *AllQueryHostChainConfigRespone) Marshal() (dAtA []byte, err error) {
+func (m *AllQueryHostChainConfigResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -857,12 +857,12 @@ func (m *AllQueryHostChainConfigRespone) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *AllQueryHostChainConfigRespone) MarshalTo(dAtA []byte) (int, error) {
+func (m *AllQueryHostChainConfigResponse) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *AllQueryHostChainConfigRespone) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *AllQueryHostChainConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -908,7 +908,7 @@ func (m *QueryHostChainConfigRequest) Size() (n int) {
 	return n
 }
 
-func (m *QueryHostChainConfigRespone) Size() (n int) {
+func (m *QueryHostChainConfigResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -980,7 +980,7 @@ func (m *AllQueryHostChainConfigRequest) Size() (n int) {
 	return n
 }
 
-func (m *AllQueryHostChainConfigRespone) Size() (n int) {
+func (m *AllQueryHostChainConfigResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -1083,7 +1083,7 @@ func (m *QueryHostChainConfigRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryHostChainConfigRespone) Unmarshal(dAtA []byte) error {
+func (m *QueryHostChainConfigResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1106,10 +1106,10 @@ func (m *QueryHostChainConfigRespone) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryHostChainConfigRespone: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryHostChainConfigResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryHostChainConfigRespone: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryHostChainConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -1548,7 +1548,7 @@ func (m *AllQueryHostChainConfigRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *AllQueryHostChainConfigRespone) Unmarshal(dAtA []byte) error {
+func (m *AllQueryHostChainConfigResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1571,10 +1571,10 @@ func (m *AllQueryHostChainConfigRespone) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: AllQueryHostChainConfigRespone: wiretype end group for non-group")
+			return fmt.Errorf("proto: AllQueryHostChainConfigResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: AllQueryHostChainConfigRespone: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: AllQueryHostChainConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1: