gebv · June 7, 2022 11:24 · 0fuz · Jun 7, 2022
diff --git a/README.md b/README.md
diff --git a/main.go b/main.go
 // You can edit this code!
 // Click here and start typing.
 package main

 import (
 	"crypto/ecdsa"
 	"crypto/sha256"
 	"encoding/hex"
 	"fmt"
 	"strings"

 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/mr-tron/base58"
 )

 func main() {
 	priv := newPrivKey()

 	showPrivDetails(priv)
 	fmt.Println()
 	showEthDetails(priv)
 	fmt.Println()
 	showTronDetails(priv)
 	fmt.Println()
 	fmt.Println()
 	fmt.Println("Restore from Private Key")
 	newPriv := privFromHex(privKeyHex(priv))

 	showPrivDetails(newPriv)
 	fmt.Println()
 	showEthDetails(newPriv)
 	fmt.Println()
 	showTronDetails(newPriv)
 	fmt.Println()
 }

 func showPrivDetails(priv *ecdsa.PrivateKey) {
 	fmt.Println("Private Key:", privKeyHex(priv))
 	fmt.Println("Public Key:", pubKeyHex(priv))
 }

 func showTronDetails(priv *ecdsa.PrivateKey) {
 	tron := &TronWallet{priv}
 	fmt.Println("Tron")
 	tronAddrHex, tronAddrb58 := tron.Addr()
 	fmt.Println("Addr Hex:", tronAddrHex)
 	fmt.Println("Addr Base58:", tronAddrb58)
 }
 func showEthDetails(priv *ecdsa.PrivateKey) {
 	eth := &EthWallet{priv}
 	fmt.Println("Ethereum")
 	fmt.Println("Addr:", eth.Addr())
 }

 type EthWallet struct {
 	priv *ecdsa.PrivateKey
 }

 // Addr returns the address in hex format
 func (w *EthWallet) Addr() string {
 	return w.addr().String()
 }

 func (w *EthWallet) addr() common.Address {
 	return crypto.PubkeyToAddress(w.priv.PublicKey)
 }

 func (w *EthWallet) addrN(n int) common.Address {
 	return crypto.CreateAddress(w.addr(), uint64(n))
 }

 func (w *EthWallet) AddrN(n int) string {
 	return w.addrN(n).String()
 }

 type TronWallet struct {
 	priv *ecdsa.PrivateKey
 }

 // Addr returns the address in hex (begins with 41) and base58 (begins with T) format
 func (w *TronWallet) Addr() (string, string) {
 	address := crypto.PubkeyToAddress(w.priv.PublicKey).Hex()
 	address = "41" + address[2:]

 	s256 := func(in []byte) []byte {
 		h := sha256.New()
 		h.Write(in)
 		b := h.Sum(nil)
 		return b
 	}

 	addb, _ := hex.DecodeString(address)
 	hash1 := s256(s256(addb))
 	secret := hash1[:4]
 	for _, v := range secret {
 		addb = append(addb, v)
 	}
 	return address, base58.Encode(addb)
 }

 func newPrivKey() *ecdsa.PrivateKey {
 	priv, err := crypto.GenerateKey()
 	if err != nil {
 		panic(err)
 	}
 	return priv
 }

 func pubKeyHex(priv *ecdsa.PrivateKey) string {
 	return "0x" + hex.EncodeToString(crypto.FromECDSAPub(&priv.PublicKey))
 }

 func privKeyHex(priv *ecdsa.PrivateKey) string {
 	return "0x" + hex.EncodeToString(crypto.FromECDSA(priv))
 }

 func privFromHex(in string) *ecdsa.PrivateKey {
 	h, err := hex.DecodeString(strings.TrimPrefix(in, "0x"))
 	if err != nil {
 		panic(err)
 		// BOOM
 	}

 	priv, err := crypto.ToECDSA(h)
 	if err != nil {
 		panic(err)
 		// BOOM
 	}
 	return priv
 }
	// You can edit this code!
	// Click here and start typing.
	package main

	import (
	"crypto/ecdsa"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"strings"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/mr-tron/base58"
	)

	func main() {
	priv := newPrivKey()

	showPrivDetails(priv)
	fmt.Println()
	showEthDetails(priv)
	fmt.Println()
	showTronDetails(priv)
	fmt.Println()
	fmt.Println()
	fmt.Println("Restore from Private Key")
	newPriv := privFromHex(privKeyHex(priv))

	showPrivDetails(newPriv)
	fmt.Println()
	showEthDetails(newPriv)
	fmt.Println()
	showTronDetails(newPriv)
	fmt.Println()
	}

	func showPrivDetails(priv *ecdsa.PrivateKey) {
	fmt.Println("Private Key:", privKeyHex(priv))
	fmt.Println("Public Key:", pubKeyHex(priv))
	}

	func showTronDetails(priv *ecdsa.PrivateKey) {
	tron := &TronWallet{priv}
	fmt.Println("Tron")
	tronAddrHex, tronAddrb58 := tron.Addr()
	fmt.Println("Addr Hex:", tronAddrHex)
	fmt.Println("Addr Base58:", tronAddrb58)
	}
	func showEthDetails(priv *ecdsa.PrivateKey) {
	eth := &EthWallet{priv}
	fmt.Println("Ethereum")
	fmt.Println("Addr:", eth.Addr())
	}

	type EthWallet struct {
	priv *ecdsa.PrivateKey
	}

	// Addr returns the address in hex format
	func (w *EthWallet) Addr() string {
	return w.addr().String()
	}

	func (w *EthWallet) addr() common.Address {
	return crypto.PubkeyToAddress(w.priv.PublicKey)
	}

	func (w *EthWallet) addrN(n int) common.Address {
	return crypto.CreateAddress(w.addr(), uint64(n))
	}

	func (w *EthWallet) AddrN(n int) string {
	return w.addrN(n).String()
	}

	type TronWallet struct {
	priv *ecdsa.PrivateKey
	}

	// Addr returns the address in hex (begins with 41) and base58 (begins with T) format
	func (w *TronWallet) Addr() (string, string) {
	address := crypto.PubkeyToAddress(w.priv.PublicKey).Hex()
	address = "41" + address[2:]

	s256 := func(in []byte) []byte {
	h := sha256.New()
	h.Write(in)
	b := h.Sum(nil)
	return b
	}

	addb, _ := hex.DecodeString(address)
	hash1 := s256(s256(addb))
	secret := hash1[:4]
	for _, v := range secret {
	addb = append(addb, v)
	}
	return address, base58.Encode(addb)
	}

	func newPrivKey() *ecdsa.PrivateKey {
	priv, err := crypto.GenerateKey()
	if err != nil {
	panic(err)
	}
	return priv
	}

	func pubKeyHex(priv *ecdsa.PrivateKey) string {
	return "0x" + hex.EncodeToString(crypto.FromECDSAPub(&priv.PublicKey))
	}

	func privKeyHex(priv *ecdsa.PrivateKey) string {
	return "0x" + hex.EncodeToString(crypto.FromECDSA(priv))
	}

	func privFromHex(in string) *ecdsa.PrivateKey {
	h, err := hex.DecodeString(strings.TrimPrefix(in, "0x"))
	if err != nil {
	panic(err)
	// BOOM
	}

	priv, err := crypto.ToECDSA(h)
	if err != nil {
	panic(err)
	// BOOM
	}
	return priv
	}