github.com/daragao/go-ethereum@v1.8.14-0.20180809141559-45eaef243198/common/bytes.go (about)

     1  // Copyright 2014 The go-ethereum Authors
     2  // This file is part of the go-ethereum library.
     3  //
     4  // The go-ethereum library is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Lesser General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // The go-ethereum library is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU Lesser General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Lesser General Public License
    15  // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  // Package common contains various helper functions.
    18  package common
    19  
    20  import "encoding/hex"
    21  
    22  // ToHex returns the hex representation of b, prefixed with '0x'.
    23  // For empty slices, the return value is "0x0".
    24  //
    25  // Deprecated: use hexutil.Encode instead.
    26  func ToHex(b []byte) string {
    27  	hex := Bytes2Hex(b)
    28  	if len(hex) == 0 {
    29  		hex = "0"
    30  	}
    31  	return "0x" + hex
    32  }
    33  
    34  // FromHex returns the bytes represented by the hexadecimal string s.
    35  // s may be prefixed with "0x".
    36  func FromHex(s string) []byte {
    37  	if len(s) > 1 {
    38  		if s[0:2] == "0x" || s[0:2] == "0X" {
    39  			s = s[2:]
    40  		}
    41  	}
    42  	if len(s)%2 == 1 {
    43  		s = "0" + s
    44  	}
    45  	return Hex2Bytes(s)
    46  }
    47  
    48  // CopyBytes returns an exact copy of the provided bytes.
    49  func CopyBytes(b []byte) (copiedBytes []byte) {
    50  	if b == nil {
    51  		return nil
    52  	}
    53  	copiedBytes = make([]byte, len(b))
    54  	copy(copiedBytes, b)
    55  
    56  	return
    57  }
    58  
    59  // hasHexPrefix validates str begins with '0x' or '0X'.
    60  func hasHexPrefix(str string) bool {
    61  	return len(str) >= 2 && str[0] == '0' && (str[1] == 'x' || str[1] == 'X')
    62  }
    63  
    64  // isHexCharacter returns bool of c being a valid hexadecimal.
    65  func isHexCharacter(c byte) bool {
    66  	return ('0' <= c && c <= '9') || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')
    67  }
    68  
    69  // isHex validates whether each byte is valid hexadecimal string.
    70  func isHex(str string) bool {
    71  	if len(str)%2 != 0 {
    72  		return false
    73  	}
    74  	for _, c := range []byte(str) {
    75  		if !isHexCharacter(c) {
    76  			return false
    77  		}
    78  	}
    79  	return true
    80  }
    81  
    82  // Bytes2Hex returns the hexadecimal encoding of d.
    83  func Bytes2Hex(d []byte) string {
    84  	return hex.EncodeToString(d)
    85  }
    86  
    87  // Hex2Bytes returns the bytes represented by the hexadecimal string str.
    88  func Hex2Bytes(str string) []byte {
    89  	h, _ := hex.DecodeString(str)
    90  	return h
    91  }
    92  
    93  // Hex2BytesFixed returns bytes of a specified fixed length flen.
    94  func Hex2BytesFixed(str string, flen int) []byte {
    95  	h, _ := hex.DecodeString(str)
    96  	if len(h) == flen {
    97  		return h
    98  	}
    99  	if len(h) > flen {
   100  		return h[len(h)-flen:]
   101  	}
   102  	hh := make([]byte, flen)
   103  	copy(hh[flen-len(h):flen], h[:])
   104  	return hh
   105  }
   106  
   107  // RightPadBytes zero-pads slice to the right up to length l.
   108  func RightPadBytes(slice []byte, l int) []byte {
   109  	if l <= len(slice) {
   110  		return slice
   111  	}
   112  
   113  	padded := make([]byte, l)
   114  	copy(padded, slice)
   115  
   116  	return padded
   117  }
   118  
   119  // LeftPadBytes zero-pads slice to the left up to length l.
   120  func LeftPadBytes(slice []byte, l int) []byte {
   121  	if l <= len(slice) {
   122  		return slice
   123  	}
   124  
   125  	padded := make([]byte, l)
   126  	copy(padded[l-len(slice):], slice)
   127  
   128  	return padded
   129  }