Saltar al contenido principal

Guía Completa de Staking en KodeChain

En el corazón de la seguridad y estabilidad de KodeChain reside el sistema de staking, un mecanismo sofisticado que combina contratos inteligentes, delegaciones pasivas y recompensas dinámicas. Esta guía revela cómo el código en pkg/staking/ transforma el staking en una experiencia fluida y segura.

La Arquitectura del Staking​

El Contrato Maestro: StakingContract​

El StakingContract en staking_contract.go es el núcleo del sistema, una estructura compleja que maneja:

type StakingContract struct {
    validators        map[string]*Validator
    stakes            map[string]*types.Balance
    activeValidators  map[string]bool
    activationManager ValidatorActivation
    rewardsSystem     *RewardsSystem
    penaltySystem     *PenaltySystem
    // ... más campos
}

Este contrato no solo almacena stakes, sino que orquesta todo el ciclo de vida de los validadores.

Delegaciones Pasivas: El Poder de la Comunidad​

El PassiveDelegationManager permite que cualquier usuario participe en la validación sin ejecutar nodos:

type PassiveDelegation struct {
    DelegatorAddress string         `json:"delegator_address"`
    ValidatorAddress string         `json:"validator_address"`
    StakeAmount      *types.Balance `json:"stake_amount"`
    DelegationTime   time.Time      `json:"delegation_time"`
    IsActive         bool           `json:"is_active"`
    RewardsEarned    *types.Balance `json:"rewards_earned"`
}

El Proceso de Staking​

Paso 1: Registro del Validador​

Cuando ejecutas la API para registrar un validador, el código crea una entrada en el staking contract:

func (sc *StakingContract) RegisterAPIValidator(address, name, nodeID string, stakeAmount *types.Balance) error {
    validator := &Validator{
        Address:         address,
        Stake:           stakeAmount,
        IsActive:        false, // Se activa cuando se ejecuta físicamente
        TotalFees:       types.NewBalance(0),
        BlocksValidated: 0,
        LastActive:      time.Now(),
    }
    sc.validators[address] = validator
    sc.stakes[address] = stakeAmount
    sc.nodeIDToAddress[nodeID] = address // Mapeo crucial
    return nil
}

Paso 2: Activación Física​

Cuando tu nodo se ejecuta, el staking contract lo reconoce y activa:

func (sc *StakingContract) ActivateValidator(nodeID string) error {
    validatorAddress, err := sc.GetValidatorAddressByNodeID(nodeID)
    if err != nil {
        return err
    }
    validator, exists := sc.validators[validatorAddress]
    if !exists {
        return fmt.Errorf("validator %s not found", validatorAddress)
    }
    validator.IsActive = true
    validator.LastActive = time.Now()
    sc.activeValidators[validatorAddress] = true
    return nil
}

Paso 3: Creación de Delegaciones Pasivas​

Las delegaciones se crean a través del PassiveDelegationManager:

func (pdm *PassiveDelegationManager) CreatePassiveDelegation(
    delegatorAddress, validatorAddress string,
    stakeAmount *types.Balance) (*PassiveDelegation, error) {

    delegationID := fmt.Sprintf("%s_%s_%d", delegatorAddress, validatorAddress, time.Now().Unix())
    delegation := &PassiveDelegation{
        DelegatorAddress: delegatorAddress,
        ValidatorAddress: validatorAddress,
        StakeAmount:      stakeAmount,
        DelegationTime:   time.Now(),
        IsActive:         true,
        RewardsEarned:    types.NewBalance(0),
        LastRewardTime:   time.Now(),
        DelegationID:     delegationID,
    }
    pdm.delegations[delegationID] = delegation
    pdm.updateValidatorSummary(validatorAddress, stakeAmount, true)
    return delegation, nil
}

Recompensas y Economía​

Sistema de Recompensas Dinámicas​

Las recompensas se calculan basadas en el rendimiento y stake:

func (rs *RewardsSystem) CalculateBlockReward(validatorAddress string, blockNumber uint64) *types.Balance {
    baseReward := rs.baseBlockReward
    validatorStake := rs.stakingContract.GetValidatorStake(validatorAddress)
    totalStaked := rs.getTotalStaked()

    // Recompensa proporcional al stake
    stakeRatio := float64(validatorStake.GetAmount().Int64()) / float64(totalStaked.Int64())
    reward := baseReward * stakeRatio

    return types.NewBalance(int64(reward))
}

Distribución de Fees​

Los fees se distribuyen siguiendo una estructura clara:

  • 70% al validador que produjo el bloque
  • 20% al fondo de desarrollo
  • 10% al sistema de quema (burn)

Sistema de Penalizaciones​

Tipos de Penalizaciones​

El sistema implementa penalizaciones automáticas por mal comportamiento:

func (ps *PenaltySystem) ApplyPenalty(validatorAddress string, penaltyType PenaltyType) error {
    penalty := ps.getPenaltyAmount(penaltyType)

    // Aplicar penalización
    validatorStake := ps.stakingContract.GetValidatorStake(validatorAddress)
    newStake := validatorStake.Sub(penalty)

    // Actualizar stake del validador
    ps.stakingContract.UpdateValidatorStake(validatorAddress, newStake)

    // Registrar penalización
    ps.recordPenalty(validatorAddress, penaltyType, penalty)

    return nil
}

Categorías de Penalizaciones​

  1. Minor: Penalizaciones pequeñas por fallos menores
  2. Severe: Penalizaciones moderadas por comportamiento problemático
  3. Critical: Penalizaciones severas que pueden desactivar validadores

Delegaciones Pasivas: Democracia en Acción​

Cómo Funcionan​

Las delegaciones pasivas permiten que usuarios sin nodos participen:

  1. Delegador transfiere KDC a un validador
  2. Sistema registra la delegación en PassiveDelegationManager
  3. Validador incluye al delegador en su pool de producción
  4. Recompensas se distribuyen proporcionalmente

Distribución de Recompensas​

func (pdm *PassiveDelegationManager) DistributeRewards(validatorAddress string, totalReward *types.Balance) error {
    delegations := pdm.GetDelegationsByValidator(validatorAddress)

    for _, delegation := range delegations {
        stakeRatio := float64(delegation.StakeAmount.GetAmount().Int64()) /
                     float64(totalDelegatedStake.GetAmount().Int64())

        delegatorReward := float64(totalReward.GetAmount().Int64()) * stakeRatio
        netReward := delegatorReward * (1 - commissionRate) // Después de comisión

        delegation.RewardsEarned = delegation.RewardsEarned.Add(types.NewBalance(int64(netReward)))
    }
    return nil
}

Gestión de Riesgos​

Límites de Stake​

  • Mínimo por validador: 10 KDC
  • Mínimo por delegación: 1 KDC
  • Máximo por delegación: 100 KDC

Periodos de Seguridad​

  • Activación: 24 horas para validar compromiso
  • Unbonding: 7 días para retirar stake
  • Penalizaciones: Aplicadas automáticamente por el sistema

Monitoreo y Métricas​

Estadísticas del Sistema​

func (sc *StakingContract) GetStakingStats() map[string]interface{} {
    return map[string]interface{}{
        "totalValidators":  len(sc.validators),
        "activeValidators": activeValidators,
        "totalStaked":      totalStaked.GetAmount(),
        "genesisFile":      sc.genesisFile,
    }
}

Métricas por Validador​

Cada validador puede consultar:

  • Stake total y disponible
  • Número de delegaciones
  • Recompensas acumuladas
  • Historial de penalizaciones
  • Tasa de rendimiento

Seguridad del Sistema​

Protección Contra Ataques​

  1. Slashing automático por double-signing
  2. Penalizaciones por inactividad prolongada
  3. Validación criptográfica de todas las operaciones
  4. Límites de stake para prevenir centralización

Recuperación de Fondos​

Los validadores pueden recuperar sus fondos siguiendo el proceso de unbonding, pero deben mantener actividad durante el período para evitar penalizaciones adicionales.

El Futuro del Staking en KodeChain​

El sistema de staking evoluciona constantemente:

  • Delegaciones cruzadas entre cadenas DPoS y PBFT
  • Recompensas dinámicas basadas en rendimiento de red
  • Gobernanza integrada para parámetros del sistema
  • Staking líquido para mayor flexibilidad

Cada línea de código en pkg/staking/ está diseñada para crear un sistema robusto, seguro y eficiente que mantenga la integridad de la red mientras recompensa la participación activa.