Make cleaner for callers by not exposing success parameter - callers can decide whether to take different action on nilPtr

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

Author: davecrighton

internal/operations/operation_updater.go

@@ -422,8 +422,8 @@ func (ou *operationUpdater) resolveOperation(ctx context.Context, ns string, id
 	if status != "" {
 		update = update.Set("status", status)
 	}
-	if safeErr, ok := utils.DBSafeUTF8StringFromPtr(ctx, errorMsg); ok {
-		update = update.Set("error", safeErr)
+	if errorMsg != nil {
+		update = update.Set("error", utils.DBSafeUTF8StringFromPtr(ctx, errorMsg))
 	}
 	if output != nil {
 		update = update.Set("output", output)

pkg/utils/dbstring.go

@@ -25,18 +25,18 @@ import (
 	"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) {
+// DBSafeUTF8StringFromPtr returns a DB-safe UTF-8 string from a pointer.
+// Nil pointers return "". 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 {
 	if s == nil {
-		return "", false
+		return ""
 	}
 	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 hexString
 	}
-	return *s, true
+	return *s
 }

pkg/utils/dbstring_test.go

@@ -24,32 +24,20 @@ import (
 )
 
 func TestDBSafeUTF8StringFromPtrNil(t *testing.T) {
-	s, ok := DBSafeUTF8StringFromPtr(context.Background(), nil)
-	assert.False(t, ok)
-	assert.Equal(t, "", s)
+	assert.Equal(t, "", DBSafeUTF8StringFromPtr(context.Background(), nil))
 }
 
 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)
+	assert.Equal(t, msg, DBSafeUTF8StringFromPtr(context.Background(), &msg))
 }
 
 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)
+	assert.Equal(t, "5b4f4350455d3430342f3938202d2008c379a00000005b544d4d5d3430342f313665", DBSafeUTF8StringFromPtr(context.Background(), &msg))
 }
 
 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)
+	assert.Equal(t, "68656c6c6f00776f726c64", DBSafeUTF8StringFromPtr(context.Background(), &msg))
 }