merkle tree yazıldı

blockchain/block.go

@@ -2,7 +2,6 @@ package blockchain
 
 import (
 	"bytes"
-	"crypto/sha256"
 	"encoding/gob"
 	"log"
 )
@@ -14,27 +13,19 @@ type Block struct {
 	Nonce        int
 }
 
+// HashTransactions fonksiyonu, bloğun islemlerini hash eder
 func (b *Block) HashTransactions() []byte {
-	var txHashes [][]byte // İşlemlerin kimliklerini (hash'lerini) tutmak için bir slice tanımlıyoruz
-	var txHash []byte     // Son hesaplanan hash'i tutacak byte slice
+	var txHashes [][]byte
 
-	// Bloktaki her bir işlem için döngü
-	for _, tx := range b.Transactions {
-		txHashes = append(txHashes, tx.ID) // Her işlemin ID'sini (hash'ini) txHashes slice'ına ekliyoruz
+	for _, tx := range b.Transactions { //islemi byte dizisine dönüştürür
+		txHashes = append(txHashes, tx.Serialize()) //islemi byte dizisine dönüştürür
 	}
+	tree := NewMerkleTree(txHashes) //merkle tree olusturulur
 
-	// txHashes içindeki tüm işlem kimliklerini birleştirip tek bir byte dizisi oluşturuyoruz
-	concatenated := bytes.Join(txHashes, []byte{})
-
-	// concatenated byte dizisinin SHA-256 hash'ini hesaplıyoruz
-	hash := sha256.Sum256(concatenated)
-
-	// [32]byte türündeki hash'i []byte türüne dönüştürüyoruz
-	txHash = hash[:]
-
-	return txHash[:] // Hesaplanan hash'i döndürüyoruz
+	return tree.RootNode.Data //merkle treein rootunun byte dizisine dönüştürülür
 }
 
+// CreateBlock fonksiyonu, yeni bir bloğu olusturur
 func CreateBlock(tsx []*Transaction, prevHash []byte) *Block {
 	block := &Block{[]byte{}, tsx, prevHash, 0} //[]byte(data) kısmı strıng ıfadeyi byte dizisine donduruyor
 
@@ -45,12 +36,14 @@ func CreateBlock(tsx []*Transaction, prevHash []byte) *Block {
 	return block
 }
 
+// Genesis fonksiyonu, ilk bloğu olusturur
 func Genesis(coinbase *Transaction) *Block {
 	return CreateBlock([]*Transaction{coinbase}, []byte{})
 }
 
 //Badger DB sadece byte kabul ettıgı ıcın serılestırme ve deserilize ıslemlerı kolyalastıralım
 
+// Serialize fonksiyonu, bloğu byte dizisine dönüştürür
 func (b *Block) Serialize() []byte {
 	var res bytes.Buffer // bir bytes.Buffer nesnesi oluşturuluyor
 
@@ -86,6 +79,7 @@ func Deserilize(data []byte) *Block {
 	return &block
 }
 
+// Handle fonksiyonu, oluşan hata durumunda programı durdurur.
 func Handle(err error) {
 	if err != nil {
 		log.Panic(err)

blockchain/blockchain.go

@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"github.com/dgraph-io/badger"
+	"log"
 	"os"
 	"runtime"
 )
@@ -109,26 +110,38 @@ func InitBlockChain(address string) *BlockChain {
 }
 
 // AddBlock  block zincirine  blok elememızı saglar
-func (chain *BlockChain) AddBlock(transactions []*Transaction) {
-	var lastHash []byte                                      //son  blogu tutucak
-	err := chain.Database.View(func(txn *badger.Txn) error { //verıtabanında okuma ıslemı yapıca k
-		item, err := txn.Get([]byte("lh")) //lh degerını oku
+func (chain *BlockChain) AddBlock(transactions []*Transaction) *Block {
+	var lastHash []byte //lastHash degerini olusturduk
+
+	for _, tx := range transactions { //gelen transactionları döndürerek
+		if chain.VerifyTransaction(tx) != true { //Gelen transactionları kontrol edip
+			log.Panic("Invalid Transaction") //Hatalı bir transaction varsa hata mesajını verir
+		}
+	}
+
+	err := chain.Database.View(func(txn *badger.Txn) error { //veritabanından son hash degerini alıyoruz
+		item, err := txn.Get([]byte("lh")) //son hash degerini alıyoruz
 		Handle(err)
-		lastHash, err = item.ValueCopy(nil) //degeri kopyala
+		lastHash, err = item.ValueCopy(nil) //son hash degerini alıyoruz
+
 		return err
 	})
 	Handle(err)
-	newBlock := CreateBlock(transactions, lastHash) //blogu olusturt
 
-	err = chain.Database.Update(func(txn *badger.Txn) error { //verıtabanında bır guncelleme ekleme yapılıcak
-		err := txn.Set(newBlock.Hash, newBlock.Serialize()) //yenı blogu verıtabanına ekle
+	newBlock := CreateBlock(transactions, lastHash) //yeni blok olusturuyoruz
+
+	err = chain.Database.Update(func(txn *badger.Txn) error { //veritabanına yeni blok ekliyoruz
+		err := txn.Set(newBlock.Hash, newBlock.Serialize()) //yeni blok veritabanına kaydediliyor
 		Handle(err)
-		err = txn.Set([]byte("lh"), newBlock.Hash) //lh degerını guncelle
+		err = txn.Set([]byte("lh"), newBlock.Hash) //son hash degeri veritabanına kaydediliyor
+
+		chain.LastHash = newBlock.Hash //son hash degeri veritabanına kaydedildi
 
-		chain.LastHash = newBlock.Hash //mevcut Blockchain nesenesındekı lastHası guncelle cunku artık son uretılen blog newBlock
 		return err
 	})
 	Handle(err)
+
+	return newBlock
 }
 
 // Iterator :BlockChaın de okuma işlemi yapmak için başlangıç değerlerini atayan kod
@@ -287,6 +300,11 @@ func (bc *BlockChain) SignTransaction(tx *Transaction, privKey ecdsa.PrivateKey)
 // VerifyTransaction fonksiyonu, bir Transaction yapısının geçerliliğini doğrular.
 // Geçerlilik kontrolü için verilen önceki işlemler haritası (prevTXs) kullanılır.
 func (bc *BlockChain) VerifyTransaction(tx *Transaction) bool {
+
+	if tx.IsCoinbase() {
+		return true
+	}
+
 	prevTXs := make(map[string]Transaction) // Önceki işlemlerin haritasını (map) oluşturur
 
 	// İşlemdeki her girdi için önceki işlemi bulup prevTXs haritasına ekler

blockchain/merkle.go

@@ -0,0 +1,55 @@
+package blockchain
+
+import "crypto/sha256"
+
+type MerkleTree struct {
+	RootNode *MerkleNode
+}
+
+type MerkleNode struct {
+	Left  *MerkleNode
+	Right *MerkleNode
+	Data  []byte
+}
+
+func NewMerkleNode(left, right *MerkleNode, data []byte) *MerkleNode {
+	node := MerkleNode{}
+
+	if left == nil && right == nil {
+		hash := sha256.Sum256(data)
+		node.Data = hash[:]
+	} else {
+		prevHash := append(left.Data, right.Data...)
+		hash := sha256.Sum256(prevHash)
+		node.Data = hash[:]
+	}
+
+	node.Left = left
+	node.Right = right
+
+	return &node
+}
+
+func NewMerkleTree(data [][]byte) *MerkleTree {
+	var nodes []MerkleNode
+	if len(data)%2 != 0 {
+		data = append(data, data[len(data)-1])
+	}
+
+	for _, data := range data {
+		node := NewMerkleNode(nil, nil, data)
+		nodes = append(nodes, *node)
+	}
+
+	for i := 0; i < len(data)/2; i++ {
+		var level []MerkleNode
+		for j := 0; j < len(nodes); j += 2 {
+			node := NewMerkleNode(&nodes[j], &nodes[j+1], nil)
+			level = append(level, *node)
+		}
+		nodes = level
+	}
+
+	tree := MerkleTree{&nodes[0]}
+	return &tree
+}

blockchain/transaction.go

@@ -24,30 +24,23 @@ type Transaction struct {
 // CoinbaseTx fonksiyonu, bir coinbase transaction oluşturur.
 func CoinbaseTx(to, data string) *Transaction {
 	if data == "" { //data boş ise gir
-		data = fmt.Sprintf("Coins to %s", to) //paralar to da der
+		randData := make([]byte, 24)  //data 24 byte'lık bir diziye dönüştür
+		_, err := rand.Read(randData) //rastgele sayı uretıcısı ile diziye dönüştür (diziyi doldur)
+		if err != nil {
+			log.Panic(err)
+		}
+		data = fmt.Sprintf("%x", randData) // diziyi stringe doğru dönüştür
+
 	}
 
 	txin := TxInput{[]byte{}, -1, nil, []byte(data)} //hıcbır cıktıya referabs vermez ,cıkıs endexi -1 aynı referans yok , sadce data mesajı vardır
-	txout := NewTXOutput(100, to)                    //100 tokeni to ya gonderırı
+	txout := NewTXOutput(20, to)                     //100 tokeni to ya gonderırı
 
 	tx := Transaction{nil, []TxInput{txin}, []TxOutput{*txout}} //transectıonı olustururuz
-	tx.SetID()                                                  //Transectıon Id sını olustururuz
+	tx.ID = tx.Hash()                                           //Transectıon hashini olustururuz                                           //Transectıon Id sını olustururuz
 	return &tx
 }
 
-// SetID fonksiyonu, Transectıon Id sını olusturur.
-func (tx *Transaction) SetID() { //Id olusturur transectıonun
-	var encoded bytes.Buffer
-	var hash [32]byte
-
-	encode := gob.NewEncoder(&encoded)
-	err := encode.Encode(tx) //transectıonu encode edıyoruz
-	Handle(err)
-
-	hash = sha256.Sum256(encoded.Bytes()) //transectıonu byte seklınde sha256 ıle sıfrelıyoruz ve ıd yı urettık
-	tx.ID = hash[:]
-}
-
 // NewTransaction, belirtilen bir adresten başka bir adrese belirtilen miktar token transferi yapacak yeni bir işlem oluşturur.
 func NewTransaction(from, to string, amount int, UTXO *UTXOSet) *Transaction {
 	var inputs []TxInput   // Bu işlemdeki girdiler (inputs)

cli/cli.go

@@ -125,9 +125,11 @@ func (cli *CommandLine) send(from, to string, amount int) {
 	UTXOSet := blockchain.UTXOSet{chain}         // gonderenin UTXO setini oluşturur
 	defer chain.Database.Close()                 // blok zincirini kapat
 
-	tx := blockchain.NewTransaction(from, to, amount, &UTXOSet) // yeni bir işlem oluşturur
-	chain.AddBlock([]*blockchain.Transaction{tx})               // blok zincirine ekler
-	fmt.Println("\u001B[32mSuccess!\u001B[0m")                  // basarılı mesajı verir
+	tx := blockchain.NewTransaction(from, to, amount, &UTXOSet)  // yeni bir işlem oluşturur
+	cbTx := blockchain.CoinbaseTx(from, "")                      //madencının parasını verıcezdrom olan madencı burada
+	block := chain.AddBlock([]*blockchain.Transaction{cbTx, tx}) // blok zincirine ekler
+	UTXOSet.Update(block)                                        // UTXO setini yeniden oluşturur
+	fmt.Println("\u001B[32mSuccess!\u001B[0m")                   // basarılı mesajı verir
 }
 
 // listAddresses fonksiyonu, cüzdan adreslerini listeler.