perf: add GIGA_SUPPRESS_COSMOS_EVENTS flag to skip dead event emission

Cosmos-level events (coin_spent, coin_received, transfer, etc.) emitted
during giga executor tx execution are never consumed: the ExecTxResult
is built without populating the Events field, and events are not
consensus-critical (stripped from deterministicExecTxResult).

EVM logs (Solidity events) flow through a completely separate path
(tempState.logs -> receipts + MsgEVMTransactionResponse) and are
unaffected.

When GIGA_SUPPRESS_COSMOS_EVENTS=true:
- EventManager.EmitEvent/EmitEvents return immediately (no mutex, no
  append, no bech32 encoding in event attributes)
- Snapshot() creates suppressed EventManagers
- Finalize() skips the flushEvents() consolidation loop

This eliminates ~55s of mutex contention per 30s profile window:
- AccAddress.String() bech32 cache mutex: ~27s
- EventManager.EmitEvents RWMutex: ~28s

Also updates benchmark/analysis/ with findings from the AccAddress.String
sync.Map optimization (PR #2902) and this event suppression discovery.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: pdrobnjak

app/app.go

@@ -327,6 +327,10 @@ type gigaBlockCache struct {
 	blockCtx    vm.BlockContext
 	chainConfig *ethparams.ChainConfig
 	baseFee     *big.Int
+
+	// when true, Cosmos-level events (coin_spent, coin_received, etc.) are
+	// discarded during giga executor tx execution.  EVM logs are unaffected.
+	suppressCosmosEvents bool
 }
 
 func newGigaBlockCache(ctx sdk.Context, keeper *gigaevmkeeper.Keeper) (*gigaBlockCache, error) {
@@ -340,10 +344,11 @@ func newGigaBlockCache(ctx sdk.Context, keeper *gigaevmkeeper.Keeper) (*gigaBloc
 	chainConfig := evmtypes.DefaultChainConfig().EthereumConfigWithSstore(chainID, &sstore)
 	baseFee := keeper.GetBaseFee(ctx)
 	return &gigaBlockCache{
-		chainID:     chainID,
-		blockCtx:    *blockCtx,
-		chainConfig: chainConfig,
-		baseFee:     baseFee,
+		chainID:              chainID,
+		blockCtx:             *blockCtx,
+		chainConfig:          chainConfig,
+		baseFee:              baseFee,
+		suppressCosmosEvents: os.Getenv("GIGA_SUPPRESS_COSMOS_EVENTS") == "true",
 	}, nil
 }
 
@@ -1793,6 +1798,9 @@ func (app *App) executeEVMTxWithGigaExecutor(ctx sdk.Context, msg *evmtypes.MsgE
 
 	// Create state DB for this transaction
 	stateDB := gigaevmstate.NewDBImpl(ctx, &app.GigaEvmKeeper, false)
+	if cache.suppressCosmosEvents {
+		stateDB.SuppressCosmosEvents()
+	}
 	defer stateDB.Cleanup()
 
 	// Get gas pool (mutated per tx, cannot be cached)

giga/deps/xevm/state/state.go

@@ -102,7 +102,11 @@ func (s *DBImpl) HasSelfDestructed(acc common.Address) bool {
 }
 
 func (s *DBImpl) Snapshot() int {
-	newCtx := s.ctx.WithMultiStore(s.ctx.MultiStore().CacheMultiStore()).WithEventManager(sdk.NewEventManager())
+	em := sdk.NewEventManager()
+	if s.cosmosEventsSuppressed {
+		em = sdk.NewSuppressedEventManager()
+	}
+	newCtx := s.ctx.WithMultiStore(s.ctx.MultiStore().CacheMultiStore()).WithEventManager(em)
 	s.snapshottedCtxs = append(s.snapshottedCtxs, s.ctx)
 	s.ctx = newCtx
 	version := len(s.snapshottedCtxs) - 1

giga/deps/xevm/state/statedb.go

@@ -39,6 +39,11 @@ type DBImpl struct {
 	// for cases like bank.send_native, we want to suppress transfer events
 	eventsSuppressed bool
 
+	// when true, all Cosmos-level events (coin_spent, coin_received, etc.)
+	// are discarded. EVM logs are unaffected. Use this on the giga executor
+	// path where Cosmos events are constructed but never consumed.
+	cosmosEventsSuppressed bool
+
 	logger *tracing.Hooks
 }
 
@@ -66,6 +71,10 @@ func (s *DBImpl) EnableEvents() {
 	s.eventsSuppressed = false
 }
 
+func (s *DBImpl) SuppressCosmosEvents() {
+	s.cosmosEventsSuppressed = true
+}
+
 func (s *DBImpl) SetLogger(logger *tracing.Hooks) {
 	s.logger = logger
 }
@@ -112,11 +121,14 @@ func (s *DBImpl) Finalize() (surplus sdk.Int, err error) {
 	s.clearAccountStateIfDestructed(s.tempState)
 
 	s.flushCtxs()
-	// write all events in order
-	for i := 1; i < len(s.snapshottedCtxs); i++ {
-		s.flushEvents(s.snapshottedCtxs[i])
+	// write all events in order (skip when cosmos events are suppressed —
+	// the EventManagers are no-ops so there is nothing to consolidate)
+	if !s.cosmosEventsSuppressed {
+		for i := 1; i < len(s.snapshottedCtxs); i++ {
+			s.flushEvents(s.snapshottedCtxs[i])
+		}
+		s.flushEvents(s.ctx)
 	}
-	s.flushEvents(s.ctx)
 
 	surplus = s.tempState.surplus
 	return

sei-cosmos/types/events.go

@@ -28,7 +28,8 @@ import (
 type EventManager struct {
 	events Events
 
-	mtx sync.RWMutex
+	mtx        sync.RWMutex
+	suppressed bool
 }
 
 // Common Event Types and Attributes
@@ -55,11 +56,22 @@ func NewEventManager() *EventManager {
 	return &em
 }
 
+// NewSuppressedEventManager returns an EventManager that silently discards all
+// emitted events. Use this on hot paths where events are constructed but never
+// consumed (e.g. the giga executor) to avoid mutex contention, bech32 encoding
+// in event attributes, and allocation overhead.
+func NewSuppressedEventManager() *EventManager {
+	return &EventManager{suppressed: true}
+}
+
 func (em *EventManager) Events() Events { return em.events }
 
 // EmitEvent stores a single Event object.
 // Deprecated: Use EmitTypedEvent
 func (em *EventManager) EmitEvent(event Event) {
+	if em.suppressed {
+		return
+	}
 	em.mtx.Lock()
 	defer em.mtx.Unlock()
 	em.events = em.events.AppendEvent(event)
@@ -68,6 +80,9 @@ func (em *EventManager) EmitEvent(event Event) {
 // EmitEvents stores a series of Event objects.
 // Deprecated: Use EmitTypedEvents
 func (em *EventManager) EmitEvents(events Events) {
+	if em.suppressed {
+		return
+	}
 	em.mtx.Lock()
 	defer em.mtx.Unlock()
 	em.events = em.events.AppendEvents(events)