feat: enhance error classification for RelayMiner errors

Add comprehensive error classification for RelayMiner errors from
poktroll/pkg/relayer/proxy/errors.go. This enables proper handling
of all RelayMiner error types, including making timeouts retryable.

Changes:
- Add 10 new error types in shannon.proto for RelayMiner-specific errors
- Update classifyMalformedEndpointPayload to detect RelayMiner error messages
- Make RAW_PAYLOAD_RELAY_MINER_TIMEOUT retryable (timeout errors should retry)
- Add comprehensive unit tests for error classification

RelayMiner Error Mapping:
- Code 1: invalid session -> RELAY_MINER_INVALID_SESSION
- Code 2: configs undefined -> RELAY_MINER_SERVICE_CONFIG_UNDEFINED
- Code 4: unsupported transport -> RELAY_MINER_UNSUPPORTED_TRANSPORT
- Code 5: internal error -> RELAY_MINER_INTERNAL_ERROR
- Code 6: unknown session -> RELAY_MINER_UNKNOWN_SESSION
- Code 7: rate limited -> RELAY_MINER_RATE_LIMITED
- Code 8: relay cost calc -> RELAY_MINER_RELAY_COST_CALCULATION
- Code 10: timeout -> RELAY_MINER_TIMEOUT (RETRYABLE!)
- Code 13: request limit -> RELAY_MINER_REQUEST_LIMIT_EXCEEDED
- Code 14: unmarshal request -> RELAY_MINER_UNMARSHAL_REQUEST

Author: jorgecuesta

observation/protocol/shannon.pb.go

@@ -130,6 +130,39 @@ enum ShannonEndpointErrorType {
 
   // RelayMiner returned a 5XX HTTP status code
   SHANNON_ENDPOINT_ERROR_RELAY_MINER_HTTP_5XX = 43;
+
+  // RelayMiner-specific error types (from poktroll/pkg/relayer/proxy/errors.go)
+  // These errors are returned by the RelayMiner in the raw payload
+
+  // RelayMiner request timed out (code 10) - RETRYABLE
+  SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_TIMEOUT = 44;
+
+  // RelayMiner invalid session error (code 1)
+  SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_INVALID_SESSION = 45;
+
+  // RelayMiner services configs undefined (code 2)
+  SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_SERVICE_CONFIG_UNDEFINED = 46;
+
+  // RelayMiner unsupported transport type (code 4)
+  SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_UNSUPPORTED_TRANSPORT = 47;
+
+  // RelayMiner internal error (code 5)
+  SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_INTERNAL_ERROR = 48;
+
+  // RelayMiner unknown session (code 6)
+  SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_UNKNOWN_SESSION = 49;
+
+  // RelayMiner rate limited (code 7)
+  SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_RATE_LIMITED = 50;
+
+  // RelayMiner failed to calculate relay cost (code 8)
+  SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_RELAY_COST_CALCULATION = 51;
+
+  // RelayMiner request limit exceeded (code 13)
+  SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_REQUEST_LIMIT_EXCEEDED = 52;
+
+  // RelayMiner failed to unmarshal relay request (code 14)
+  SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_UNMARSHAL_REQUEST = 53;
 }
 
 // ShannonSanctionType specifies the duration type for endpoint sanctions

proto/path/protocol/shannon.proto

@@ -101,11 +101,12 @@ func isRetryableErrorType(errorType protocolobservations.ShannonEndpointErrorTyp
 	}
 
 	switch errorType {
-	// Timeout errors
+	// Timeout errors (including RelayMiner timeout from poktroll)
 	case protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_TIMEOUT,
 		protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_IO_TIMEOUT,
 		protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_CONTEXT_DEADLINE_EXCEEDED,
-		protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_CONNECTION_TIMEOUT:
+		protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_CONNECTION_TIMEOUT,
+		protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_TIMEOUT:
 		return config.RetryOnTimeout
 
 	// Connection errors

protocol/shannon/retry.go

@@ -162,6 +162,8 @@ func TestIsRetryableErrorType_TimeoutErrors(t *testing.T) {
 		protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_IO_TIMEOUT,
 		protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_CONTEXT_DEADLINE_EXCEEDED,
 		protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_HTTP_CONNECTION_TIMEOUT,
+		// RelayMiner timeout from poktroll (code 10)
+		protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_TIMEOUT,
 	}
 
 	// With timeout retry enabled

protocol/shannon/retry_test.go

@@ -292,6 +292,62 @@ func classifyMalformedEndpointPayload(logger polylog.Logger, payloadContent stri
 		return protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_HTTP_TRANSPORT, protocolobservations.ShannonSanctionType_SHANNON_SANCTION_SESSION
 	}
 
+	// ============================================================================
+	// RelayMiner-specific errors (from poktroll/pkg/relayer/proxy/errors.go)
+	// These match the exact error messages returned by the RelayMiner
+	// ============================================================================
+
+	// RelayMiner timeout (code 10) - RETRYABLE: transient error, may succeed on different endpoint
+	if strings.Contains(payloadContent, "relayer proxy request timed out") {
+		return protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_TIMEOUT, protocolobservations.ShannonSanctionType_SHANNON_SANCTION_SESSION
+	}
+
+	// RelayMiner invalid session (code 1) - session validation failed
+	if strings.Contains(payloadContent, "invalid session in relayer request") {
+		return protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_INVALID_SESSION, protocolobservations.ShannonSanctionType_SHANNON_SANCTION_SESSION
+	}
+
+	// RelayMiner services configs undefined (code 2) - configuration error
+	if strings.Contains(payloadContent, "services configurations are undefined") {
+		return protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_SERVICE_CONFIG_UNDEFINED, protocolobservations.ShannonSanctionType_SHANNON_SANCTION_PERMANENT
+	}
+
+	// RelayMiner unsupported transport type (code 4) - configuration error
+	if strings.Contains(payloadContent, "unsupported proxy transport type") {
+		return protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_UNSUPPORTED_TRANSPORT, protocolobservations.ShannonSanctionType_SHANNON_SANCTION_PERMANENT
+	}
+
+	// RelayMiner internal error (code 5) - internal relay miner error
+	// Note: Match exact phrase to avoid false positives with generic "internal error" strings
+	if strings.Contains(payloadContent, "internal error") && strings.Contains(payloadContent, "relayer") {
+		return protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_INTERNAL_ERROR, protocolobservations.ShannonSanctionType_SHANNON_SANCTION_SESSION
+	}
+
+	// RelayMiner unknown session (code 6) - session not found
+	if strings.Contains(payloadContent, "relayer proxy encountered unknown session") {
+		return protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_UNKNOWN_SESSION, protocolobservations.ShannonSanctionType_SHANNON_SANCTION_SESSION
+	}
+
+	// RelayMiner rate limited (code 7) - offchain rate limit hit
+	if strings.Contains(payloadContent, "offchain rate limit hit by relayer proxy") {
+		return protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_RATE_LIMITED, protocolobservations.ShannonSanctionType_SHANNON_SANCTION_SESSION
+	}
+
+	// RelayMiner relay cost calculation failed (code 8)
+	if strings.Contains(payloadContent, "failed to calculate relay cost") {
+		return protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_RELAY_COST_CALCULATION, protocolobservations.ShannonSanctionType_SHANNON_SANCTION_SESSION
+	}
+
+	// RelayMiner request limit exceeded (code 13)
+	if strings.Contains(payloadContent, "request limit exceed") {
+		return protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_REQUEST_LIMIT_EXCEEDED, protocolobservations.ShannonSanctionType_SHANNON_SANCTION_DO_NOT_SANCTION
+	}
+
+	// RelayMiner unmarshal relay request failed (code 14)
+	if strings.Contains(payloadContent, "failed to unmarshal relay request") {
+		return protocolobservations.ShannonEndpointErrorType_SHANNON_ENDPOINT_ERROR_RAW_PAYLOAD_RELAY_MINER_UNMARSHAL_REQUEST, protocolobservations.ShannonSanctionType_SHANNON_SANCTION_SESSION
+	}
+
 	// If we can't classify the malformed payload, it's an internal error
 	logger.With(
 		"endpoint_payload_preview", payloadContent[:min(100, len(payloadContent))],