// Copyright 2014 The go-ethereum Authors // This file is part of the go-ethereum library. // // The go-ethereum library is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // The go-ethereum library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. // Package common contains various helper functions. package common import ( "encoding/hex" "errors" "github.com/ethereum/go-ethereum/common/hexutil" ) // FromHex returns the bytes represented by the hexadecimal string s. // s may be prefixed with "0x". func FromHex(s string) []byte { if has0xPrefix(s) { s = s[2:] } if len(s)%2 == 1 { s = "0" + s } return Hex2Bytes(s) } // CopyBytes returns an exact copy of the provided bytes. func CopyBytes(b []byte) (copiedBytes []byte) { if b == nil { return nil } copiedBytes = make([]byte, len(b)) copy(copiedBytes, b) return } // has0xPrefix validates str begins with '0x' or '0X'. func has0xPrefix(str string) bool { return len(str) >= 2 && str[0] == '0' && (str[1] == 'x' || str[1] == 'X') } // isHexCharacter returns bool of c being a valid hexadecimal. func isHexCharacter(c byte) bool { return ('0' <= c && c <= '9') || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F') } // isHex validates whether each byte is valid hexadecimal string. func isHex(str string) bool { if len(str)%2 != 0 { return false } for _, c := range []byte(str) { if !isHexCharacter(c) { return false } } return true } // Bytes2Hex returns the hexadecimal encoding of d. func Bytes2Hex(d []byte) string { return hex.EncodeToString(d) } // Hex2Bytes returns the bytes represented by the hexadecimal string str. func Hex2Bytes(str string) []byte { h, _ := hex.DecodeString(str) return h } // Hex2BytesFixed returns bytes of a specified fixed length flen. func Hex2BytesFixed(str string, flen int) []byte { h, _ := hex.DecodeString(str) if len(h) == flen { return h } if len(h) > flen { return h[len(h)-flen:] } hh := make([]byte, flen) copy(hh[flen-len(h):flen], h) return hh } // ParseHexOrString tries to hexdecode b, but if the prefix is missing, it instead just returns the raw bytes func ParseHexOrString(str string) ([]byte, error) { b, err := hexutil.Decode(str) if errors.Is(err, hexutil.ErrMissingPrefix) { return []byte(str), nil } return b, err } // RightPadBytes zero-pads slice to the right up to length l. func RightPadBytes(slice []byte, l int) []byte { if l <= len(slice) { return slice } padded := make([]byte, l) copy(padded, slice) return padded } // LeftPadBytes zero-pads slice to the left up to length l. func LeftPadBytes(slice []byte, l int) []byte { if l <= len(slice) { return slice } padded := make([]byte, l) copy(padded[l-len(slice):], slice) return padded } // TrimLeftZeroes returns a subslice of s without leading zeroes func TrimLeftZeroes(s []byte) []byte { idx := 0 for ; idx < len(s); idx++ { if s[idx] != 0 { break } } return s[idx:] } // TrimRightZeroes returns a subslice of s without trailing zeroes func TrimRightZeroes(s []byte) []byte { idx := len(s) for ; idx > 0; idx-- { if s[idx-1] != 0 { break } } return s[:idx] }