DPoS (Delegated Proof of Stake)

Introducción

KodeChain implementa un sistema DPoS optimizado para transacciones de alta velocidad con un sistema de rotación justo basado en múltiples métricas de performance.

Características Principales

Parámetros Básicos

• Delegados Activos: 21 (producción) / 7 (desarrollo)
• Tiempo de Bloque: 3 segundos
• Duración de Ronda: 63 segundos (21 bloques × 3s)
• TPS Estimado: ~300 transacciones por segundo

Archivos Clave

• consensus/dpos.go (1485 líneas)
• consensus/dpos_beacon_chain.go
• pkg/staking/staking_contract.go

Arquitectura

Estructura Principal

type DPoS struct {
    NodeID                 string
    Delegates              map[string]*DelegateInfo
    ActiveDelegates        []string
    CurrentProducer        string
    RoundLength            int        // 21 bloques
    BlockTime              int        // 3 segundos
    CurrentRound           int
    CurrentSlot            int
    StakeByNodeID          map[string]float64
    VotesByNodeID          map[string]string
    stakingContract        *staking.StakingContract
    passiveDelegationManager *staking.PassiveDelegationManager
    blockchainInstance     *blockchain.Blockchain
}

DelegateInfo

type DelegateInfo struct {
    Address          string
    PublicKey        string
    Stake            float64
    Votes            float64
    BlocksProduced   int
    MissedBlocks     int
    Reliability      float64
    IsActive         bool
    LastBlockTime    time.Time
    RewardsEarned    float64
    JoinedAt         time.Time
}

Sistema de Selección de Delegados

Cálculo de Score Balanceado

score = (reliability × 0.4) +
        (votes × 0.3) +
        (blocksCreated × 0.2) +
        (stake × 0.1)

Pesos de Métricas

• Confiabilidad (40%): Uptime y bloques producidos exitosamente
• Votos (30%): Delegaciones pasivas recibidas
• Bloques Creados (20%): Contribución histórica a la red
• Stake (10%): Cantidad de KDC en stake

Proceso de Selección

1. Obtener todos los validadores registrados
   ↓
2. Filtrar validadores activos (IsActive = true)
   ↓
3. Calcular score balanceado para cada uno
   ↓
4. Ordenar por score (mayor a menor)
   ↓
5. Seleccionar top 21 como ActiveDelegates
   ↓
6. Actualizar cada 100 bloques (5 minutos)

Producción de Bloques

Ciclo de Producción

┌─────────────────────────────────────┐
│   Ticker cada 3 segundos            │
└──────────────┬──────────────────────┘
               ↓
┌──────────────────────────────────────┐
│  updateSchedule()                    │
│  - Calcula slot actual               │
│  - Determina CurrentProducer         │
└──────────────┬───────────────────────┘
               ↓
┌──────────────────────────────────────┐
│  ¿Soy el productor actual?           │
└──────────────┬───────────────────────┘
               ↓ Sí
┌──────────────────────────────────────┐
│  createAndMineBlock()                │
│  1. Obtener txs del mempool          │
│  2. Crear nuevo bloque                │
│  3. Forjar bloque (hash + merkle)    │
│  4. Agregar a blockchain              │
└──────────────┬───────────────────────┘
               ↓
┌──────────────────────────────────────┐
│  ¿Fin de ronda?                      │
└──────────────┬───────────────────────┘
               ↓ Sí
┌──────────────────────────────────────┐
│  distributeRewards()                 │
│  - Calcular fees del período         │
│  - Distribuir a validadores          │
└──────────────────────────────────────┘

Creación de Bloques

func (dpos *DPoS) createAndMineBlock() (*blockchain.Block, error) {
    // 1. Obtener transacciones del mempool
    transactions := mempool.GetTransactions("DPOS", 1000)

    // 2. Crear bloque
    block := &blockchain.Block{
        Index:        lastBlock.Index + 1,
        Timestamp:    time.Now().Format(time.RFC3339),
        Type:         blockchain.BlockTypeDPOS,
        Transactions: transactions,
        PreviousHash: lastBlock.Hash,
        Validator:    dpos.NodeID,
    }

    // 3. Forjar bloque
    block.Hash = block.CalculateHash()
    block.MerkleRoot = block.CalculateMerkleRoot()

    // 4. Firmar bloque
    signature, _ := dpos.signer.Sign([]byte(block.Hash))
    block.Signature = hex.EncodeToString(signature)

    // 5. Agregar a blockchain
    blockchain.AddBlock(block)

    return block, nil
}

Sistema de Recompensas

Distribución de Fees

Total Fee = 100%
├── Validador: 70% - Burn Rate
├── Desarrollo: 30%
└── Burn: 1-10% (dinámico según supply)

Burn Rate Dinámico

Supply Total	Burn Rate	Validador Recibe
> 40M KDC	10%	60%
20-40M KDC	5%	65%
< 20M KDC	1%	69%

Distribución por Ronda

Al final de cada ronda (21 bloques):

func (dpos *DPoS) distributeRewards() {
    // Calcular total de fees de la ronda
    totalFees := calculateRoundFees()

    // Aplicar burn rate
    burnRate := calculateBurnRate(currentSupply)
    burnAmount := totalFees * burnRate

    // Calcular porción del validador
    validatorPortion := (totalFees * 0.70) - burnAmount
    developmentPortion := totalFees * 0.30

    // Distribuir a validadores según bloques producidos
    for _, delegate := range ActiveDelegates {
        blocksInRound := delegate.BlocksProducedInRound
        share := (blocksInRound / 21.0) * validatorPortion
        delegate.RewardsEarned += share
    }

    // Burn tokens
    blockchain.BurnTokens(burnAmount)
}

Reliability Score

Cálculo

reliability = (BlocksProduced / BlocksAssigned) × 100%

Ejemplo

Bloques Asignados: 1000
Bloques Producidos: 995
Bloques Perdidos: 5

Reliability = (995 / 1000) × 100% = 99.5%

Impacto en Score

Un validador con alta reliability tiene ventaja en la selección de delegados activos.

Sistema de Penalizaciones

Tipos de Penalties

Minor (0.1% stake, -5% reliability)

- Miss 1-3 bloques consecutivos
- Downtime < 1 hora

Severe (0.3% stake, -20% reliability)

- Miss 4-10 bloques consecutivos
- Downtime 1-6 horas

Critical (0.5% stake, reliability = 0, desactivación)

- Double signing
- Downtime > 6 horas
- Miss > 10 bloques consecutivos

Implementación

func (dpos *DPoS) SlashDelegate(address string, reason string) {
    delegate := dpos.Delegates[address]

    var penaltyAmount float64
    var reliabilityPenalty float64

    switch reason {
    case "missed_blocks_minor":
        penaltyAmount = delegate.Stake * 0.001 // 0.1%
        reliabilityPenalty = 0.05              // -5%

    case "missed_blocks_severe":
        penaltyAmount = delegate.Stake * 0.003 // 0.3%
        reliabilityPenalty = 0.20              // -20%

    case "double_sign":
        penaltyAmount = delegate.Stake * 0.005 // 0.5%
        delegate.Reliability = 0
        delegate.IsActive = false
    }

    // Aplicar penalty
    delegate.Stake -= penaltyAmount
    delegate.Reliability -= reliabilityPenalty

    // Burn penalty tokens
    blockchain.BurnTokens(penaltyAmount)
}

Delegación Pasiva

Los usuarios pueden delegar tokens a validadores sin correr un nodo.

Ventajas

• Participar en consenso sin hardware
• Recibir parte de las recompensas del validador
• Aumentar el voto del validador

Proceso

// 1. Usuario delega 100 KDC a validador
PassiveDelegationManager.Delegate(
    delegator: "0xUser",
    validator: "0xValidator",
    amount: 100 KDC
)

// 2. Aumenta "Votes" del validador
validator.Votes += 100

// 3. Mejora score del validador
score = (reliability × 0.4) + (votes × 0.3) + ...

// 4. Validador comparte recompensas
validatorReward = 10 KDC
delegatorShare = (delegatedAmount / totalDelegated) × validatorReward

Sincronización de Delegados

Entre Peers

func (dpos *DPoS) SyncDelegatesWithPeer(peerURL string) {
    // Obtener delegados del peer
    peerDelegates := fetchDelegatesFromPeer(peerURL)

    // Comparar con locales
    for address, peerDelegate := range peerDelegates {
        localDelegate := dpos.Delegates[address]

        // Actualizar si peer tiene info más reciente
        if peerDelegate.LastBlockTime.After(localDelegate.LastBlockTime) {
            dpos.Delegates[address] = peerDelegate
        }
    }

    // Actualizar ActiveDelegates si cambió
    dpos.UpdateActiveDelegates()
}

Ventajas de DPoS en KodeChain

1. Alta Velocidad

• Bloques cada 3 segundos
• ~300 TPS
• Confirmación casi instantánea

2. Eficiencia Energética

• No requiere minería
• Bajo consumo de recursos
• Ambientalmente sustentable

3. Descentralización Controlada

• 21 delegados activos
• Rotación dinámica
• Sistema de votación

4. Incentivos Alineados

• Recompensas por producción
• Penalties por mal comportamiento
• Delegación pasiva inclusiva

Comparación con Otros Sistemas

Característica	KodeChain DPoS	Bitcoin PoW	Ethereum PoS
Tiempo de Bloque	3s	~10min	~12s
TPS	~300	~7	~15
Consumo Energético	Bajo	Muy Alto	Medio
Finalidad	Inmediata	~60min	~15min
Validadores	21	Todos	Todos con 32 ETH
Delegación	Sí (pasiva)	No	No directa

Próximos Pasos

• Consenso PBFT
• Beacon Chains
• Convertirse en Validador
• Guía de Staking

---

DPoS: Velocidad y eficiencia sin comprometer seguridad