Saltar al contenido principal

Núcleo de KodeCoin: La Moneda Nativa

En el corazón de KodeChain late KodeCoin (KDC), una moneda nativa diseñada no solo como medio de intercambio, sino como el pilar fundamental que sustenta toda la economía del ecosistema. Esta implementación en kdc/kodecoin.go revela cómo un sistema aparentemente simple de tokens puede convertirse en la base de una economía blockchain completa.

La Estructura Fundamental​

KodeCoin: Más que un Token​

type KodeCoin struct {
    Name        string   `json:"name"`
    Symbol      string   `json:"symbol"`
    Decimals    uint8    `json:"decimals"`
    MaxSupply   *big.Int `json:"maxSupply"`
    TotalSupply *big.Int `json:"totalSupply"`
    Creator     string   `json:"creator"`
    CreatedAt   int64    `json:"createdAt"`
    mutex       sync.RWMutex
}

Esta estructura aparentemente simple contiene la esencia de lo que hace a KDC especial: un token con límites claros, propósito definido y controles estrictos.

Inicialización con Propósito​

func NewKodeCoin() *KodeCoin {
    maxSupply := new(big.Int)
    maxSupply.SetString("50000000000000000000000000", 10) // 50 millones con 18 decimales

    return &KodeCoin{
        Name:        "KodeCoin",
        Symbol:      "KDC",
        Decimals:    18,
        MaxSupply:   maxSupply,
        TotalSupply: big.NewInt(0),
        Creator:     "0x0000000000000000000000000000000000000000",
        CreatedAt:   0,
    }
}

Desde el momento de su creación, KDC establece sus reglas fundamentales: 50 millones de tokens máximo, 18 decimales de precisión, y un compromiso con la escasez controlada.

Gestión de Supply: El Arte del Equilibrio​

Supply Máximo como Promesa​

func (kc *KodeCoin) GetMaxSupply() string {
    kc.mutex.RLock()
    defer kc.mutex.RUnlock()

    // Convertir a millones para legibilidad
    millions := new(big.Int).Div(kc.MaxSupply, big.NewInt(1000000000000000000))
    return fmt.Sprintf("%d millones KDC", millions.Int64())
}

El supply máximo no es solo un número; es una promesa al mercado de que nunca habrá más de 50 millones de KDC. Esta limitación crea escasez artificial en un mundo digital donde la replicación es infinita.

Seguimiento Preciso del Supply Total​

func (kc *KodeCoin) GetTotalSupply() *big.Int {
    kc.mutex.RLock()
    defer kc.mutex.RUnlock()
    return new(big.Int).Set(kc.TotalSupply)
}

Cada token en circulación se cuenta meticulosamente, asegurando que el sistema siempre sepa exactamente cuántos KDC existen.

Supply Restante: La Reserva Disponible​

func (kc *KodeCoin) GetRemainingSupply() *big.Int {
    kc.mutex.RLock()
    defer kc.mutex.RUnlock()

    remaining := new(big.Int).Sub(kc.MaxSupply, kc.TotalSupply)
    if remaining.Sign() < 0 {
        return big.NewInt(0)
    }
    return remaining
}

Esta función calcula cuánto "espacio" queda para nuevos tokens, crucial para decisiones de emisión y validación de transacciones.

Porcentaje de Supply: La Medida del Crecimiento​

func (kc *KodeCoin) GetSupplyPercentage() float64 {
    kc.mutex.RLock()
    defer kc.mutex.RUnlock()

    if kc.MaxSupply.Sign() == 0 {
        return 0
    }

    percentage := new(big.Float).Quo(
        new(big.Float).SetInt(kc.TotalSupply),
        new(big.Float).SetInt(kc.MaxSupply),
    )

    result, _ := percentage.Float64()
    return result * 100
}

Esta métrica permite a los participantes del ecosistema entender en qué fase de crecimiento se encuentra KDC, informando decisiones económicas.

Validación Rigurosa​

Protección Contra la Inflación​

func (kc *KodeCoin) ValidateSupply(amount *big.Int) error {
    kc.mutex.RLock()
    defer kc.mutex.RUnlock()

    newTotal := new(big.Int).Add(kc.TotalSupply, amount)
    if newTotal.Cmp(kc.MaxSupply) > 0 {
        return fmt.Errorf("excede el max supply de %s", kc.GetMaxSupply())
    }
    return nil
}

Antes de cualquier emisión de nuevos tokens, el sistema valida que no se exceda el límite máximo, protegiendo la integridad económica.

Emisión Controlada​

func (kc *KodeCoin) AddToSupply(amount *big.Int) error {
    if err := kc.ValidateSupply(amount); err != nil {
        return err
    }

    kc.mutex.Lock()
    defer kc.mutex.Unlock()

    kc.TotalSupply.Add(kc.TotalSupply, amount)
    return nil
}

Solo después de validación estricta se permite aumentar el supply total, asegurando que cada token emitido sea legítimo.

Información Transparente​

El Libro Abierto de KDC​

func (kc *KodeCoin) GetInfo() map[string]interface{} {
    kc.mutex.RLock()
    defer kc.mutex.RUnlock()

    return map[string]interface{}{
        "name":              kc.Name,
        "symbol":            kc.Symbol,
        "decimals":          kc.Decimals,
        "maxSupply":         kc.MaxSupply.String(),
        "maxSupplyReadable": kc.GetMaxSupply(),
        "totalSupply":       kc.TotalSupply.String(),
        "remainingSupply":   kc.GetRemainingSupply().String(),
        "supplyPercentage":  kc.GetSupplyPercentage(),
        "creator":           kc.Creator,
        "createdAt":         kc.CreatedAt,
    }
}

Esta función proporciona una vista completa del estado de KDC, permitiendo a aplicaciones y usuarios entender completamente el estado económico del sistema.

Propiedades de Diseño​

18 Decimales: Precisión Financiera​

Los 18 decimales permiten divisiones extremadamente precisas, esenciales para aplicaciones financieras donde las fracciones de centavo importan.

Supply Máximo Fijo​

Los 50 millones de KDC representan un compromiso con la deflación controlada, donde el valor se preserva mediante escasez artificial.

Thread-Safety​

El uso de sync.RWMutex asegura que múltiples operaciones puedan leer simultáneamente, mientras que las escrituras se serializan, manteniendo la consistencia en entornos concurrentes.

Inmutabilidad de Propiedades​

Una vez creado, el nombre, símbolo, decimales y supply máximo de KDC no pueden cambiar, proporcionando estabilidad predictible.

El Rol Económico de KDC​

Medio de Intercambio​

KDC facilita todas las transacciones dentro del ecosistema KodeChain, desde pagos por gas hasta recompensas de staking.

Reserva de Valor​

Con supply limitado y crecimiento controlado, KDC sirve como reserva de valor dentro del ecosistema.

Incentivo para Participación​

Los validadores y delegados reciben recompensas en KDC, creando un ciclo virtuoso de participación y valor.

Gobernanza​

Los holders de KDC pueden participar en decisiones que afectan el futuro del protocolo.

Seguridad y Confianza​

Cada operación en KDC está protegida por validaciones estrictas y operaciones atómicas. El sistema no permite estados inválidos: o una transacción se completa completamente, o no se ejecuta en absoluto.

La transparencia total del supply y las operaciones matemáticas precisas construyen confianza en que KDC es exactamente lo que dice ser: una moneda nativa confiable, escasa y útil.

En esencia, KodeCoin no es solo código; es la materialización de principios económicos en software, creando un puente entre la teoría económica y la ejecución técnica perfecta.