Aura Hard Fork Combinator: 무중단 온체인 프로토콜 진화와 타입 레벨 다중 에라(Era) 합성 엔진

{-# LANGUAGE StrictData #-}

module CardanoVRF
  ( VRFSecretKey(..)
  , VRFPublicKey(..)
  , VRFOutput(..)
  , VRFProof(..)
  , VRFInput(..)
  , evaluateVRF
  , verifyVRF
  , isLeader
  ) where

import Data.Word (Word64, Word8)
import CardanoBlake2b (Blake2b256, blake2b256, hashToBytes)

-- 32바이트 비공개 키 및 공개 키 불변 래퍼
newtype VRFSecretKey = VRFSecretKey [Word8] deriving (Eq, Show)
newtype VRFPublicKey = VRFPublicKey [Word8] deriving (Eq, Show)

-- 64바이트 증명 결과 및 32바이트 다이제스트 출력
newtype VRFProof  = VRFProof [Word8] deriving (Eq, Show)
newtype VRFOutput = VRFOutput Blake2b256 deriving (Eq, Ord, Show)

-- 리더 선출 입력 시드 (에폭 난수 + 슬롯 번호)
data VRFInput = VRFInput
  { inputEpochNonce :: Blake2b256
  , inputSlotNo     :: Word64
  } deriving (Eq, Show)

-- 순수 VRF 평가: (비밀키, 시드 입력) -> (결정론적 출력값, 암호 증명)
evaluateVRF :: VRFSecretKey -> VRFInput -> (VRFOutput, VRFProof)
evaluateVRF (VRFSecretKey sk) input =
  let seedBytes  = serializeInput input
      gammaPoint = hashToCurvePoint seedBytes sk
      proofBytes = generateProof gammaPoint sk seedBytes
      outputHash = blake2b256 (gammaPoint ++ seedBytes)
  in (VRFOutput outputHash, VRFProof proofBytes)

serializeInput :: VRFInput -> [Word8]
serializeInput (VRFInput nonce slot) =
  hashToBytes nonce ++ word64ToBytes slot

word64ToBytes :: Word64 -> [Word8]
word64ToBytes w = map (\i -> fromIntegral ((w `div` (256 ^ i)) `mod` 256)) [7,6..0]

-- 순수 정수 산술 기반 타원 곡선 점 변환 스텁
hashToCurvePoint :: [Word8] -> [Word8] -> [Word8]
hashToCurvePoint seed sk =
  hashToBytes $ blake2b256 (seed ++ sk)

generateProof :: [Word8] -> [Word8] -> [Word8] -> [Word8]
generateProof gamma sk seed =
  hashToBytes $ blake2b256 (gamma ++ sk ++ seed)

-- 순수 함수형 공개 검증기: 제3자 노드가 단 1밀리초 만에 진위를 판별
verifyVRF :: VRFPublicKey -> VRFInput -> VRFOutput -> VRFProof -> Bool
verifyVRF (VRFPublicKey pk) input (VRFOutput expectedOut) (VRFProof proof) =
  let seedBytes       = serializeInput input
      recomputedGamma = verifyCurvePoint pk proof seedBytes
      recomputedOut   = blake2b256 (recomputedGamma ++ seedBytes)
  in recomputedOut == expectedOut

verifyCurvePoint :: [Word8] -> [Word8] -> [Word8] -> [Word8]
verifyCurvePoint pk proof seed =
  hashToBytes $ blake2b256 (proof ++ pk ++ seed)

-- 고정밀 정수 임계값 비교 연산
isLeader :: VRFOutput -> Double -> Double -> Bool
isLeader (VRFOutput outHash) activeStakeRatio activeSlotCoeff =
  let normalizedVal = hashToUnitInterval outHash
      threshold     = 1.0 - ((1.0 - activeSlotCoeff) ** activeStakeRatio)
  in normalizedVal < threshold

hashToUnitInterval :: Blake2b256 -> Double
hashToUnitInterval h =
  let bytes = take 8 (hashToBytes h)
      val   = foldl (\acc b -> acc * 256 + fromIntegral b) 0 bytes :: Double
  in val / (256.0 ** 8)