tron address

pkg/address/address.go

@@ -0,0 +1,127 @@
+package address
+
+import (
+	"crypto/ecdsa"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/mr-tron/base58"
+	"strings"
+)
+
+type Address [21]byte
+
+func (a *Address) UnmarshalJSON(bytes []byte) error {
+	s := ""
+
+	if err := json.Unmarshal(bytes, &s); err != nil {
+		return fmt.Errorf("unmarshal string: %w", err)
+	}
+
+	addr, err := NewFromBase58(s)
+	if err != nil {
+		return fmt.Errorf("parse address: %w", err)
+	}
+
+	*a = addr
+	return nil
+}
+
+func (a Address) String() string {
+	return a.Base58()
+}
+
+func (a Address) Bytes() []byte {
+	return a[:]
+}
+
+func (a Address) Hex() string {
+	return hex.EncodeToString(a[:])
+}
+
+func (a Address) Base58() string {
+	var tmp []byte
+	tmp = append(tmp, a[:]...)
+
+	hash := SHA256(SHA256(tmp))
+	checksum := hash[:4]
+	tmp = append(tmp, checksum...)
+
+	return base58.Encode(tmp)
+}
+
+func (a Address) ETH() common.Address {
+	return common.BytesToAddress(a[1:])
+}
+
+func NewFromETH(eth common.Address) Address {
+	return Address(append([]byte{65}, eth.Bytes()...))
+}
+
+func NewFromBytes(b []byte) (Address, error) {
+	if len(b) != 21 {
+		return Address{}, fmt.Errorf("tron address is not 21 bytes but %d", len(b))
+	}
+	return *(*[21]byte)(b), nil
+}
+
+func NewFromHex(s string) (Address, error) {
+	addrBytes, err := hex.DecodeString(s)
+	if err != nil {
+		return Address{}, err
+	}
+	return *(*[21]byte)(addrBytes), nil
+}
+
+func NewFromBase58(s string) (Address, error) {
+	bytes, err := base58.Decode(s)
+	if err != nil {
+		return Address{}, err
+	}
+
+	if len(bytes) != 25 {
+		return Address{}, fmt.Errorf("tron address is not 25 bytes but %d", len(bytes))
+	}
+
+	return *(*[21]byte)(bytes[:21]), nil
+}
+
+func NewFromString(s string) (Address, error) {
+	if strings.HasPrefix(s, "T") {
+		return NewFromBase58(s)
+	}
+	if strings.HasPrefix(s, "41") {
+		return NewFromHex(s)
+	}
+	return [21]byte{}, fmt.Errorf("%s is not a Tron address", s)
+}
+
+func NewFromKey(k *ecdsa.PrivateKey) Address {
+	return NewFromETH(crypto.PubkeyToAddress(k.PublicKey))
+}
+
+func NewFromKeyBytes(k []byte) (Address, error) {
+	key, err := crypto.ToECDSA(k)
+	if err != nil {
+		return Address{}, err
+	}
+	return NewFromKey(key), nil
+}
+
+func NewFromKeyHex(k string) (Address, error) {
+	keyBytes, err := hex.DecodeString(k)
+	if err != nil {
+		return Address{}, err
+	}
+	return NewFromKeyBytes(keyBytes)
+}
+
+func SHA256(s []byte) []byte {
+	h := sha256.New()
+	h.Write(s)
+	bs := h.Sum(nil)
+	return bs
+}