status-im/status-go

package abispec

import (
    "fmt"
    "math/big"
    "regexp"
    "strings"
    "unicode"

    "github.com/ethereum/go-ethereum/common"
    "github.com/status-im/status-go/eth-node/crypto"
)

var unicodeZeroPattern = regexp.MustCompile("^(?:\u0000)*")
var hexZeroPattern = regexp.MustCompile("^(?:00)*")
var hexStringPattern = regexp.MustCompile("(?i)^[0-9a-f]+$")
var hexPrefixPattern = regexp.MustCompile("(?i)^0x")

var addressBasicPattern = regexp.MustCompile("(?i)^(0x)?[0-9a-f]{40}$")
var addressLowerCasePattern = regexp.MustCompile("^(0x|0X)?[0-9a-f]{40}$")
var addressUpperCasePattern = regexp.MustCompile("^(0x|0X)?[0-9A-F]{40}$")

func HexToNumber(hex string) string {
    num, success := big.NewInt(0).SetString(hex, 16)
    if success {
        return num.String()
    }
    return ""
}

func NumberToHex(numString string) string {
    num, success := big.NewInt(0).SetString(numString, 0)
    if success {
        return fmt.Sprintf("%x", num)
    }
    return ""
}

func Sha3(str string) string {
    bytes := crypto.Keccak256([]byte(str))
    return common.Bytes2Hex(bytes)
}

func reverse(str string) string {
    bytes := []byte(str)
    var out []byte
    for i := len(bytes) - 1; i >= 0; i-- {
        out = append(out, bytes[i])
    }
    return string(out)
}

// remove \u0000 padding from either side
func removeUnicodeZeroPadding(str string) string {
    found := unicodeZeroPattern.FindString(str)
    str = strings.Replace(str, found, "", 1)
    str = reverse(str)
    found = unicodeZeroPattern.FindString(str)
    str = strings.Replace(str, found, "", 1)
    return reverse(str)
}

// remove 00 padding from either side
func removeHexZeroPadding(str string) string {
    found := hexZeroPattern.FindString(str)
    str = strings.Replace(str, found, "", 1)
    str = reverse(str)
    found = hexZeroPattern.FindString(str)
    str = strings.Replace(str, found, "", 1)
    return reverse(str)
}

// implementation referenced from https://github.com/ChainSafe/web3.js/blob/edcd215bf657a4bba62fabaafd08e6e70040976e/packages/web3-utils/src/utils.js#L165
func Utf8ToHex(str string) (string, error) {
    str, err := Utf8encode(str)
    if err != nil {
        return "", err
    }
    str = removeUnicodeZeroPadding(str)

    var hex = ""
    for _, r := range str {
        n := fmt.Sprintf("%x", r)
        if len(n) < 2 {
            hex += "0" + n
        } else {
            hex += n
        }
    }
    return "0x" + hex, nil
}

// implementation referenced from https://github.com/ChainSafe/web3.js/blob/edcd215bf657a4bba62fabaafd08e6e70040976e/packages/web3-utils/src/utils.js#L193
func HexToUtf8(hexString string) (string, error) {
    hexString = removeHexPrefix(hexString)
    if !hexStringPattern.MatchString(hexString) {
        return "", fmt.Errorf("the parameter '%s' must be a valid HEX string", hexString)
    }
    if len(hexString)%2 != 0 {
        return "", fmt.Errorf("the parameter '%s' must have a even number of digits", hexString)
    }

    hexString = removeHexZeroPadding(hexString)

    n := big.NewInt(0)
    var bytes []byte
    for i := 0; i < len(hexString); i += 2 {
        hex := hexString[i : i+2]
        n, success := n.SetString(hex, 16)
        if !success {
            return "", fmt.Errorf("invalid hex value %s", hex)
        }
        r := rune(n.Int64())
        bs := stringFromCharCode(r)
        bytes = appendBytes(bytes, bs)
    }

    bytes, err := Utf8decode(string(bytes))
    if err != nil {
        return "", err
    }
    return string(bytes), nil
}

func removeHexPrefix(str string) string {
    found := hexPrefixPattern.FindString(str)
    return strings.Replace(str, found, "", 1)
}

// implementation referenced from https://github.com/ChainSafe/web3.js/blob/edcd215bf657a4bba62fabaafd08e6e70040976e/packages/web3-utils/src/utils.js#L107
func CheckAddressChecksum(address string) (bool, error) {
    address = removeHexPrefix(address)
    addressHash := Sha3(strings.ToLower(address))

    n := big.NewInt(0)
    for i := 0; i < 40; i++ {
        // the nth letter should be uppercase if the nth digit of casemap is 1
        n, success := n.SetString(addressHash[i:i+1], 16)
        if !success {
            return false, fmt.Errorf("failed to convert hex value '%s' to int", addressHash[i:i+1])
        }
        v := n.Int64()

        if (v > 7 && uint8(unicode.ToUpper(rune(address[i]))) != address[i]) || (v <= 7 && uint8(unicode.ToLower(rune(address[i]))) != address[i]) {
            return false, nil
        }
    }
    return true, nil
}

// implementation referenced from https://github.com/ChainSafe/web3.js/blob/edcd215bf657a4bba62fabaafd08e6e70040976e/packages/web3-utils/src/utils.js#L85
func IsAddress(address string) (bool, error) {
    // check if it has the basic requirements of an address
    if !addressBasicPattern.MatchString(address) {
        return false, nil
    } else if addressLowerCasePattern.MatchString(address) || addressUpperCasePattern.MatchString(address) {
        return true, nil
    } else {
        return CheckAddressChecksum(address)
    }
}

// implementation referenced from https://github.com/ChainSafe/web3.js/blob/2022b17d52d31ce95559d18d5530d18c83eb4d1c/packages/web3-utils/src/index.js#L283
func ToChecksumAddress(address string) (string, error) {
    if strings.Trim(address, "") == "" {
        return "", nil
    }
    if !addressBasicPattern.MatchString(address) {
        return "", fmt.Errorf("given address '%s' is not a valid Ethereum address", address)
    }

    address = strings.ToLower(address)
    address = removeHexPrefix(address)
    addressHash := Sha3(address)

    var checksumAddress = []rune("0x")
    var n = big.NewInt(0)
    for i := 0; i < len(address); i++ {
        // If ith character is 9 to f then make it uppercase
        n, success := n.SetString(addressHash[i:i+1], 16)
        if !success {
            return "", fmt.Errorf("failed to convert hex value '%s' to int", addressHash[i:i+1])
        }
        if n.Int64() > 7 {
            upper := unicode.ToUpper(rune(address[i]))
            checksumAddress = append(checksumAddress, upper)
        } else {
            checksumAddress = append(checksumAddress, rune(address[i]))
        }
    }
    return string(checksumAddress), nil
}