fix: svm event gas fee used report

Author: Aman035

universalClient/chains/svm/event_confirmer.go

@@ -2,7 +2,6 @@ package svm
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"strings"
 	"sync"
@@ -170,34 +169,8 @@ func (ec *EventConfirmer) processPendingEvents(ctx context.Context) error {
 		confirmations := latestSlot - txSlot + 1
 
 		if confirmations >= requiredConfirmations {
-			var rowsAffected int64
-
-			// For outbound events, enrich with gas fee from tx metadata
-			if event.Type == chaincommon.EventTypeOutbound {
-				var outboundEvent chaincommon.OutboundEvent
-				if unmarshalErr := json.Unmarshal(event.EventData, &outboundEvent); unmarshalErr != nil {
-					ec.logger.Error().
-						Err(unmarshalErr).
-						Str("event_id", event.EventID).
-						Msg("failed to unmarshal outbound event data")
-					continue
-				}
-				outboundEvent.GasFeeUsed = "0"
-
-				updatedData, marshalErr := json.Marshal(outboundEvent)
-				if marshalErr != nil {
-					ec.logger.Error().
-						Err(marshalErr).
-						Str("event_id", event.EventID).
-						Msg("failed to marshal enriched outbound event data")
-					continue
-				}
-
-				rowsAffected, err = ec.chainStore.UpdateStatusAndEventData(event.EventID, "PENDING", "CONFIRMED", updatedData)
-			} else {
-				rowsAffected, err = ec.chainStore.UpdateEventStatus(event.EventID, "PENDING", "CONFIRMED")
-			}
-
+			// GasFeeUsed for outbound events is already set by the event parser from the on-chain event data
+			rowsAffected, err := ec.chainStore.UpdateEventStatus(event.EventID, "PENDING", "CONFIRMED")
 			if err != nil {
 				ec.logger.Error().
 					Err(err).

universalClient/chains/svm/event_parser.go

@@ -101,11 +101,17 @@ func parseSendFundsEvent(log string, signature string, slot uint64, logIndex uin
 	return event
 }
 
-// parseOutboundObservationEvent parses an outboundObservation event
+// parseOutboundObservationEvent parses an outboundObservation event (UniversalTxFinalized)
 // Event structure (Borsh serialized):
 // - discriminator (8 bytes)
-// - sub_tx_id (32 bytes - bytes32)
-// - universal_tx_id (32 bytes - bytes32)
+// - sub_tx_id (32 bytes)
+// - universal_tx_id (32 bytes)
+// - gas_fee (8 bytes, u64 lamports)
+// - push_account (20 bytes)
+// - target (32 bytes, Pubkey)
+// - token (32 bytes, Pubkey)
+// - amount (8 bytes, u64)
+// - payload (4 bytes length + data, Vec<u8>)
 func parseOutboundObservationEvent(log string, signature string, slot uint64, logIndex uint, chainID string, logger zerolog.Logger) *store.Event {
 	if !strings.HasPrefix(log, "Program data: ") {
 		return nil
@@ -117,11 +123,11 @@ func parseOutboundObservationEvent(log string, signature string, slot uint64, lo
 		return nil
 	}
 
-	// Need at least: 8 bytes discriminator + 32 bytes txID + 32 bytes universalTxID = 72 bytes
-	if len(decoded) < 72 {
+	// Minimum: 8 disc + 32 sub_tx_id + 32 universal_tx_id + 8 gas_fee = 80 bytes
+	if len(decoded) < 80 {
 		logger.Warn().
 			Int("data_len", len(decoded)).
-			Msg("data too short for outboundObservation event; need at least 72 bytes")
+			Msg("data too short for outboundObservation event; need at least 80 bytes")
 		return nil
 	}
 
@@ -144,11 +150,16 @@ func parseOutboundObservationEvent(log string, signature string, slot uint64, lo
 
 	// Extract universalTxID (32 bytes)
 	universalTxID := "0x" + hex.EncodeToString(decoded[offset:offset+32])
+	offset += 32
+
+	// Extract gas_fee (8 bytes, u64 little-endian lamports)
+	gasFee := binary.LittleEndian.Uint64(decoded[offset : offset+8])
 
 	// Create OutboundEvent payload
 	payload := common.OutboundEvent{
 		TxID:          txID,
 		UniversalTxID: universalTxID,
+		GasFeeUsed:    fmt.Sprintf("%d", gasFee),
 	}
 
 	// Marshal payload to JSON
@@ -176,6 +187,7 @@ func parseOutboundObservationEvent(log string, signature string, slot uint64, lo
 		Str("event_id", eventID).
 		Str("tx_id", txID).
 		Str("universal_tx_id", universalTxID).
+		Str("gas_fee", fmt.Sprintf("%d", gasFee)).
 		Msg("parsed outboundObservation event")
 
 	return event

universalClient/chains/svm/event_parser_test.go

@@ -2,6 +2,7 @@ package svm
 
 import (
 	"encoding/base64"
+	"encoding/binary"
 	"encoding/hex"
 	"encoding/json"
 	"testing"
@@ -19,12 +20,15 @@ func TestParseOutboundObservationEvent(t *testing.T) {
 	chainID := "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"
 	signature := "5wHu1qwD7q5xMkZxq6z2S3r4y5N7m8P9kL0jH1gF2dE3cB4aA5b6C7d8E9f0G1h2"
 
-	// Helper to create base64-encoded log data
-	createLogData := func(discriminator []byte, txID []byte, universalTxID []byte) string {
-		data := make([]byte, 0, 72)
+	// Helper to create base64-encoded log data with gas_fee
+	createLogData := func(discriminator []byte, txID []byte, universalTxID []byte, gasFee uint64) string {
+		data := make([]byte, 0, 80)
 		data = append(data, discriminator...)
 		data = append(data, txID...)
 		data = append(data, universalTxID...)
+		gasFeeBytes := make([]byte, 8)
+		binary.LittleEndian.PutUint64(gasFeeBytes, gasFee)
+		data = append(data, gasFeeBytes...)
 		return "Program data: " + base64.StdEncoding.EncodeToString(data)
 	}
 
@@ -54,7 +58,7 @@ func TestParseOutboundObservationEvent(t *testing.T) {
 	}{
 		{
 			name:      "parses valid outbound observation event",
-			log:       createLogData(discriminator, txID, universalTxID),
+			log:       createLogData(discriminator, txID, universalTxID, 5000),
 			wantEvent: true,
 			validate: func(t *testing.T, event *store.Event) {
 				assert.Contains(t, event.EventID, signature)
@@ -63,7 +67,7 @@ func TestParseOutboundObservationEvent(t *testing.T) {
 				assert.Equal(t, "PENDING", event.Status)
 				assert.Equal(t, "STANDARD", event.ConfirmationType)
 
-				// Verify event data contains tx_id and universal_tx_id
+				// Verify event data contains tx_id, universal_tx_id, and gas_fee_used
 				assert.NotNil(t, event.EventData)
 				var outboundData map[string]any
 				err := json.Unmarshal(event.EventData, &outboundData)
@@ -74,6 +78,7 @@ func TestParseOutboundObservationEvent(t *testing.T) {
 
 				assert.Equal(t, expectedTxID, outboundData["tx_id"])
 				assert.Equal(t, expectedUniversalTxID, outboundData["universal_tx_id"])
+				assert.Equal(t, "5000", outboundData["gas_fee_used"])
 			},
 		},
 		{
@@ -92,27 +97,29 @@ func TestParseOutboundObservationEvent(t *testing.T) {
 			wantEvent: false,
 		},
 		{
-			name: "returns nil for data too short (less than 72 bytes)",
+			name: "returns nil for data too short (less than 80 bytes)",
 			log: func() string {
-				// Only 64 bytes (8 discriminator + 32 txID, missing universalTxID)
-				shortData := make([]byte, 64)
+				// Only 72 bytes (8 discriminator + 32 txID + 32 universalTxID, missing gas_fee)
+				shortData := make([]byte, 72)
 				copy(shortData[:8], discriminator)
 				copy(shortData[8:40], txID)
+				copy(shortData[40:72], universalTxID)
 				return "Program data: " + base64.StdEncoding.EncodeToString(shortData)
 			}(),
 			wantEvent: false,
 		},
 		{
-			name: "correctly parses minimum valid data (exactly 72 bytes)",
+			name: "correctly parses minimum valid data (exactly 80 bytes)",
 			log: func() string {
-				exactData := make([]byte, 72)
+				exactData := make([]byte, 80)
 				copy(exactData[:8], discriminator)
 				for i := 8; i < 40; i++ {
 					exactData[i] = 0x11 // txID
 				}
 				for i := 40; i < 72; i++ {
 					exactData[i] = 0x22 // universalTxID
 				}
+				binary.LittleEndian.PutUint64(exactData[72:80], 12345) // gas_fee
 				return "Program data: " + base64.StdEncoding.EncodeToString(exactData)
 			}(),
 			wantEvent: true,
@@ -121,21 +128,22 @@ func TestParseOutboundObservationEvent(t *testing.T) {
 				err := json.Unmarshal(event.EventData, &outboundData)
 				require.NoError(t, err)
 
-				// Verify the values are correctly parsed
 				assert.Contains(t, outboundData["tx_id"], "0x1111")
 				assert.Contains(t, outboundData["universal_tx_id"], "0x2222")
+				assert.Equal(t, "12345", outboundData["gas_fee_used"])
 			},
 		},
 		{
-			name: "handles data longer than 72 bytes",
+			name: "handles data longer than 80 bytes",
 			log: func() string {
-				// 100 bytes - extra data after the required fields should be ignored
-				longData := make([]byte, 100)
+				// 120 bytes - extra data after the required fields should be ignored
+				longData := make([]byte, 120)
 				copy(longData[:8], discriminator)
 				copy(longData[8:40], txID)
 				copy(longData[40:72], universalTxID)
+				binary.LittleEndian.PutUint64(longData[72:80], 9999) // gas_fee
 				// Extra bytes at the end
-				for i := 72; i < 100; i++ {
+				for i := 80; i < 120; i++ {
 					longData[i] = 0xFF
 				}
 				return "Program data: " + base64.StdEncoding.EncodeToString(longData)
@@ -151,6 +159,7 @@ func TestParseOutboundObservationEvent(t *testing.T) {
 
 				assert.Equal(t, expectedTxID, outboundData["tx_id"])
 				assert.Equal(t, expectedUniversalTxID, outboundData["universal_tx_id"])
+				assert.Equal(t, "9999", outboundData["gas_fee_used"])
 			},
 		},
 	}
@@ -193,14 +202,15 @@ func TestParseOutboundObservationEvent_EventIDFormat(t *testing.T) {
 	logger := zerolog.New(nil).Level(zerolog.Disabled)
 	chainID := "solana:devnet"
 
-	// Create valid outbound data
-	data := make([]byte, 72)
+	// Create valid outbound data (80 bytes minimum: 8 disc + 32 txID + 32 utxID + 8 gas_fee)
+	data := make([]byte, 80)
 	for i := 0; i < 8; i++ {
 		data[i] = byte(i) // discriminator
 	}
 	for i := 8; i < 72; i++ {
 		data[i] = byte(i % 256) // txID and universalTxID
 	}
+	binary.LittleEndian.PutUint64(data[72:80], 0) // gas_fee
 	log := "Program data: " + base64.StdEncoding.EncodeToString(data)
 
 	tests := []struct {