Move unwrap error to use new method

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

Author: davecrighton

pkg/abi/abi.go

@@ -320,14 +320,12 @@ func (a ABI) ParseError(revertData []byte) (*Entry, *ComponentValue, bool) {
 	return a.ParseErrorCtx(context.Background(), revertData)
 }
 
-// Returns the components value from the parsed error
+// ParseErrorCtx returns the matched Entry and decoded ComponentValue from the
+// given revert data. The ABI's error entries are tried first, followed by the
+// built-in Error(string) and Panic(uint256).
 func (a ABI) ParseErrorCtx(ctx context.Context, revertData []byte) (*Entry, *ComponentValue, bool) {
-	// Always include the default error
-	a = append(ABI{
-		{Type: Error, Name: "Error", Inputs: ParameterArray{{Name: "reason", Type: "string"}}},
-	}, a...)
-	for _, e := range a {
-		if e.Type == Error {
+	for _, source := range []ABI{a.errors(), defaultErrorEntries} {
+		for _, e := range source {
 			if cv, err := e.DecodeCallDataCtx(ctx, revertData); err == nil {
 				return e, cv, true
 			}
@@ -349,103 +347,24 @@ func (a ABI) ErrorStringCtx(ctx context.Context, revertData []byte) (strError st
 	return strError, ok
 }
 
-const maxNestedRevertDepth = 10
-
 // UnwrapErrorStringCtx is like ErrorStringCtx but handles nested errors caused by
-// Solidity contracts that catch a revert and re-throw using string(reason). This
-// embeds raw ABI-encoded error data (including null bytes from ABI padding) inside
-// the new Error(string). The function scans for all known error selectors,
-// recursively decodes nested Error(string) chains, and formats known custom errors.
-// Any undecoded binary data is hex-encoded.
+// Solidity contracts that catch a revert and re-throw using string(reason).
+// Delegates to DecodeRevertErrorCtx for structured decoding, then formats the
+// result as a human-readable string.
 func (a ABI) UnwrapErrorStringCtx(ctx context.Context, revertData []byte) (string, bool) {
-	e, cv, ok := a.ParseErrorCtx(ctx, revertData)
-	if !ok {
+	r := a.DecodeRevertErrorCtx(ctx, revertData)
+	if r == nil {
 		return "", false
 	}
-	// For Error(string), unwrap any nested errors inside the decoded string
-	if e.Name == "Error" && len(cv.Children) == 1 {
-		if strVal, ok := cv.Children[0].Value.(string); ok {
-			return unwrapNestedRevertReasons(ctx, a, strVal, 0), true
-		}
-	}
-	// For other error types, format directly
-	strError := FormatErrorStringCtx(ctx, e, cv)
-	return strError, strError != ""
+	s := r.String()
+	return s, s != ""
 }
 
 // UnwrapErrorString is a convenience wrapper for UnwrapErrorStringCtx.
 func (a ABI) UnwrapErrorString(revertData []byte) (string, bool) {
 	return a.UnwrapErrorStringCtx(context.Background(), revertData)
 }
 
-// unwrapNestedRevertReasons recursively decodes Error(string) values that contain
-// embedded ABI-encoded error data from Solidity catch-and-rethrow patterns.
-func unwrapNestedRevertReasons(ctx context.Context, a ABI, s string, depth int) string {
-	if depth >= maxNestedRevertDepth {
-		return SanitizeBinaryString([]byte(s))
-	}
-
-	raw := []byte(s)
-
-	// Build a lookup map of 4-byte selectors so we can scan the string once
-	type selectorKey = [4]byte
-	selectors := make(map[selectorKey]*Entry)
-	errorsWithDefault := append(ABI{
-		{Type: Error, Name: "Error", Inputs: ParameterArray{{Name: "reason", Type: "string"}}},
-	}, a...)
-	for _, e := range errorsWithDefault {
-		if e.Type != Error {
-			continue
-		}
-		sel := e.FunctionSelectorBytes()
-		if len(sel) >= 4 {
-			var key selectorKey
-			copy(key[:], sel[:4])
-			if _, exists := selectors[key]; !exists {
-				selectors[key] = e
-			}
-		}
-	}
-
-	// Single pass: walk through the bytes looking for any known selector
-	bestIdx := -1
-	var bestEntry *Entry
-	if len(raw) >= 4 {
-		for i := 0; i <= len(raw)-4; i++ {
-			var key selectorKey
-			copy(key[:], raw[i:i+4])
-			if e, ok := selectors[key]; ok {
-				bestIdx = i
-				bestEntry = e
-				break
-			}
-		}
-	}
-
-	if bestIdx < 0 {
-		return SanitizeBinaryString(raw)
-	}
-
-	prefix := SanitizeBinaryString(raw[:bestIdx])
-	embedded := raw[bestIdx:]
-
-	cv, err := bestEntry.DecodeCallDataCtx(ctx, embedded)
-	if err == nil {
-		if bestEntry.Name == "Error" && len(cv.Children) == 1 {
-			if nested, ok := cv.Children[0].Value.(string); ok {
-				return prefix + unwrapNestedRevertReasons(ctx, a, nested, depth+1)
-			}
-		}
-		formatted := FormatErrorStringCtx(ctx, bestEntry, cv)
-		if formatted != "" {
-			return prefix + formatted
-		}
-	}
-
-	log.L(ctx).Debugf("Could not decode nested revert at depth %d, hex-encoding remaining %d bytes", depth, len(embedded))
-	return prefix + "0x" + hex.EncodeToString(embedded)
-}
-
 // SanitizeBinaryString returns the input as a text string if it is entirely
 // printable ASCII, or hex-encodes the entire input otherwise. This ensures the
 // output is always safe for database TEXT columns and human-readable logging.

pkg/abi/abi_test.go

@@ -1104,7 +1104,7 @@ func TestUnwrapErrorStringPlainError(t *testing.T) {
 
 	result, ok := ABI{}.UnwrapErrorString(revertData)
 	assert.True(t, ok)
-	assert.Equal(t, "Not enough Ether provided.", result)
+	assert.Equal(t, `Error("Not enough Ether provided.")`, result)
 }
 
 func TestUnwrapErrorStringSingleNested(t *testing.T) {
@@ -1120,7 +1120,7 @@ func TestUnwrapErrorStringSingleNested(t *testing.T) {
 
 	result, ok := ABI{}.UnwrapErrorString(revertData)
 	assert.True(t, ok)
-	assert.Equal(t, "outer: inner error message", result)
+	assert.Equal(t, `outer: Error("inner error message")`, result)
 }
 
 func TestUnwrapErrorStringDoubleNested(t *testing.T) {
@@ -1140,7 +1140,7 @@ func TestUnwrapErrorStringDoubleNested(t *testing.T) {
 
 	result, ok := ABI{}.UnwrapErrorString(revertData)
 	assert.True(t, ok)
-	assert.Equal(t, "level1: level2: deepest error", result)
+	assert.Equal(t, `level1: level2: Error("deepest error")`, result)
 }
 
 func TestUnwrapErrorStringNestedCustomError(t *testing.T) {
@@ -1160,10 +1160,11 @@ func TestUnwrapErrorStringNestedCustomError(t *testing.T) {
 			"deadbeef00000000000000000000000000000000000000000000000000000000" +
 			"00000000")
 
-	// Without the custom ABI, the nested section can't be decoded
+	// Without the custom ABI, the nested section can't be decoded — the
+	// outer Error(string) is formatted directly (binary content included)
 	result, ok := ABI{}.UnwrapErrorString(revertData)
 	assert.True(t, ok)
-	assert.True(t, strings.HasPrefix(result, "0x"))
+	assert.True(t, strings.HasPrefix(result, `Error("[404]01d`))
 
 	// With the custom ABI, the nested error is decoded
 	result, ok = customABI.UnwrapErrorString(revertData)
@@ -1184,28 +1185,26 @@ func TestUnwrapErrorStringMalformedNestedABI(t *testing.T) {
 	badData := "prefix:" + string(sel) + "truncated"
 	outerABI := buildErrorStringABI([]byte(badData))
 
+	// Malformed nested data can't be decoded, so the outer Error(string)
+	// is formatted directly with the raw string content
 	result, ok := ABI{}.UnwrapErrorString(outerABI)
 	assert.True(t, ok)
-	assert.Equal(t, "prefix:0x08c379a07472756e6361746564", result)
+	assert.True(t, strings.HasPrefix(result, "Error("))
 }
 
 func TestUnwrapErrorStringDepthLimit(t *testing.T) {
-	innerABI := buildErrorStringABI([]byte("should not decode"))
-	s := "prefix:" + string(innerABI)
-	outerABI := buildErrorStringABI([]byte(s))
-
-	// Passes through processRevertReason, then into unwrap at depth 0.
-	// We can't easily test depth=10 through the public API without 10 levels of nesting,
-	// so test the internal function directly.
-	result := unwrapNestedRevertReasons(nil, ABI{}, s, maxNestedRevertDepth)
-	assert.True(t, strings.HasPrefix(result, "0x"))
-	assert.NotEqual(t, "prefix:should not decode", result)
+	// Build a chain deeper than maxRevertErrorDepth (10)
+	data := []byte("leaf")
+	for i := 0; i < maxRevertErrorDepth+2; i++ {
+		data = buildErrorStringABI(append([]byte("L:"), data...))
+	}
 
-	// At depth max-1, it still decodes
-	result = unwrapNestedRevertReasons(nil, ABI{}, s, maxNestedRevertDepth-1)
-	assert.Equal(t, "prefix:should not decode", result)
+	result, ok := ABI{}.UnwrapErrorString(data)
+	assert.True(t, ok)
 
-	_ = outerABI // suppress unused
+	// The chain should be capped — the leaf should not be fully unwrapped
+	// through all levels, so the result won't contain a cleanly decoded "leaf"
+	assert.NotEmpty(t, result)
 }
 
 func TestUnwrapErrorStringCustomBeforeDefaultError(t *testing.T) {