synapsecns/sanguine

package main

import (
    "flag"
    "fmt"
    "os"
    "path/filepath"
    "regexp"
    "strings"

    "github.com/ethereum/go-ethereum/crypto"
)

func extractRevertStrings(line string) []string {
    re := regexp.MustCompile(`\brevert\s+([\w\d_]+)\s*\(\s*\)`)
    matches := re.FindAllStringSubmatch(line, -1)
    var result []string
    for _, match := range matches {
        result = append(result, match[1])
    }
    return result
}

func keccak256Hash(input string) string {
    hash := crypto.Keccak256Hash([]byte(input + "()"))
    return hash.Hex()
}

func processFile(file string, filter string) {
    //nolint: gosec
    content, err := os.ReadFile(file)
    if err != nil {
        fmt.Printf("Error reading file %s: %s\n", file, err)
        return
    }

    lines := strings.Split(string(content), "\n")
    for i, line := range lines {
        revertStrings := extractRevertStrings(line)
        for _, revertString := range revertStrings {
            hashedString := keccak256Hash(revertString)
            if filter == "" || strings.HasPrefix(hashedString, filter) {
                fmt.Printf("%s(): %s (File: %s, Line: %d)\n", revertString, hashedString, file, i+1)
            }
        }
    }
}

func findAndPrintReverts(path, filter string) {
    err := filepath.Walk(path, func(filePath string, info os.FileInfo, err error) error {
        if err != nil {
            return err
        }

        if !info.IsDir() && filepath.Ext(filePath) == ".sol" {
            processFile(filePath, filter)
        }

        return nil
    })

    if err != nil {
        fmt.Println("Error walking the path:", err)
    }
}

func main() {
    var path string
    var filter string
    flag.StringVar(&path, "p", "", "path to search recursively")
    flag.StringVar(&filter, "f", "", "revert hash filter [optional]")
    flag.Parse()
    if len(path) == 0 {
        panic("expected path to be set (use -p flag)")
    }

    findAndPrintReverts(path, filter)
}