Example #1
0
func getStringValue(value interface{}, output Argument) (string, error) {
	typ := output.Type

	if typ.IsSlice || typ.IsArray {
		if typ.T == BytesTy || typ.T == FixedBytesTy {
			return string(bytes.Trim(value.([]byte), "\x00")[:]), nil
		}
		var val []string
		if typ.Elem.T == FixedBytesTy {
			byteVals := reflect.ValueOf(value)
			for i := 0; i < byteVals.Len(); i++ {
				val = append(val, string(bytes.Trim(byteVals.Index(i).Interface().([]byte), "\x00")[:]))
			}

		} else {
			val = strings.Split(fmt.Sprintf("%v", value), " ")
		}
		StringVal := strings.Join(val, ",")

		if typ.Elem.T == FixedBytesTy {
			StringVal = strings.Join([]string{"[", StringVal, "]"}, "")
		}
		return StringVal, nil
	} else {
		switch typ.T {
		case IntTy:
			switch typ.Size {
			case 8, 16, 32, 64:
				return fmt.Sprintf("%v", value), nil
			default:
				return common.S256(value.(*big.Int)).String(), nil
			}
		case UintTy:
			switch typ.Size {
			case 8, 16, 32, 64:
				return fmt.Sprintf("%v", value), nil
			default:
				return common.U256(value.(*big.Int)).String(), nil
			}
		case BoolTy:
			return strconv.FormatBool(value.(bool)), nil
		case StringTy:
			return value.(string), nil
		case AddressTy:
			return strings.ToUpper(Bytes2Hex(value.(Address).Bytes())), nil
		default:
			return "", fmt.Errorf("Could not unpack value %v", value)
		}
	}
}
Example #2
0
// U256 converts a big Int into a 256bit EVM number.
func U256(n *big.Int) []byte {
	return common.LeftPadBytes(common.U256(n).Bytes(), 32)
}