CriptoSensor: Emissão Lastreada e Distribuição Proporcional — Algoritmos e Código

import math

def calc_ema(receitas: list[float], n_janela: int) -> list[float]:
    """Calcula a Média Móvel Exponencial (EMA) sobre uma série de receitas."""
    alpha = 2.0 / (n_janela + 1)
    ema = [receitas[0]]
    for r in receitas[1:]:
        ema.append(alpha * r + (1 - alpha) * ema[-1])
    return ema


def fator_decaimento(epoch: int, lambd: float = 0.005) -> float:
    """Retorna o fator de decaimento D(t) = e^(-λ·t)."""
    return math.exp(-lambd * epoch)


def tokens_do_epoch(
    ema_t: float,
    taxa_incentivo: float,
    preco_ref: float,
    epoch: int,
    lambd: float = 0.005,
) -> float:
    """
    Calcula quantos tokens são emitidos em um epoch.

    ReceitaElegível = EMA_t × taxa_incentivo × D(t)
    TokensDoEpoch   = ReceitaElegível / PreçoDeReferência
    """
    d_t = fator_decaimento(epoch, lambd)
    receita_elegivel = ema_t * taxa_incentivo * d_t
    return receita_elegivel / preco_ref


# --- Exemplo numérico ---
receitas_confirmadas = [
    1000, 1200, 900, 1500, 1100,
    1300, 1400, 1250, 1600, 1350,
]

N_JANELA = 5          # janela da EMA em epochs
TAXA_INCENTIVO = 0.20 # 20 % da receita vai para tokens
PRECO_REF = 0.50      # 1 token = 0,50 unidade monetária
LAMBDA = 0.005        # decaimento suave

emas = calc_ema(receitas_confirmadas, N_JANELA)

print(f"{'Epoch':>5} {'Receita':>10} {'EMA':>10} {'D(t)':>8} {'Tokens':>10}")
print("-" * 48)
for t, (r, e) in enumerate(zip(receitas_confirmadas, emas)):
    tokens = tokens_do_epoch(e, TAXA_INCENTIVO, PRECO_REF, t, LAMBDA)
    d_t = fator_decaimento(t, LAMBDA)
    print(f"{t:>5} {r:>10.2f} {e:>10.2f} {d_t:>8.4f} {tokens:>10.4f}")

def twap(precos: list[tuple[float, float]]) -> float:
    """
    Calcula o TWAP a partir de uma lista de (preço, duração_segundos).

    P_twap = Σ(p_i × Δt_i) / Σ(Δt_i)
    """
    soma_ponderada = sum(p * dt for p, dt in precos)
    soma_tempo = sum(dt for _, dt in precos)
    return soma_ponderada / soma_tempo


# Exemplo: preços observados em intervalos de tempo
observacoes = [
    (0.48, 3600),   # 0,48 por 1 hora
    (0.50, 7200),   # 0,50 por 2 horas
    (0.52, 1800),   # 0,52 por 30 min
    (0.49, 5400),   # 0,49 por 1,5 horas
]

preco_twap = twap(observacoes)
print(f"TWAP calculado: {preco_twap:.4f}")
# TWAP calculado: 0.4950

from dataclasses import dataclass


@dataclass
class Sensor:
    id: str
    score: float
    valido: bool = True  # False se penalizado


@dataclass
class NoDeBorda:
    id: str
    score: float


def distribuir_tokens(
    tokens_epoch: float,
    sensores: list[Sensor],
    nos_borda: list[NoDeBorda],
    frac_sensores: float = 0.70,
    frac_borda: float = 0.30,
) -> dict[str, float]:
    """
    Distribui os tokens do epoch proporcionalmente ao score.

    - 70 % do pool para sensores válidos
    - 30 % para nós de borda
    """
    pool_sensores = tokens_epoch * frac_sensores
    pool_borda = tokens_epoch * frac_borda

    # Filtra apenas sensores com score válido (anti-farming)
    sensores_validos = [s for s in sensores if s.valido and s.score > 0]
    s_total = sum(s.score for s in sensores_validos)

    distribuicao: dict[str, float] = {}

    # Distribuição para sensores
    for s in sensores_validos:
        fracao = s.score / s_total if s_total > 0 else 0
        distribuicao[f"sensor:{s.id}"] = pool_sensores * fracao

    # Distribuição para nós de borda
    b_total = sum(n.score for n in nos_borda)
    for n in nos_borda:
        fracao = n.score / b_total if b_total > 0 else 0
        distribuicao[f"borda:{n.id}"] = pool_borda * fracao

    return distribuicao


# --- Exemplo completo de um epoch ---
tokens_epoch = 500.0  # tokens calculados pela emissão lastreada

sensores = [
    Sensor(id="temp-001", score=120),
    Sensor(id="umid-002", score=95),
    Sensor(id="press-003", score=60),
    Sensor(id="spam-004", score=200, valido=False),  # penalizado!
]

nos_borda = [
    NoDeBorda(id="edge-A", score=80),
    NoDeBorda(id="edge-B", score=45),
]

resultado = distribuir_tokens(tokens_epoch, sensores, nos_borda)

print(f"\nTokens do Epoch: {tokens_epoch:.2f}")
print(f"Pool sensores (70%): {tokens_epoch * 0.70:.2f}")
print(f"Pool borda    (30%): {tokens_epoch * 0.30:.2f}")
print()
print(f"{'Participante':<20} {'Tokens':>10}")
print("-" * 32)
total = 0.0
for participante, tokens in sorted(resultado.items()):
    print(f"{participante:<20} {tokens:>10.4f}")
    total += tokens
print("-" * 32)
print(f"{'TOTAL':<20} {total:>10.4f}")

def simular_epochs(
    receitas: list[float],
    sensores_por_epoch: list[list[Sensor]],
    nos_borda: list[NoDeBorda],
    n_janela: int = 5,
    taxa_incentivo: float = 0.20,
    preco_ref: float = 0.50,
    lambd: float = 0.005,
):
    """Simula a emissão e distribuição ao longo de vários epochs."""
    emas = calc_ema(receitas, n_janela)

    print(f"\n{'='*60}")
    print(f"  SIMULAÇÃO INTEGRADA — {len(receitas)} EPOCHS")
    print(f"{'='*60}\n")

    acumulado: dict[str, float] = {}

    for t in range(len(receitas)):
        tk_epoch = tokens_do_epoch(emas[t], taxa_incentivo, preco_ref, t, lambd)
        dist = distribuir_tokens(tk_epoch, sensores_por_epoch[t], nos_borda)

        print(f"--- Epoch {t} | Receita: {receitas[t]:.0f} | "
              f"EMA: {emas[t]:.2f} | Tokens: {tk_epoch:.2f} ---")

        for k, v in dist.items():
            acumulado[k] = acumulado.get(k, 0) + v
            print(f"  {k}: +{v:.4f}")
        print()

    print(f"{'='*60}")
    print("  ACUMULADO TOTAL")
    print(f"{'='*60}")
    for k, v in sorted(acumulado.items()):
        print(f"  {k}: {v:.4f}")