Changes to be committed:

new file:   cmd/geth/consensus/hybrid.go
	new file:   cmd/geth/core/blockchain.go
	modified:   cmd/geth/main.go
	new file:   cmd/geth/tests/hybrid_test.go
	new file:   consensus/hybrid-consensus/consensus.go
	new file:   consensus/hybrid-consensus/consensus_test.go
	new file:   consensus/hybrid-consensus/go.mod
	new file:   consensus/hybrid-consensus/hybridconsensus.go
	new file:   consensus/hybrid-consensus/metrics.go
	new file:   consensus/hybrid-consensus/validators.go

cmd/geth/consensus/hybrid.go

@@ -0,0 +1,22 @@
+package consensus
+
+import "log"
+
+type HybridConsensus struct {
+    PoW *ProofOfWork
+    PoS *ProofOfStake
+}
+
+type ProofOfWork struct {
+    // PoW ile ilgili alanlar
+}
+
+type ProofOfStake struct {
+    // PoS ile ilgili alanlar
+}
+
+func (h *HybridConsensus) Start() {
+    log.Println("Hybrid konsensüs başlatıldı.")
+    // Başlatma işlemleri
+}
+

cmd/geth/core/blockchain.go

@@ -0,0 +1,9 @@
+package core
+
+import "log"
+
+func ProcessBlock() {
+    // Hybrid konsensüs ile blok işleme mantığı
+    log.Println("Blok işleniyor...")
+}
+

cmd/geth/main.go

@@ -45,6 +45,7 @@ import (
 	_ "github.com/ethereum/go-ethereum/eth/tracers/native"
 
 	"github.com/urfave/cli/v2"
+	"github.com/oxwa/hybrid-consensus" // Hibrit konsensüs paketini içe aktarın
 )
 
 const (
@@ -277,6 +278,25 @@ func init() {
 }
 
 func main() {
+	// Validator listesi (örnek)
+	validators := []hybridconsensus.Validator{
+		{Address: common.HexToAddress("0xValidator1"), Stake: 100},
+		{Address: common.HexToAddress("0xValidator2"), Stake: 200},
+	}
+
+	// Hibrit konsensüs algoritmasını başlat
+	hc := hybridconsensus.NewHybridConsensus(validators)
+
+	// İlk bloğu oluştur
+	block, err := hc.CreateBlock(validators[0].Address)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "failed to create block: %v\n", err)
+		os.Exit(1)
+	}
+
+	fmt.Printf("Created block: %+v\n", block)
+
+	// Uygulamanızı başlat
 	if err := app.Run(os.Args); err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)

cmd/geth/tests/hybrid_test.go

@@ -0,0 +1,11 @@
+package tests
+
+import (
+    "testing"
+)
+
+func TestHybridConsensus(t *testing.T) {
+    // Hybrid konsensüs testleri
+    // Örnek test kodları
+}
+

consensus/hybrid-consensus/consensus.go

@@ -0,0 +1,64 @@
+package hybridconsensus
+
+import (
+    "errors"
+    "time"
+)
+
+type Block struct {
+    Number    uint64
+    Validator string
+    Timestamp time.Time
+    PrevHash  string
+}
+
+type Validator struct {
+    Address string
+    Stake   uint64
+}
+
+type HybridConsensus struct {
+    validators []Validator
+    blocks     []Block
+}
+
+func NewHybridConsensus(validators []Validator) *HybridConsensus {
+    return &HybridConsensus{
+        validators: validators,
+        blocks:     []Block{},
+    }
+}
+
+func (hc *HybridConsensus) CreateBlock(validator string) (*Block, error) {
+    if !hc.IsValidator(validator) {
+        return nil, errors.New("validator not authorized")
+    }
+
+    newBlock := Block{
+        Number:    uint64(len(hc.blocks) + 1),
+        Validator: validator,
+        Timestamp: time.Now(),
+        PrevHash:  hc.GetLatestBlockHash(),
+    }
+
+    hc.blocks = append(hc.blocks, newBlock)
+    return &newBlock, nil
+}
+
+func (hc *HybridConsensus) GetLatestBlockHash() string {
+    if len(hc.blocks) == 0 {
+        return ""
+    }
+    latestBlock := hc.blocks[len(hc.blocks)-1]
+    return string(latestBlock.Number)
+}
+
+func (hc *HybridConsensus) IsValidator(address string) bool {
+    for _, validator := range hc.validators {
+        if validator.Address == address {
+            return true
+        }
+    }
+    return false
+}
+

consensus/hybrid-consensus/consensus_test.go

@@ -0,0 +1,24 @@
+package hybridconsensus
+
+import (
+    "testing"
+)
+
+func TestCreateBlock(t *testing.T) {
+    validators := []Validator{
+        {Address: "0xValidator1", Stake: 100},
+        {Address: "0xValidator2", Stake: 200},
+    }
+    
+    hc := NewHybridConsensus(validators)
+
+    block, err := hc.CreateBlock("0xValidator1")
+    if err != nil {
+        t.Errorf("expected no error, got %v", err)
+    }
+    
+    if block.Number != 1 {
+        t.Errorf("expected block number 1, got %d", block.Number)
+    }
+}
+

consensus/hybrid-consensus/go.mod

@@ -0,0 +1,4 @@
+module github.com/oxwa/hybrid-consensus
+
+go 1.23.2
+

consensus/hybrid-consensus/hybridconsensus.go

@@ -0,0 +1,36 @@
+package hybridconsensus
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"time"
+)
+
+type Validator struct {
+	Address common.Address
+	Stake   uint64
+}
+
+type Block struct {
+	Number     uint64
+	Time       time.Time
+	Validators []common.Address
+}
+
+type HybridConsensus struct {
+	validators []Validator
+}
+
+func NewHybridConsensus(validators []Validator) *HybridConsensus {
+	return &HybridConsensus{validators: validators}
+}
+
+func (hc *HybridConsensus) CreateBlock(validatorAddress common.Address) (*Block, error) {
+	// Burada blok oluşturma mantığını ekleyin
+	block := &Block{
+		Number:     1, // Blok numarasını güncel bir mekanizma ile güncelleyin
+		Time:       time.Now(),
+		Validators: []common.Address{validatorAddress},
+	}
+	return block, nil
+}
+

consensus/hybrid-consensus/metrics.go

@@ -0,0 +1,16 @@
+package hybridconsensus
+
+import (
+    "time"
+)
+
+type Metrics struct {
+    BlockCreationTime time.Duration
+    TotalBlocks       uint64
+}
+
+func (hc *HybridConsensus) RecordBlockCreationTime(start time.Time) {
+    hc.metrics.BlockCreationTime = time.Since(start)
+    hc.metrics.TotalBlocks++
+}
+

consensus/hybrid-consensus/validators.go

@@ -0,0 +1,16 @@
+package hybridconsensus
+
+// Validator ekleme, çıkarma ve doğrulama işlevleri
+func (hc *HybridConsensus) AddValidator(address string, stake uint64) {
+    hc.validators = append(hc.validators, Validator{Address: address, Stake: stake})
+}
+
+func (hc *HybridConsensus) RemoveValidator(address string) {
+    for i, validator := range hc.validators {
+        if validator.Address == address {
+            hc.validators = append(hc.validators[:i], hc.validators[i+1:]...)
+            return
+        }
+    }
+}
+