From 8bf39caa1ae845b3a410b6ce55f4b01ac4d85618 Mon Sep 17 00:00:00 2001 From: anilchinchawale Date: Thu, 29 Jan 2026 03:58:33 +0100 Subject: [PATCH] Remove duplicate rawdb accessors and incompatible p2p files --- core/rawdb/accessors_xdc_indexes.go | 209 ---------------------- p2p/dial_xdc.go | 262 ---------------------------- p2p/server_xdc.go | 221 ----------------------- 3 files changed, 692 deletions(-) delete mode 100644 core/rawdb/accessors_xdc_indexes.go delete mode 100644 p2p/dial_xdc.go delete mode 100644 p2p/server_xdc.go diff --git a/core/rawdb/accessors_xdc_indexes.go b/core/rawdb/accessors_xdc_indexes.go deleted file mode 100644 index e53e1232a0..0000000000 --- a/core/rawdb/accessors_xdc_indexes.go +++ /dev/null @@ -1,209 +0,0 @@ -// Copyright 2021 XDC Network -// This file is part of the XDC library. - -package rawdb - -import ( - "encoding/binary" - - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethdb" -) - -// XDC-specific database key prefixes -var ( - validatorSetPrefix = []byte("xdc-validators-") - epochDataPrefix = []byte("xdc-epoch-") - penaltyPrefix = []byte("xdc-penalty-") - checkpointPrefix = []byte("xdc-checkpoint-") - snapshotPrefix = []byte("xdc-snapshot-") - tradingStatePrefix = []byte("xdcx-trading-") - lendingStatePrefix = []byte("xdcx-lending-") -) - -// encodeBlockNumber encodes a block number as big endian uint64 -func encodeBlockNumber(number uint64) []byte { - enc := make([]byte, 8) - binary.BigEndian.PutUint64(enc, number) - return enc -} - -// validatorSetKey returns the key for validator set at block number -func validatorSetKey(number uint64) []byte { - return append(validatorSetPrefix, encodeBlockNumber(number)...) -} - -// epochDataKey returns the key for epoch data -func epochDataKey(epoch uint64) []byte { - return append(epochDataPrefix, encodeBlockNumber(epoch)...) -} - -// penaltyKey returns the key for a penalty record -func penaltyKey(validator common.Address, block uint64) []byte { - key := append(penaltyPrefix, validator.Bytes()...) - return append(key, encodeBlockNumber(block)...) -} - -// checkpointKey returns the key for a checkpoint -func checkpointKey(number uint64) []byte { - return append(checkpointPrefix, encodeBlockNumber(number)...) -} - -// snapshotKey returns the key for a snapshot -func snapshotKey(hash common.Hash) []byte { - return append(snapshotPrefix, hash.Bytes()...) -} - -// WriteValidatorSet writes the validator set for a block -func WriteValidatorSet(db ethdb.KeyValueWriter, number uint64, validators []common.Address) error { - data := make([]byte, len(validators)*common.AddressLength) - for i, v := range validators { - copy(data[i*common.AddressLength:], v.Bytes()) - } - return db.Put(validatorSetKey(number), data) -} - -// ReadValidatorSet reads the validator set for a block -func ReadValidatorSet(db ethdb.KeyValueReader, number uint64) []common.Address { - data, err := db.Get(validatorSetKey(number)) - if err != nil || len(data) == 0 { - return nil - } - - count := len(data) / common.AddressLength - validators := make([]common.Address, count) - for i := 0; i < count; i++ { - validators[i] = common.BytesToAddress(data[i*common.AddressLength : (i+1)*common.AddressLength]) - } - return validators -} - -// DeleteValidatorSet deletes the validator set for a block -func DeleteValidatorSet(db ethdb.KeyValueWriter, number uint64) error { - return db.Delete(validatorSetKey(number)) -} - -// WriteEpochData writes epoch data -func WriteEpochData(db ethdb.KeyValueWriter, epoch uint64, data []byte) error { - return db.Put(epochDataKey(epoch), data) -} - -// ReadEpochData reads epoch data -func ReadEpochData(db ethdb.KeyValueReader, epoch uint64) []byte { - data, err := db.Get(epochDataKey(epoch)) - if err != nil { - return nil - } - return data -} - -// DeleteEpochData deletes epoch data -func DeleteEpochData(db ethdb.KeyValueWriter, epoch uint64) error { - return db.Delete(epochDataKey(epoch)) -} - -// WritePenalty writes a penalty record -func WritePenalty(db ethdb.KeyValueWriter, validator common.Address, block uint64, amount uint64) error { - data := encodeBlockNumber(amount) - return db.Put(penaltyKey(validator, block), data) -} - -// ReadPenalty reads a penalty record -func ReadPenalty(db ethdb.KeyValueReader, validator common.Address, block uint64) uint64 { - data, err := db.Get(penaltyKey(validator, block)) - if err != nil || len(data) != 8 { - return 0 - } - return binary.BigEndian.Uint64(data) -} - -// DeletePenalty deletes a penalty record -func DeletePenalty(db ethdb.KeyValueWriter, validator common.Address, block uint64) error { - return db.Delete(penaltyKey(validator, block)) -} - -// WriteCheckpoint writes a checkpoint -func WriteCheckpoint(db ethdb.KeyValueWriter, number uint64, hash common.Hash) error { - return db.Put(checkpointKey(number), hash.Bytes()) -} - -// ReadCheckpoint reads a checkpoint -func ReadCheckpoint(db ethdb.KeyValueReader, number uint64) common.Hash { - data, err := db.Get(checkpointKey(number)) - if err != nil || len(data) != common.HashLength { - return common.Hash{} - } - return common.BytesToHash(data) -} - -// DeleteCheckpoint deletes a checkpoint -func DeleteCheckpoint(db ethdb.KeyValueWriter, number uint64) error { - return db.Delete(checkpointKey(number)) -} - -// WriteXDPoSSnapshot writes an XDPoS snapshot -func WriteXDPoSSnapshot(db ethdb.KeyValueWriter, hash common.Hash, data []byte) error { - return db.Put(snapshotKey(hash), data) -} - -// ReadXDPoSSnapshot reads an XDPoS snapshot -func ReadXDPoSSnapshot(db ethdb.KeyValueReader, hash common.Hash) []byte { - data, err := db.Get(snapshotKey(hash)) - if err != nil { - return nil - } - return data -} - -// DeleteXDPoSSnapshot deletes an XDPoS snapshot -func DeleteXDPoSSnapshot(db ethdb.KeyValueWriter, hash common.Hash) error { - return db.Delete(snapshotKey(hash)) -} - -// HasXDPoSSnapshot checks if a snapshot exists -func HasXDPoSSnapshot(db ethdb.KeyValueReader, hash common.Hash) bool { - has, _ := db.Has(snapshotKey(hash)) - return has -} - -// XDCx Trading State - -// tradingStateKey returns the key for trading state -func tradingStateKey(root common.Hash) []byte { - return append(tradingStatePrefix, root.Bytes()...) -} - -// WriteTradingStateRoot writes the trading state root for a block -func WriteTradingStateRoot(db ethdb.KeyValueWriter, blockHash, tradingRoot common.Hash) error { - return db.Put(tradingStateKey(blockHash), tradingRoot.Bytes()) -} - -// ReadTradingStateRoot reads the trading state root for a block -func ReadTradingStateRoot(db ethdb.KeyValueReader, blockHash common.Hash) common.Hash { - data, err := db.Get(tradingStateKey(blockHash)) - if err != nil || len(data) != common.HashLength { - return common.Hash{} - } - return common.BytesToHash(data) -} - -// XDCx Lending State - -// lendingStateKey returns the key for lending state -func lendingStateKey(root common.Hash) []byte { - return append(lendingStatePrefix, root.Bytes()...) -} - -// WriteLendingStateRoot writes the lending state root for a block -func WriteLendingStateRoot(db ethdb.KeyValueWriter, blockHash, lendingRoot common.Hash) error { - return db.Put(lendingStateKey(blockHash), lendingRoot.Bytes()) -} - -// ReadLendingStateRoot reads the lending state root for a block -func ReadLendingStateRoot(db ethdb.KeyValueReader, blockHash common.Hash) common.Hash { - data, err := db.Get(lendingStateKey(blockHash)) - if err != nil || len(data) != common.HashLength { - return common.Hash{} - } - return common.BytesToHash(data) -} diff --git a/p2p/dial_xdc.go b/p2p/dial_xdc.go deleted file mode 100644 index b90962dd05..0000000000 --- a/p2p/dial_xdc.go +++ /dev/null @@ -1,262 +0,0 @@ -// Copyright 2023 The XDC Network Authors -// This file is part of the XDC Network library. -// -// The XDC Network library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -package p2p - -import ( - "context" - "sync" - "time" - - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/p2p/enode" -) - -// XDCDialScheduler extends the dial scheduler with masternode prioritization -type XDCDialScheduler struct { - mu sync.Mutex - masternodeNodes map[enode.ID]*enode.Node - priorityQueue []*enode.Node - dialer NodeDialer - maxDialing int - dialingCount int -} - -// NewXDCDialScheduler creates a new XDC dial scheduler -func NewXDCDialScheduler(dialer NodeDialer, maxDialing int) *XDCDialScheduler { - return &XDCDialScheduler{ - masternodeNodes: make(map[enode.ID]*enode.Node), - priorityQueue: make([]*enode.Node, 0), - dialer: dialer, - maxDialing: maxDialing, - } -} - -// SetMasternodes sets the current masternode list -func (s *XDCDialScheduler) SetMasternodes(nodes []*enode.Node) { - s.mu.Lock() - defer s.mu.Unlock() - - s.masternodeNodes = make(map[enode.ID]*enode.Node) - s.priorityQueue = make([]*enode.Node, 0, len(nodes)) - - for _, node := range nodes { - s.masternodeNodes[node.ID()] = node - s.priorityQueue = append(s.priorityQueue, node) - } - - log.Debug("Updated dial scheduler masternode list", "count", len(nodes)) -} - -// IsMasternode checks if a node ID is a masternode -func (s *XDCDialScheduler) IsMasternode(id enode.ID) bool { - s.mu.Lock() - defer s.mu.Unlock() - - _, exists := s.masternodeNodes[id] - return exists -} - -// GetPriorityNode returns the next priority node to dial -func (s *XDCDialScheduler) GetPriorityNode() *enode.Node { - s.mu.Lock() - defer s.mu.Unlock() - - if len(s.priorityQueue) == 0 { - return nil - } - - node := s.priorityQueue[0] - s.priorityQueue = s.priorityQueue[1:] - return node -} - -// AddPriorityNode adds a node to the priority queue -func (s *XDCDialScheduler) AddPriorityNode(node *enode.Node) { - s.mu.Lock() - defer s.mu.Unlock() - - // Don't add duplicates - for _, n := range s.priorityQueue { - if n.ID() == node.ID() { - return - } - } - - s.priorityQueue = append(s.priorityQueue, node) -} - -// DialContext dials a node with context -func (s *XDCDialScheduler) DialContext(ctx context.Context, node *enode.Node) (Conn, error) { - s.mu.Lock() - if s.dialingCount >= s.maxDialing { - s.mu.Unlock() - return nil, errTooManyPeers - } - s.dialingCount++ - s.mu.Unlock() - - defer func() { - s.mu.Lock() - s.dialingCount-- - s.mu.Unlock() - }() - - return s.dialer.Dial(node) -} - -var errTooManyPeers = &DiscReason{DiscTooManyPeers} - -// MasternodeDialer dials masternodes with priority -type MasternodeDialer struct { - scheduler *XDCDialScheduler - interval time.Duration - quit chan struct{} -} - -// NewMasternodeDialer creates a new masternode dialer -func NewMasternodeDialer(scheduler *XDCDialScheduler, interval time.Duration) *MasternodeDialer { - return &MasternodeDialer{ - scheduler: scheduler, - interval: interval, - quit: make(chan struct{}), - } -} - -// Start starts the masternode dialing loop -func (d *MasternodeDialer) Start() { - go d.loop() -} - -// Stop stops the masternode dialer -func (d *MasternodeDialer) Stop() { - close(d.quit) -} - -func (d *MasternodeDialer) loop() { - ticker := time.NewTicker(d.interval) - defer ticker.Stop() - - for { - select { - case <-ticker.C: - d.dialNext() - case <-d.quit: - return - } - } -} - -func (d *MasternodeDialer) dialNext() { - node := d.scheduler.GetPriorityNode() - if node == nil { - return - } - - ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) - defer cancel() - - _, err := d.scheduler.DialContext(ctx, node) - if err != nil { - log.Debug("Failed to dial masternode", "id", node.ID(), "err", err) - // Re-add to queue for retry - d.scheduler.AddPriorityNode(node) - } -} - -// PeerPriority defines peer priority levels -type PeerPriority int - -const ( - PriorityNormal PeerPriority = iota - PriorityMasternode - PriorityValidator -) - -// XDCPeerSelector selects peers based on priority -type XDCPeerSelector struct { - mu sync.RWMutex - peers map[enode.ID]PeerPriority - maxPeers int -} - -// NewXDCPeerSelector creates a new peer selector -func NewXDCPeerSelector(maxPeers int) *XDCPeerSelector { - return &XDCPeerSelector{ - peers: make(map[enode.ID]PeerPriority), - maxPeers: maxPeers, - } -} - -// SetPriority sets the priority for a peer -func (s *XDCPeerSelector) SetPriority(id enode.ID, priority PeerPriority) { - s.mu.Lock() - defer s.mu.Unlock() - s.peers[id] = priority -} - -// GetPriority gets the priority for a peer -func (s *XDCPeerSelector) GetPriority(id enode.ID) PeerPriority { - s.mu.RLock() - defer s.mu.RUnlock() - return s.peers[id] -} - -// ShouldConnect determines if we should connect to a peer -func (s *XDCPeerSelector) ShouldConnect(id enode.ID, priority PeerPriority) bool { - s.mu.RLock() - defer s.mu.RUnlock() - - // Always accept masternodes and validators - if priority >= PriorityMasternode { - return true - } - - // Count by priority - normalCount := 0 - for _, p := range s.peers { - if p == PriorityNormal { - normalCount++ - } - } - - // Reserve slots for high priority peers - reservedSlots := s.maxPeers / 3 - maxNormal := s.maxPeers - reservedSlots - - return normalCount < maxNormal -} - -// RemovePeer removes a peer from the selector -func (s *XDCPeerSelector) RemovePeer(id enode.ID) { - s.mu.Lock() - defer s.mu.Unlock() - delete(s.peers, id) -} - -// GetMasternodePeers returns all masternode peers -func (s *XDCPeerSelector) GetMasternodePeers() []enode.ID { - s.mu.RLock() - defer s.mu.RUnlock() - - var result []enode.ID - for id, priority := range s.peers { - if priority >= PriorityMasternode { - result = append(result, id) - } - } - return result -} - -// MasternodeAddressToNodeID converts a masternode address to enode ID -// This is a placeholder - actual implementation would use the masternode registry -func MasternodeAddressToNodeID(addr common.Address) enode.ID { - // In practice, this would look up the enode from the masternode registry - return enode.ID{} -} diff --git a/p2p/server_xdc.go b/p2p/server_xdc.go deleted file mode 100644 index c5ee2aeeb6..0000000000 --- a/p2p/server_xdc.go +++ /dev/null @@ -1,221 +0,0 @@ -// Copyright 2023 The XDC Network Authors -// This file is part of the XDC Network library. -// -// The XDC Network library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -package p2p - -import ( - "errors" - "sync" - - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/p2p/enode" -) - -var ( - // ErrAddPairPeer is returned when adding a paired peer (not an error, signals pairing) - ErrAddPairPeer = errors.New("add pair peer") - - // ErrMasternodeNotFound is returned when masternode is not in the list - ErrMasternodeNotFound = errors.New("masternode not found") -) - -// MasternodeConfig contains XDPoS masternode configuration -type MasternodeConfig struct { - // Enable masternode mode - Enabled bool - - // Masternode account address - Address common.Address - - // Priority dial for masternodes - PriorityDial bool - - // Max masternode peers - MaxMasternodePeers int -} - -// MasternodeManager manages masternode peer connections -type MasternodeManager struct { - mu sync.RWMutex - masternodes map[common.Address]*enode.Node - active map[common.Address]bool - config *MasternodeConfig -} - -// NewMasternodeManager creates a new masternode manager -func NewMasternodeManager(config *MasternodeConfig) *MasternodeManager { - if config == nil { - config = &MasternodeConfig{ - MaxMasternodePeers: 50, - } - } - return &MasternodeManager{ - masternodes: make(map[common.Address]*enode.Node), - active: make(map[common.Address]bool), - config: config, - } -} - -// UpdateMasternodes updates the masternode list -func (m *MasternodeManager) UpdateMasternodes(nodes map[common.Address]*enode.Node) { - m.mu.Lock() - defer m.mu.Unlock() - - // Clear old list - m.masternodes = make(map[common.Address]*enode.Node) - - // Add new masternodes - for addr, node := range nodes { - m.masternodes[addr] = node - } - - log.Info("Updated masternode list", "count", len(m.masternodes)) -} - -// GetMasternodes returns the current masternode list -func (m *MasternodeManager) GetMasternodes() map[common.Address]*enode.Node { - m.mu.RLock() - defer m.mu.RUnlock() - - result := make(map[common.Address]*enode.Node) - for addr, node := range m.masternodes { - result[addr] = node - } - return result -} - -// IsMasternode checks if an address is a masternode -func (m *MasternodeManager) IsMasternode(addr common.Address) bool { - m.mu.RLock() - defer m.mu.RUnlock() - - _, exists := m.masternodes[addr] - return exists -} - -// SetActive marks a masternode as active/inactive -func (m *MasternodeManager) SetActive(addr common.Address, active bool) { - m.mu.Lock() - defer m.mu.Unlock() - - m.active[addr] = active -} - -// IsActive checks if a masternode is active -func (m *MasternodeManager) IsActive(addr common.Address) bool { - m.mu.RLock() - defer m.mu.RUnlock() - - return m.active[addr] -} - -// ActiveCount returns the count of active masternodes -func (m *MasternodeManager) ActiveCount() int { - m.mu.RLock() - defer m.mu.RUnlock() - - count := 0 - for _, active := range m.active { - if active { - count++ - } - } - return count -} - -// GetMasternodeNode gets the enode for a masternode address -func (m *MasternodeManager) GetMasternodeNode(addr common.Address) *enode.Node { - m.mu.RLock() - defer m.mu.RUnlock() - - return m.masternodes[addr] -} - -// GetMasternodeAddresses returns all masternode addresses -func (m *MasternodeManager) GetMasternodeAddresses() []common.Address { - m.mu.RLock() - defer m.mu.RUnlock() - - addrs := make([]common.Address, 0, len(m.masternodes)) - for addr := range m.masternodes { - addrs = append(addrs, addr) - } - return addrs -} - -// PrioritizeMasternodes returns nodes that should be prioritized for connection -func (m *MasternodeManager) PrioritizeMasternodes() []*enode.Node { - m.mu.RLock() - defer m.mu.RUnlock() - - nodes := make([]*enode.Node, 0) - for addr, node := range m.masternodes { - if !m.active[addr] && node != nil { - nodes = append(nodes, node) - } - } - return nodes -} - -// XDCServerConfig extends server config with XDPoS options -type XDCServerConfig struct { - // Base server config - Config - - // Masternode configuration - Masternode *MasternodeConfig - - // Whether to accept non-masternode peers - AcceptNonMasternode bool -} - -// XDCDialer implements a dialer that prioritizes masternodes -type XDCDialer struct { - manager *MasternodeManager - dialer NodeDialer -} - -// NewXDCDialer creates a new XDC dialer -func NewXDCDialer(manager *MasternodeManager, dialer NodeDialer) *XDCDialer { - return &XDCDialer{ - manager: manager, - dialer: dialer, - } -} - -// Dial attempts to dial a node, prioritizing masternodes -func (d *XDCDialer) Dial(dest *enode.Node) (Conn, error) { - // TODO: Implement priority dialing for masternodes - return d.dialer.Dial(dest) -} - -// PeerHook is called when a peer connects or disconnects -type PeerHook func(peer *Peer, added bool) - -// XDCPeerHooks contains hooks for XDPoS peer events -type XDCPeerHooks struct { - OnConnect PeerHook - OnDisconnect PeerHook -} - -// MasternodePeerInfo contains masternode-specific peer info -type MasternodePeerInfo struct { - Address common.Address `json:"address"` - IsMaster bool `json:"isMaster"` - Epoch uint64 `json:"epoch"` - IsValidator bool `json:"isValidator"` -} - -// GetMasternodePeerInfo extracts masternode info from a peer -func GetMasternodePeerInfo(peer *Peer) *MasternodePeerInfo { - // This would be extracted from peer handshake data - return &MasternodePeerInfo{ - IsMaster: false, - } -}