errors.go

package multicall

import (
	"encoding/binary"
	"errors"
	"fmt"

	"github.com/ethereum/go-ethereum/accounts/abi"
)

// Standard error selectors as hex constants for readability
const (
	// Error(string) selector
	errorSelector = 0x08c379a0
	// Panic(uint256) selector
	panicSelector = 0x4e487b71
)

var (
	// ErrResultMissing result count does not match call count
	ErrResultMissing = errors.New("multicall: result missing from response")
)

// CallFailedError error for individual call failure, includes revert reason (if any)
type CallFailedError struct {
	Reason string // Decoded revert reason
	Data   []byte // Raw return data
}

func (e *CallFailedError) Error() string {
	if e.Reason != "" {
		return fmt.Sprintf("multicall: call failed: %s", e.Reason)
	}
	return "multicall: call failed"
}

// newCallFailedError creates CallFailedError, attempts to decode revert reason
func newCallFailedError(data []byte) *CallFailedError {
	reason := decodeRevertReason(data)
	return &CallFailedError{
		Reason: reason,
		Data:   data,
	}
}

// decodeRevertReason decodes revert reason from error return data
// Supports both Error(string) and Panic(uint256) standard formats
func decodeRevertReason(data []byte) string {
	if len(data) < 4 {
		return ""
	}

	selector := binary.BigEndian.Uint32(data[:4])

	switch selector {
	case errorSelector:
		return decodeErrorString(data[4:])
	case panicSelector:
		return decodePanicCode(data[4:])
	default:
		if len(data) == 4 {
			return fmt.Sprintf("custom error: 0x%08x", selector)
		}
		return fmt.Sprintf("custom error: 0x%08x (with data)", selector)
	}
}

// decodeErrorString decodes Error(string) revert data
func decodeErrorString(data []byte) string {
	stringType, _ := abi.NewType("string", "string", nil)
	args := abi.Arguments{{Type: stringType}}
	decoded, err := args.Unpack(data)
	if err != nil || len(decoded) == 0 {
		return ""
	}
	if reason, ok := decoded[0].(string); ok {
		return reason
	}
	return ""
}

// decodePanicCode decodes Panic(uint256) revert data
func decodePanicCode(data []byte) string {
	uintType, _ := abi.NewType("uint256", "uint256", nil)
	args := abi.Arguments{{Type: uintType}}
	decoded, err := args.Unpack(data)
	if err != nil || len(decoded) == 0 {
		return "panic: unknown"
	}
	return fmt.Sprintf("panic code: %d", decoded[0])
}

// IsCallFailed checks if error is an individual call failure
func IsCallFailed(err error) bool {
	var callErr *CallFailedError
	return errors.As(err, &callErr)
}

// RevertReason extracts revert reason from error, returns empty string if not CallFailedError
func RevertReason(err error) string {
	var callErr *CallFailedError
	if errors.As(err, &callErr) {
		return callErr.Reason
	}
	return ""
}