github.com/karalabe/go-ethereum@v0.8.5/accounts/abi/numbers.go (about)

     1  package abi
     2  
     3  import (
     4  	"math/big"
     5  	"reflect"
     6  
     7  	"github.com/ethereum/go-ethereum/ethutil"
     8  )
     9  
    10  var big_t = reflect.TypeOf(&big.Int{})
    11  var ubig_t = reflect.TypeOf(&big.Int{})
    12  var byte_t = reflect.TypeOf(byte(0))
    13  var byte_ts = reflect.TypeOf([]byte(nil))
    14  var uint_t = reflect.TypeOf(uint(0))
    15  var uint8_t = reflect.TypeOf(uint8(0))
    16  var uint16_t = reflect.TypeOf(uint16(0))
    17  var uint32_t = reflect.TypeOf(uint32(0))
    18  var uint64_t = reflect.TypeOf(uint64(0))
    19  var int_t = reflect.TypeOf(int(0))
    20  var int8_t = reflect.TypeOf(int8(0))
    21  var int16_t = reflect.TypeOf(int16(0))
    22  var int32_t = reflect.TypeOf(int32(0))
    23  var int64_t = reflect.TypeOf(int64(0))
    24  
    25  var uint_ts = reflect.TypeOf([]uint(nil))
    26  var uint8_ts = reflect.TypeOf([]uint8(nil))
    27  var uint16_ts = reflect.TypeOf([]uint16(nil))
    28  var uint32_ts = reflect.TypeOf([]uint32(nil))
    29  var uint64_ts = reflect.TypeOf([]uint64(nil))
    30  var ubig_ts = reflect.TypeOf([]*big.Int(nil))
    31  
    32  var int_ts = reflect.TypeOf([]int(nil))
    33  var int8_ts = reflect.TypeOf([]int8(nil))
    34  var int16_ts = reflect.TypeOf([]int16(nil))
    35  var int32_ts = reflect.TypeOf([]int32(nil))
    36  var int64_ts = reflect.TypeOf([]int64(nil))
    37  var big_ts = reflect.TypeOf([]*big.Int(nil))
    38  
    39  // U256 will ensure unsigned 256bit on big nums
    40  func U256(n *big.Int) []byte {
    41  	return ethutil.LeftPadBytes(ethutil.U256(n).Bytes(), 32)
    42  }
    43  
    44  func S256(n *big.Int) []byte {
    45  	sint := ethutil.S256(n)
    46  	ret := ethutil.LeftPadBytes(sint.Bytes(), 32)
    47  	if sint.Cmp(ethutil.Big0) < 0 {
    48  		for i, b := range ret {
    49  			if b == 0 {
    50  				ret[i] = 1
    51  				continue
    52  			}
    53  			break
    54  		}
    55  	}
    56  
    57  	return ret
    58  }
    59  
    60  // S256 will ensure signed 256bit on big nums
    61  func U2U256(n uint64) []byte {
    62  	return U256(big.NewInt(int64(n)))
    63  }
    64  
    65  func S2S256(n int64) []byte {
    66  	return S256(big.NewInt(n))
    67  }
    68  
    69  // packNum packs the given number (using the reflect value) and will cast it to appropriate number representation
    70  func packNum(value reflect.Value, to byte) []byte {
    71  	switch kind := value.Kind(); kind {
    72  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
    73  		if to == UintTy {
    74  			return U2U256(value.Uint())
    75  		} else {
    76  			return S2S256(int64(value.Uint()))
    77  		}
    78  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
    79  		if to == UintTy {
    80  			return U2U256(uint64(value.Int()))
    81  		} else {
    82  			return S2S256(value.Int())
    83  		}
    84  	case reflect.Ptr:
    85  		// This only takes care of packing and casting. No type checking is done here. It should be done prior to using this function.
    86  		if to == UintTy {
    87  			return U256(value.Interface().(*big.Int))
    88  		} else {
    89  			return S256(value.Interface().(*big.Int))
    90  		}
    91  
    92  	}
    93  
    94  	return nil
    95  }
    96  
    97  // checks whether the given reflect value is signed. This also works for slices with a number type
    98  func isSigned(v reflect.Value) bool {
    99  	switch v.Type() {
   100  	case ubig_ts, big_ts, big_t, ubig_t:
   101  		return true
   102  	case int_ts, int8_ts, int16_ts, int32_ts, int64_ts, int_t, int8_t, int16_t, int32_t, int64_t:
   103  		return true
   104  	}
   105  	return false
   106  }