wallets

wallet/util.go

@@ -0,0 +1,22 @@
+package wallet
+
+import (
+	"log"
+
+	"github.com/mr-tron/base58"
+)
+
+func Base58Encode(input []byte) []byte {
+	encode := base58.Encode(input)
+
+	return []byte(encode)
+}
+
+func Base58Decode(input []byte) []byte {
+	decode, err := base58.Decode(string(input[:]))
+	if err != nil {
+		log.Panic(err)
+	}
+
+	return decode
+}

wallet/wallet.go

@@ -0,0 +1,71 @@
+package wallet
+
+import (
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+	"crypto/sha256"
+	"log"
+)
+
+const (
+	checksumLength = 4
+	version        = byte(0x00)
+)
+
+type Wallet struct {
+	PrivateKey ecdsa.PrivateKey
+	PublicKey  []byte
+}
+
+func (w Wallet) Address() []byte {
+	pubHash := PublicKeyHash(w.PublicKey)
+
+	versionedHash := append([]byte{version}, pubHash...)
+	checksum := CheckSum(versionedHash)
+
+	fullHash := append(versionedHash, checksum...)
+	address := Base58Encode(fullHash)
+
+	return address
+}
+
+func NewKeyPair() (ecdsa.PrivateKey, []byte) {
+	curve := elliptic.P256()
+
+	private, err := ecdsa.GenerateKey(curve, rand.Reader)
+	if err != nil {
+		log.Panic(err)
+	}
+
+	pub := append(private.PublicKey.X.Bytes(), private.PublicKey.Y.Bytes()...)
+	return *private, pub
+}
+
+func MakeWallet() *Wallet {
+	private, public := NewKeyPair()
+	wallet := Wallet{private, public}
+
+	return &wallet
+}
+
+func PublicKeyHash(pubKey []byte) []byte {
+	pubHash := sha256.Sum256(pubKey)
+
+	hasher := sha256.New()
+	_, err := hasher.Write(pubHash[:])
+	if err != nil {
+		log.Panic(err)
+	}
+
+	publicRipMD := hasher.Sum(nil)
+
+	return publicRipMD
+}
+
+func CheckSum(payload []byte) []byte {
+	firstHash := sha256.Sum256(payload)
+	secondHash := sha256.Sum256(firstHash[:])
+
+	return secondHash[:checksumLength]
+}

wallet/wallets.go

@@ -0,0 +1,88 @@
+package wallet
+
+import (
+	"bytes"
+	"crypto/elliptic"
+	"encoding/gob"
+	"log"
+	"os"
+)
+
+const walletFile = "./tmp/wallets.data"
+
+type Wallets struct {
+	Wallets map[string]*Wallet
+}
+
+func CreateWallets() (*Wallets, error) {
+	wallets := Wallets{}
+	wallets.Wallets = make(map[string]*Wallet)
+
+	err := wallets.LoadFile()
+
+	return &wallets, err
+}
+
+func (ws *Wallets) AddWallet() string {
+	wallet := MakeWallet()
+	address := string(wallet.Address())
+
+	ws.Wallets[address] = wallet
+
+	return address
+}
+
+func (ws *Wallets) GetAllAddresses() []string {
+	var addresses []string
+
+	for address := range ws.Wallets {
+		addresses = append(addresses, address)
+	}
+
+	return addresses
+}
+
+func (ws Wallets) GetWallet(address string) Wallet {
+	return *ws.Wallets[address]
+}
+
+func (ws *Wallets) LoadFile() error {
+	if _, err := os.Stat(walletFile); os.IsNotExist(err) {
+		return err
+	}
+
+	var wallets Wallets
+
+	fileContent, err := os.ReadFile(walletFile)
+	if err != nil {
+		return err
+	}
+
+	gob.Register(elliptic.P256())
+	decoder := gob.NewDecoder(bytes.NewReader(fileContent))
+	err = decoder.Decode(&wallets)
+	if err != nil {
+		return err
+	}
+
+	ws.Wallets = wallets.Wallets
+
+	return nil
+}
+
+func (ws *Wallets) SaveFile() {
+	var content bytes.Buffer
+
+	gob.Register(elliptic.P256())
+
+	encoder := gob.NewEncoder(&content)
+	err := encoder.Encode(ws)
+	if err != nil {
+		log.Panic(err)
+	}
+
+	err = os.WriteFile(walletFile, content.Bytes(), 0644)
+	if err != nil {
+		log.Panic(err)
+	}
+}