PR feedback: utility function

Signed-off-by: Dave Crighton <dave.crighton@kaleido.io>

Author: davecrighton

internal/operations/operation_updater.go

@@ -18,11 +18,8 @@ package operations
 
 import (
 	"context"
-	"encoding/hex"
 	"fmt"
-	"strings"
 	"time"
-	"unicode/utf8"
 
 	"github.com/hyperledger/firefly-common/pkg/config"
 	"github.com/hyperledger/firefly-common/pkg/ffapi"
@@ -35,6 +32,7 @@ import (
 	"github.com/hyperledger/firefly/internal/txcommon"
 	"github.com/hyperledger/firefly/pkg/core"
 	"github.com/hyperledger/firefly/pkg/database"
+	"github.com/hyperledger/firefly/pkg/utils"
 )
 
 type operationUpdaterBatch struct {
@@ -424,16 +422,8 @@ func (ou *operationUpdater) resolveOperation(ctx context.Context, ns string, id
 	if status != "" {
 		update = update.Set("status", status)
 	}
-	if errorMsg != nil {
-		// PostgreSQL text columns reject null bytes and invalid UTF-8 sequences.
-		// Null bytes (0x00) are valid UTF-8 but rejected by PostgreSQL, so check both.
-		if !utf8.ValidString(*errorMsg) || strings.ContainsRune(*errorMsg, 0) {
-			hexString := hex.EncodeToString([]byte(*errorMsg))
-			log.L(ctx).Warnf("Error message contains invalid UTF-8 or null bytes - encoding as hex: %s", hexString)
-			update = update.Set("error", hexString)
-		} else {
-			update = update.Set("error", *errorMsg)
-		}
+	if safeErr, ok := utils.DBSafeUTF8StringFromPtr(ctx, errorMsg); ok {
+		update = update.Set("error", safeErr)
 	}
 	if output != nil {
 		update = update.Set("output", output)

pkg/utils/dbstring.go

@@ -0,0 +1,42 @@
+// Copyright © 2026 Kaleido, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package utils
+
+import (
+	"context"
+	"encoding/hex"
+	"strings"
+	"unicode/utf8"
+
+	"github.com/hyperledger/firefly-common/pkg/log"
+)
+
+// DBSafeUTF8StringFromPtr returns a DB-safe UTF-8 string from a pointer, and true if the pointer
+// was non-nil. Strings containing invalid UTF-8 sequences or null bytes (which PostgreSQL rejects
+// in text columns even though null bytes are technically valid UTF-8) are hex-encoded instead,
+// with a warning logged.
+func DBSafeUTF8StringFromPtr(ctx context.Context, s *string) (string, bool) {
+	if s == nil {
+		return "", false
+	}
+	if !utf8.ValidString(*s) || strings.ContainsRune(*s, 0) {
+		hexString := hex.EncodeToString([]byte(*s))
+		log.L(ctx).Warnf("String contains invalid UTF-8 or null bytes - encoding as hex: %s", hexString)
+		return hexString, true
+	}
+	return *s, true
+}

pkg/utils/dbstring_test.go

@@ -0,0 +1,55 @@
+// Copyright © 2026 Kaleido, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package utils
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDBSafeUTF8StringFromPtrNil(t *testing.T) {
+	s, ok := DBSafeUTF8StringFromPtr(context.Background(), nil)
+	assert.False(t, ok)
+	assert.Equal(t, "", s)
+}
+
+func TestDBSafeUTF8StringFromPtrValid(t *testing.T) {
+	msg := "FF23021: EVM reverted: some normal error message"
+	s, ok := DBSafeUTF8StringFromPtr(context.Background(), &msg)
+	assert.True(t, ok)
+	assert.Equal(t, msg, s)
+}
+
+func TestDBSafeUTF8StringFromPtrInvalidUTF8(t *testing.T) {
+	// Simulate the actual revert scenario: readable text with embedded ABI-encoded Error(string)
+	// selector bytes (0x08, 0xc3, 0x79, 0xa0) and null byte padding, which is invalid UTF-8
+	msg := "[OCPE]404/98 - \x08\xc3\x79\xa0\x00\x00\x00[TMM]404/16e"
+	s, ok := DBSafeUTF8StringFromPtr(context.Background(), &msg)
+	assert.True(t, ok)
+	assert.Equal(t, "5b4f4350455d3430342f3938202d2008c379a00000005b544d4d5d3430342f313665", s)
+}
+
+func TestDBSafeUTF8StringFromPtrNullBytesInValidUTF8(t *testing.T) {
+	// Pure null bytes embedded in otherwise valid UTF-8 text.
+	// utf8.ValidString returns true for this, but PostgreSQL rejects 0x00 in text columns.
+	msg := "hello\x00world"
+	s, ok := DBSafeUTF8StringFromPtr(context.Background(), &msg)
+	assert.True(t, ok)
+	assert.Equal(t, "68656c6c6f00776f726c64", s)
+}