-
Notifications
You must be signed in to change notification settings - Fork 4
/
hexcmd.go
123 lines (119 loc) · 3.29 KB
/
hexcmd.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
package main
import (
"tools/log"
"tools/util"
"errors"
"fmt"
"math/big"
"strconv"
"strings"
"github.com/btcsuite/btcutil/base58"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/math"
"github.com/urfave/cli/v2"
)
var (
hexAddrCommand = cli.Command{
Name: "addr",
Usage: "Convert addr between hex, TRON-addr and eth-addr",
Action: func(c *cli.Context) error {
if c.NArg() != 1 {
return errors.New("addr subcommand only needs one arg")
}
arg0 := c.Args().Get(0)
addr := new(common.Address)
if len(arg0) == 34 && arg0[0] == 'T' {
// TRON address in Base58
addrBytes, _, err := base58.CheckDecode(arg0)
if err != nil {
return err
}
addr.SetBytes(addrBytes)
} else if len(arg0) == 42 && strings.HasPrefix(arg0, "41") {
// TRON address in hexadecimal with 0x41 prefix
if addrBytes, ok := utils.FromHex(arg0[2:]); ok {
addr.SetBytes(addrBytes)
} else {
return errors.New("input is begin with 0x41, but can`t convert to hex")
}
} else if bigint, ok := math.ParseBig256(arg0); ok {
// input is in dec or hex
addr.SetBytes(bigint.Bytes())
} else {
return errors.New("input is not recognized, please append 0x prefix if in hex")
}
log.NewLog("eth addr", addr.String())
log.NewLog("tron addr", base58.CheckEncode(addr.Bytes(), 0x41))
return nil
},
}
hexIntCommand = cli.Command{
Name: "int",
Usage: "Convert num between dec and hex",
Action: func(c *cli.Context) error {
if c.NArg() != 1 {
return errors.New("int subcommand only needs num arg")
}
arg0 := c.Args().Get(0)
var bigint *big.Int
var ok bool
if len(arg0) >= 2 && (arg0[:2] == "0x" || arg0[:2] == "0X") {
bigint, ok = new(big.Int).SetString(arg0[2:], 16)
} else {
bigint, ok = new(big.Int).SetString(arg0, 10)
}
if ok {
log.NewLog("in hex", bigint.Bytes())
log.NewLog("in dec", fmt.Sprintf("%s (%d)", formatBigInt(bigint), len(bigint.String())))
return nil
} else {
return errors.New("only accept input in dec or hex")
}
},
}
hexMaxCommand = cli.Command{
Name: "max",
Usage: "Get max value for the type like uint-x",
Action: func(c *cli.Context) error {
if c.NArg() != 1 {
return errors.New("max subcommand only needs size arg")
}
arg0 := c.Args().Get(0)
size, err := strconv.Atoi(arg0)
if err != nil {
return err
}
if size <= 0 {
return errors.New("input uint size should be greater than 0")
}
maxValue := new(big.Int)
maxValue.Lsh(big.NewInt(1), uint(size))
maxValue.Sub(maxValue, big.NewInt(1))
log.NewLog("max hex", maxValue.Bytes())
log.NewLog("max dec", maxValue)
return nil
},
}
hexStrCommand = cli.Command{
Name: "str",
Usage: "convert str between ascii and hex",
Action: func(c *cli.Context) error {
if c.NArg() != 1 {
return errors.New("hex command only needs single arg")
}
arg0 := c.Args().Get(0)
// check if input is in hex
if argBytes, ok := utils.FromHex(arg0); ok {
// special case, first byte is `backspace`
if len(argBytes) > 0 && argBytes[0] == 0x08 {
argBytes = argBytes[1:]
}
log.NewLog("in ascii", utils.ToReadableASCII(argBytes))
} else {
// otherwise treat input as str
log.NewLog("in hex", []byte(arg0))
}
return nil
},
}
)