transaction post

Author: BChainbuddy

block/blockchain.go

@@ -1,9 +1,11 @@
 package block
 
 import (
+	"crypto/ecdsa"
 	"crypto/sha256"
 	"encoding/json"
 	"fmt"
+	"goBlockchain/utils"
 	"log"
 	"strings"
 	"time"
@@ -18,14 +20,23 @@ const (
 type Block struct {
 	timestamp    int64
 	nonce        int
-	prevHash     [32]byte
+	previousHash [32]byte
 	transactions []*Transaction
 }
 
+func NewBlock(nonce int, previousHash [32]byte, transactions []*Transaction) *Block {
+	b := new(Block)
+	b.timestamp = time.Now().UnixNano()
+	b.nonce = nonce
+	b.previousHash = previousHash
+	b.transactions = transactions
+	return b
+}
+
 func (b *Block) Print() {
-	fmt.Printf("Timestamp         %d\n", b.timestamp)
-	fmt.Printf("Nonce             %d\n", b.nonce)
-	fmt.Printf("Previous_hash     %x\n", b.prevHash)
+	fmt.Printf("timestamp       %d\n", b.timestamp)
+	fmt.Printf("nonce           %d\n", b.nonce)
+	fmt.Printf("previous_hash   %x\n", b.previousHash)
 	for _, t := range b.transactions {
 		t.Print()
 	}
@@ -38,69 +49,101 @@ func (b *Block) Hash() [32]byte {
 
 func (b *Block) MarshalJSON() ([]byte, error) {
 	return json.Marshal(struct {
-		Nonce        int            `json:"nonce"`
-		PrevHash     [32]byte       `json:"prevHash"`
 		Timestamp    int64          `json:"timestamp"`
+		Nonce        int            `json:"nonce"`
+		PreviousHash string         `json:"previous_hash"`
 		Transactions []*Transaction `json:"transactions"`
 	}{
-		Nonce:        b.nonce,
-		PrevHash:     b.prevHash,
 		Timestamp:    b.timestamp,
+		Nonce:        b.nonce,
+		PreviousHash: fmt.Sprintf("%x", b.previousHash),
 		Transactions: b.transactions,
 	})
 }
 
-func newBlock(nonce int, previousHash [32]byte, transactions []*Transaction) *Block {
-	b := new(Block)
-	b.timestamp = time.Now().UnixNano()
-	b.nonce = nonce
-	b.prevHash = previousHash
-	b.transactions = transactions
-	return b
-}
-
 type Blockchain struct {
 	transactionPool   []*Transaction
 	chain             []*Block
 	blockchainAddress string
+	port              uint16
 }
 
-func newBlockchain(blockchainAddress string) *Blockchain {
+func NewBlockchain(blockchainAddress string, port uint16) *Blockchain {
 	b := &Block{}
 	bc := new(Blockchain)
 	bc.blockchainAddress = blockchainAddress
-	bc.createBlock(0, b.Hash())
+	bc.CreateBlock(0, b.Hash())
+	bc.port = port
 	return bc
 }
 
-func (bc *Blockchain) createBlock(nonce int, previousHash [32]byte) *Block {
-	b := newBlock(nonce, previousHash, bc.transactionPool)
+func (bc *Blockchain) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		Blocks []*Block `json:"chains"`
+	}{
+		Blocks: bc.chain,
+	})
+}
+
+func (bc *Blockchain) CreateBlock(nonce int, previousHash [32]byte) *Block {
+	b := NewBlock(nonce, previousHash, bc.transactionPool)
 	bc.chain = append(bc.chain, b)
 	bc.transactionPool = []*Transaction{}
 	return b
 }
 
+func (bc *Blockchain) LastBlock() *Block {
+	return bc.chain[len(bc.chain)-1]
+}
+
 func (bc *Blockchain) Print() {
 	for i, block := range bc.chain {
-		fmt.Printf("%s Chain %d  %s\n", strings.Repeat("=", 25), i, strings.Repeat("=", 25))
+		fmt.Printf("%s Chain %d %s\n", strings.Repeat("=", 25), i,
+			strings.Repeat("=", 25))
 		block.Print()
 	}
 	fmt.Printf("%s\n", strings.Repeat("*", 25))
 }
 
-func (bn *Blockchain) LastBlock() *Block {
-	return bn.chain[len(bn.chain)-1]
+func (bc *Blockchain) AddTransaction(sender string, recipient string, value float32,
+	senderPublicKey *ecdsa.PublicKey, s *utils.Signature) bool {
+	t := NewTransaction(sender, recipient, value)
+
+	if sender == MINING_SENDER {
+		bc.transactionPool = append(bc.transactionPool, t)
+		return true
+	}
+
+	if bc.VerifyTransactionSignature(senderPublicKey, s, t) {
+		/*
+			if bc.CalculateTotalAmount(sender) < value {
+				log.Println("ERROR: Not enough balance in a wallet")
+				return false
+			}
+		*/
+		bc.transactionPool = append(bc.transactionPool, t)
+		return true
+	} else {
+		log.Println("ERROR: Verify Transaction")
+	}
+	return false
+
 }
 
-func (bc *Blockchain) addTransaction(sender string, recipient string, value float32) {
-	t := NewTransaction(sender, recipient, value)
-	bc.transactionPool = append(bc.transactionPool, t)
+func (bc *Blockchain) VerifyTransactionSignature(
+	senderPublicKey *ecdsa.PublicKey, s *utils.Signature, t *Transaction) bool {
+	m, _ := json.Marshal(t)
+	h := sha256.Sum256([]byte(m))
+	return ecdsa.Verify(senderPublicKey, h[:], s.R, s.S)
 }
 
 func (bc *Blockchain) CopyTransactionPool() []*Transaction {
 	transactions := make([]*Transaction, 0)
 	for _, t := range bc.transactionPool {
-		transactions = append(transactions, NewTransaction(t.senderAddress, t.recipientAddress, t.value))
+		transactions = append(transactions,
+			NewTransaction(t.senderBlockchainAddress,
+				t.recipientBlockchainAddress,
+				t.value))
 	}
 	return transactions
 }
@@ -123,56 +166,71 @@ func (bc *Blockchain) ProofOfWork() int {
 }
 
 func (bc *Blockchain) Mining() bool {
-	bc.addTransaction(MINING_SENDER, bc.blockchainAddress, MINING_REWARD)
+	bc.AddTransaction(MINING_SENDER, bc.blockchainAddress, MINING_REWARD, nil, nil)
 	nonce := bc.ProofOfWork()
 	previousHash := bc.LastBlock().Hash()
-	bc.createBlock(nonce, previousHash)
+	bc.CreateBlock(nonce, previousHash)
 	log.Println("action=mining, status=success")
 	return true
 }
 
-// User amount
 func (bc *Blockchain) CalculateTotalAmount(blockchainAddress string) float32 {
-	var totalValue float32 = 0.0
+	var totalAmount float32 = 0.0
 	for _, b := range bc.chain {
 		for _, t := range b.transactions {
 			value := t.value
-			if blockchainAddress == t.recipientAddress {
-				totalValue += value
+			if blockchainAddress == t.recipientBlockchainAddress {
+				totalAmount += value
 			}
-			if blockchainAddress == t.senderAddress {
-				totalValue -= value
+
+			if blockchainAddress == t.senderBlockchainAddress {
+				totalAmount -= value
 			}
 		}
 	}
-	return totalValue
+	return totalAmount
 }
 
 type Transaction struct {
-	senderAddress    string
-	recipientAddress string
-	value            float32
+	senderBlockchainAddress    string
+	recipientBlockchainAddress string
+	value                      float32
 }
 
 func NewTransaction(sender string, recipient string, value float32) *Transaction {
-	return &Transaction{senderAddress: sender, recipientAddress: recipient, value: value}
+	return &Transaction{sender, recipient, value}
 }
 
 func (t *Transaction) Print() {
 	fmt.Printf("%s\n", strings.Repeat("-", 40))
-	fmt.Printf(" sender_blockchain_address    %s\n", t.senderAddress)
-	fmt.Printf(" recipient_blockchain_address %s\n", t.recipientAddress)
-	fmt.Printf(" transaction_value            %.1f\n", t.value)
+	fmt.Printf(" sender_blockchain_address      %s\n", t.senderBlockchainAddress)
+	fmt.Printf(" recipient_blockchain_address   %s\n", t.recipientBlockchainAddress)
+	fmt.Printf(" value                          %.1f\n", t.value)
 }
 
 func (t *Transaction) MarshalJSON() ([]byte, error) {
 	return json.Marshal(struct {
-		Sender    string  `json:"senderAddress"`
-		Recipient string  `json:"recipientAddress"`
+		Sender    string  `json:"sender_blockchain_address"`
+		Recipient string  `json:"recipient_blockchain_address"`
 		Value     float32 `json:"value"`
 	}{
-		Sender:    t.senderAddress,
-		Recipient: t.recipientAddress,
+		Sender:    t.senderBlockchainAddress,
+		Recipient: t.recipientBlockchainAddress,
 		Value:     t.value,
 	})
 }
+
+type TransactionRequest struct {
+	SenderBlockchainAddress    *string  `json:"sender_blockchain_address"`
+	RecipientBlockchainAddress *string  `json:"recipient_blockchain_address"`
+	SenderPublicKey            *string  `json:"sender_public_key"`
+	Value                      *float32 `json:"value"`
+	Signature                  *string  `json:"signature"`
+}
+
+func (tr *TransactionRequest) Validate() bool {
+	if tr.SenderBlockchainAddress == nil || tr.RecipientBlockchainAddress == nil || tr.SenderPublicKey == nil || tr.Value == nil || tr.Signature == nil {
+		return false
+	}
+	return true
+}

blockchain_server/blockchain_server.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"goBlockchain/block"
+	"goBlockchain/wallet"
+	"io"
+	"log"
+	"net/http"
+	"strconv"
+)
+
+var cache map[string]*block.Blockchain = make(map[string]*block.Blockchain)
+
+type BlockchainServer struct {
+	port uint16
+}
+
+func NewBlockchainServer(port uint16) *BlockchainServer {
+	return &BlockchainServer{port}
+}
+
+func (bcs *BlockchainServer) Port() uint16 {
+	return bcs.port
+}
+
+func (bcs *BlockchainServer) GetBlockchain() *block.Blockchain {
+	bc, ok := cache["blockchain"]
+	if !ok {
+		minersWallet := wallet.NewWallet()
+		bc = block.NewBlockchain(minersWallet.BlockchainAddress(), bcs.Port())
+		cache["blockchain"] = bc
+		log.Printf("private_key %v", minersWallet.PrivateKeyStr())
+		log.Printf("publick_key %v", minersWallet.PublicKeyStr())
+		log.Printf("blockchain_address %v", minersWallet.BlockchainAddress())
+	}
+	return bc
+}
+
+func (bcs *BlockchainServer) GetChain(w http.ResponseWriter, req *http.Request) {
+	switch req.Method {
+	case http.MethodGet:
+		w.Header().Add("Content-Type", "application/json")
+		bc := bcs.GetBlockchain()
+		m, _ := bc.MarshalJSON()
+		io.WriteString(w, string(m[:]))
+	default:
+		log.Printf("ERROR: Invalid HTTP Method")
+
+	}
+}
+
+func (bcs *BlockchainServer) Run() {
+	http.HandleFunc("/", bcs.GetChain)
+	log.Fatal(http.ListenAndServe("0.0.0.0:"+strconv.Itoa(int(bcs.Port())), nil))
+}

blockchain_server/main.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"flag"
+	"log"
+)
+
+func init() {
+	log.SetPrefix("Blockchain: ")
+}
+
+func main() {	
+	port := flag.Uint("port", 5000, "TCP Port Number for Blockchain Server")
+	flag.Parse()
+	app := NewBlockchainServer(uint16(*port))
+	app.Run()
+}

go.mod

@@ -3,6 +3,6 @@ module goBlockchain
 go 1.22.3
 
 require (
-	github.com/btcsuite/btcutil v1.0.2 // indirect
-	golang.org/x/crypto v0.23.0 // indirect
+	github.com/btcsuite/btcutil v1.0.2
+	golang.org/x/crypto v0.23.0
 )

main.go

@@ -0,0 +1 @@
+go run main.go blockchain_server.go