coinrandom 0.1.0__py3-none-any.whl

coinrandom/__init__.py

@@ -0,0 +1,5 @@
+from .light import (
+    random, uniform, randint, choice, choices, sample, shuffle, gauss
+)
+
+__all__ = ["random", "uniform", "randint", "choice", "choices", "sample", "shuffle", "gauss"]

coinrandom/core.py

@@ -0,0 +1,39 @@
+import hashlib
+import os
+import struct
+import time
+
+import requests
+
+BINANCE_TRADES = "https://api.binance.com/api/v3/trades"
+
+
+def fetch_binance_entropy(symbols: list[str], limit: int = 5) -> bytes:
+    raw = bytearray()
+    for symbol in symbols:
+        try:
+            resp = requests.get(
+                BINANCE_TRADES,
+                params={"symbol": symbol, "limit": limit},
+                timeout=3,
+            )
+            for t in resp.json():
+                raw += str(t["price"]).encode()
+                raw += str(t["qty"]).encode()
+                raw += str(t["time"]).encode()
+                raw += str(t["isBuyerMaker"]).encode()
+        except Exception:
+            pass
+    return bytes(raw)
+
+
+def mix_entropy(*sources: bytes) -> bytes:
+    ts = struct.pack(">d", time.time())
+    sys_e = os.urandom(32)
+    combined = b"".join(sources) + ts + sys_e
+    return hashlib.sha512(combined).digest()
+
+
+def bytes_to_float(b: bytes) -> float:
+    val = int.from_bytes(b[:8], "big")
+    return val / (2**64)

coinrandom/functions.py

@@ -0,0 +1,64 @@
+import math
+import secrets
+from typing import Any, MutableSequence, Sequence
+
+from .core import _build_seed
+
+
+def _get_random_bytes(n: int) -> bytes:
+    seed = _build_seed()
+    # seed를 secrets.token_bytes의 추가 entropy로 혼합
+    mixed = bytes(a ^ b for a, b in zip(seed[:n], secrets.token_bytes(n)))
+    return mixed
+
+
+def _random_float() -> float:
+    raw = _get_random_bytes(8)
+    val = int.from_bytes(raw, "big")
+    return val / (2**64)
+
+
+def random() -> float:
+    return _random_float()
+
+
+def uniform(a: float, b: float) -> float:
+    return a + (b - a) * _random_float()
+
+
+def randint(a: int, b: int) -> int:
+    span = b - a + 1
+    raw = _get_random_bytes(8)
+    val = int.from_bytes(raw, "big")
+    return a + (val % span)
+
+
+def choice(seq: Sequence[Any]) -> Any:
+    return seq[randint(0, len(seq) - 1)]
+
+
+def choices(seq: Sequence[Any], k: int = 1) -> list[Any]:
+    return [choice(seq) for _ in range(k)]
+
+
+def sample(seq: Sequence[Any], k: int) -> list[Any]:
+    pool = list(seq)
+    result = []
+    for _ in range(k):
+        idx = randint(0, len(pool) - 1)
+        result.append(pool.pop(idx))
+    return result
+
+
+def shuffle(seq: MutableSequence[Any]) -> None:
+    for i in range(len(seq) - 1, 0, -1):
+        j = randint(0, i)
+        seq[i], seq[j] = seq[j], seq[i]
+
+
+def gauss(mu: float = 0.0, sigma: float = 1.0) -> float:
+    # Box-Muller transform
+    u1 = _random_float()
+    u2 = _random_float()
+    z = math.sqrt(-2 * math.log(u1)) * math.cos(2 * math.pi * u2)
+    return mu + sigma * z

coinrandom/heavy/__init__.py

@@ -0,0 +1,18 @@
+from .engine import HeavyEngine
+
+_engine = HeavyEngine()
+
+random = _engine.random
+uniform = _engine.uniform
+randint = _engine.randint
+choice = _engine.choice
+choices = _engine.choices
+sample = _engine.sample
+shuffle = _engine.shuffle
+gauss = _engine.gauss
+random_with_proof = _engine.random_with_proof
+
+__all__ = [
+    "random", "uniform", "randint", "choice", "choices",
+    "sample", "shuffle", "gauss", "random_with_proof",
+]

coinrandom/heavy/engine.py

@@ -0,0 +1,233 @@
+import hashlib
+import math
+import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime, timezone
+from typing import Any, MutableSequence, Sequence
+
+import requests
+
+from ..core import mix_entropy, bytes_to_float
+from ..proof import RandomProof
+
+HEAVY_SYMBOLS = [
+    "BTCUSDT", "ETHUSDT", "SOLUSDT", "XMRUSDT", "LINKUSDT",
+    "DOGEUSDT", "ATOMUSDT", "MATICUSDT", "AVAXUSDT", "DOTUSDT",
+    "LTCUSDT", "UNIUSDT", "AAVEUSDT", "MKRUSDT", "CRVUSDT",
+]
+
+ARGON2_TIME_COST = 4
+ARGON2_MEMORY_COST = 65536  # 64MB
+ARGON2_PARALLELISM = 2
+ARGON2_HASH_LEN = 64
+
+
+def _fetch_binance(symbols: list[str]) -> tuple[bytes, list[dict]]:
+    raw = bytearray()
+    records = []
+    for symbol in symbols:
+        try:
+            resp = requests.get(
+                "https://api.binance.com/api/v3/trades",
+                params={"symbol": symbol, "limit": 5},
+                timeout=4,
+            )
+            trades = resp.json()
+            for t in trades:
+                raw += str(t["price"]).encode()
+                raw += str(t["qty"]).encode()
+                raw += str(t["time"]).encode()
+                raw += str(t["isBuyerMaker"]).encode()
+            records.append({"exchange": "binance", "symbol": symbol, "count": len(trades)})
+        except Exception:
+            pass
+    return bytes(raw), records
+
+
+def _fetch_upbit(symbols: list[str]) -> tuple[bytes, list[dict]]:
+    raw = bytearray()
+    records = []
+    upbit_map = {
+        "BTCUSDT": "KRW-BTC", "ETHUSDT": "KRW-ETH", "SOLUSDT": "KRW-SOL",
+        "DOGEUSDT": "KRW-DOGE", "LINKUSDT": "KRW-LINK", "DOTUSDT": "KRW-DOT",
+        "AVAXUSDT": "KRW-AVAX", "ATOMUSDT": "KRW-ATOM",
+    }
+    for symbol in symbols:
+        market = upbit_map.get(symbol)
+        if not market:
+            continue
+        try:
+            resp = requests.get(
+                "https://api.upbit.com/v1/trades/ticks",
+                params={"market": market, "count": 5},
+                timeout=4,
+            )
+            trades = resp.json()
+            for t in trades:
+                raw += str(t["trade_price"]).encode()
+                raw += str(t["trade_volume"]).encode()
+                raw += str(t["timestamp"]).encode()
+            records.append({"exchange": "upbit", "symbol": market, "count": len(trades)})
+        except Exception:
+            pass
+    return bytes(raw), records
+
+
+def _fetch_coinbase(symbols: list[str]) -> tuple[bytes, list[dict]]:
+    raw = bytearray()
+    records = []
+    cb_map = {
+        "BTCUSDT": "BTC-USD", "ETHUSDT": "ETH-USD", "SOLUSDT": "SOL-USD",
+        "LINKUSDT": "LINK-USD", "DOGEUSDT": "DOGE-USD", "LTCUSDT": "LTC-USD",
+        "DOTUSDT": "DOT-USD", "AVAXUSDT": "AVAX-USD", "UNIUSDT": "UNI-USD",
+    }
+    for symbol in symbols:
+        product = cb_map.get(symbol)
+        if not product:
+            continue
+        try:
+            resp = requests.get(
+                f"https://api.exchange.coinbase.com/products/{product}/trades",
+                params={"limit": 5},
+                timeout=4,
+            )
+            trades = resp.json()
+            for t in trades:
+                raw += str(t["price"]).encode()
+                raw += str(t["size"]).encode()
+                raw += str(t["time"]).encode()
+            records.append({"exchange": "coinbase", "symbol": product, "count": len(trades)})
+        except Exception:
+            pass
+    return bytes(raw), records
+
+
+_ETH_RPC_ENDPOINTS = [
+    "https://eth.llamarpc.com",
+    "https://rpc.ankr.com/eth",
+    "https://ethereum.publicnode.com",
+    "https://cloudflare-eth.com",
+]
+
+def _fetch_eth_block_hash() -> str:
+    payload = {"jsonrpc": "2.0", "method": "eth_getBlockByNumber", "params": ["latest", False], "id": 1}
+    for endpoint in _ETH_RPC_ENDPOINTS:
+        try:
+            resp = requests.post(endpoint, json=payload, timeout=5)
+            h = resp.json()["result"]["hash"]
+            if h:
+                return h
+        except Exception:
+            continue
+    return ""
+
+
+def _argon2_stretch(data: bytes, salt: bytes) -> bytes:
+    from argon2.low_level import hash_secret_raw, Type
+    return hash_secret_raw(
+        secret=data,
+        salt=salt,
+        time_cost=ARGON2_TIME_COST,
+        memory_cost=ARGON2_MEMORY_COST,
+        parallelism=ARGON2_PARALLELISM,
+        hash_len=ARGON2_HASH_LEN,
+        type=Type.ID,
+    )
+
+
+def _collect_entropy(symbols: list[str]) -> tuple[bytes, list[dict], str]:
+    results = {}
+    with ThreadPoolExecutor(max_workers=3) as ex:
+        futures = {
+            ex.submit(_fetch_binance, symbols): "binance",
+            ex.submit(_fetch_upbit, symbols): "upbit",
+            ex.submit(_fetch_coinbase, symbols): "coinbase",
+        }
+        for f in as_completed(futures):
+            results[futures[f]] = f.result()
+
+    all_raw = b""
+    all_records = []
+    for key in ("binance", "upbit", "coinbase"):
+        raw, records = results.get(key, (b"", []))
+        all_raw += raw
+        all_records.extend(records)
+
+    block_hash = _fetch_eth_block_hash()
+    all_raw += block_hash.encode()
+    return all_raw, all_records, block_hash
+
+
+def _build_heavy_seed(symbols: list[str]) -> tuple[bytes, list[dict], str, str]:
+    raw, records, block_hash = _collect_entropy(symbols)
+    mixed = mix_entropy(raw)
+    salt = os.urandom(16)
+    stretched = _argon2_stretch(mixed, salt)
+    final_hash = hashlib.sha256(stretched).hexdigest()
+    return stretched, records, block_hash, final_hash
+
+
+class HeavyEngine:
+    def __init__(self, symbols: list[str] = HEAVY_SYMBOLS):
+        self.symbols = symbols
+        self._argon2_params = {
+            "time_cost": ARGON2_TIME_COST,
+            "memory_cost_kb": ARGON2_MEMORY_COST,
+            "parallelism": ARGON2_PARALLELISM,
+            "hash_len": ARGON2_HASH_LEN,
+        }
+
+    def _generate(self) -> tuple[bytes, list[dict], str, str]:
+        return _build_heavy_seed(self.symbols)
+
+    def random(self) -> float:
+        seed, _, _, _ = self._generate()
+        return bytes_to_float(seed)
+
+    def uniform(self, a: float, b: float) -> float:
+        return a + (b - a) * self.random()
+
+    def randint(self, a: int, b: int) -> int:
+        span = b - a + 1
+        threshold = (2**64) - (2**64 % span)
+        while True:
+            seed, _, _, _ = self._generate()
+            val = int.from_bytes(seed[:8], "big")
+            if val < threshold:
+                return a + (val % span)
+
+    def choice(self, seq: Sequence[Any]) -> Any:
+        return seq[self.randint(0, len(seq) - 1)]
+
+    def choices(self, seq: Sequence[Any], k: int = 1) -> list[Any]:
+        return [self.choice(seq) for _ in range(k)]
+
+    def sample(self, seq: Sequence[Any], k: int) -> list[Any]:
+        pool = list(seq)
+        result = []
+        for _ in range(k):
+            idx = self.randint(0, len(pool) - 1)
+            result.append(pool.pop(idx))
+        return result
+
+    def shuffle(self, seq: MutableSequence[Any]) -> None:
+        for i in range(len(seq) - 1, 0, -1):
+            j = self.randint(0, i)
+            seq[i], seq[j] = seq[j], seq[i]
+
+    def gauss(self, mu: float = 0.0, sigma: float = 1.0) -> float:
+        u1, u2 = self.random(), self.random()
+        z = math.sqrt(-2 * math.log(u1)) * math.cos(2 * math.pi * u2)
+        return mu + sigma * z
+
+    def random_with_proof(self) -> RandomProof:
+        seed, records, block_hash, final_hash = self._generate()
+        return RandomProof(
+            value=bytes_to_float(seed),
+            timestamp=datetime.now(timezone.utc).isoformat(),
+            exchanges=records,
+            symbols=self.symbols,
+            block_hash=block_hash,
+            argon2_params=self._argon2_params,
+            final_hash=final_hash,
+        )

coinrandom/light/__init__.py

@@ -0,0 +1,12 @@
+from .engine import _engine
+
+random = _engine.random
+uniform = _engine.uniform
+randint = _engine.randint
+choice = _engine.choice
+choices = _engine.choices
+sample = _engine.sample
+shuffle = _engine.shuffle
+gauss = _engine.gauss
+
+__all__ = ["random", "uniform", "randint", "choice", "choices", "sample", "shuffle", "gauss"]

coinrandom/light/engine.py

@@ -0,0 +1,124 @@
+import hashlib
+import math
+import os
+import threading
+import time
+from typing import Any, MutableSequence, Sequence
+
+from argon2.low_level import hash_secret_raw, Type
+
+from ..core import fetch_binance_entropy, mix_entropy
+
+LIGHT_SYMBOLS = ["BTCUSDT", "ETHUSDT", "SOLUSDT"]
+RESEED_CALLS = 1000
+RESEED_SECONDS = 60
+
+ARGON2_TIME_COST = 1
+ARGON2_MEMORY_COST = 8192  # 8MB
+ARGON2_PARALLELISM = 1
+ARGON2_HASH_LEN = 64
+
+
+class HashDRBG:
+    """SHA-512 카운터 기반 결정론적 난수 생성기. stdlib random 미사용."""
+
+    def __init__(self):
+        self._state = b""
+        self._counter = 0
+
+    def seed(self, data: bytes) -> None:
+        self._state = hashlib.sha512(data).digest()
+        self._counter = 0
+
+    def _next_block(self) -> bytes:
+        self._counter += 1
+        return hashlib.sha512(
+            self._state + self._counter.to_bytes(8, "big")
+        ).digest()
+
+    def random(self) -> float:
+        val = int.from_bytes(self._next_block()[:8], "big")
+        return val / (2**64)
+
+    def randint(self, a: int, b: int) -> int:
+        span = b - a + 1
+        threshold = (2**64) - (2**64 % span)
+        while True:
+            val = int.from_bytes(self._next_block()[:8], "big")
+            if val < threshold:
+                return a + (val % span)
+
+
+class LightEngine:
+    def __init__(self):
+        self._rng = HashDRBG()
+        self._lock = threading.Lock()
+        self._call_count = 0
+        self._last_seed_time = 0.0
+        self._seeded = False
+
+    def _maybe_reseed(self) -> None:
+        now = time.time()
+        if (
+            not self._seeded
+            or self._call_count >= RESEED_CALLS
+            or now - self._last_seed_time >= RESEED_SECONDS
+        ):
+            coin = fetch_binance_entropy(LIGHT_SYMBOLS)
+            mixed = mix_entropy(coin)
+            salt = os.urandom(16)
+            stretched = hash_secret_raw(
+                secret=mixed,
+                salt=salt,
+                time_cost=ARGON2_TIME_COST,
+                memory_cost=ARGON2_MEMORY_COST,
+                parallelism=ARGON2_PARALLELISM,
+                hash_len=ARGON2_HASH_LEN,
+                type=Type.ID,
+            )
+            self._rng.seed(stretched)
+            self._call_count = 0
+            self._last_seed_time = now
+            self._seeded = True
+
+    def random(self) -> float:
+        with self._lock:
+            self._maybe_reseed()
+            self._call_count += 1
+            return self._rng.random()
+
+    def uniform(self, a: float, b: float) -> float:
+        return a + (b - a) * self.random()
+
+    def randint(self, a: int, b: int) -> int:
+        with self._lock:
+            self._maybe_reseed()
+            self._call_count += 1
+            return self._rng.randint(a, b)
+
+    def choice(self, seq: Sequence[Any]) -> Any:
+        return seq[self.randint(0, len(seq) - 1)]
+
+    def choices(self, seq: Sequence[Any], k: int = 1) -> list[Any]:
+        return [self.choice(seq) for _ in range(k)]
+
+    def sample(self, seq: Sequence[Any], k: int) -> list[Any]:
+        pool = list(seq)
+        result = []
+        for _ in range(k):
+            idx = self.randint(0, len(pool) - 1)
+            result.append(pool.pop(idx))
+        return result
+
+    def shuffle(self, seq: MutableSequence[Any]) -> None:
+        for i in range(len(seq) - 1, 0, -1):
+            j = self.randint(0, i)
+            seq[i], seq[j] = seq[j], seq[i]
+
+    def gauss(self, mu: float = 0.0, sigma: float = 1.0) -> float:
+        u1, u2 = self.random(), self.random()
+        z = math.sqrt(-2 * math.log(u1)) * math.cos(2 * math.pi * u2)
+        return mu + sigma * z
+
+
+_engine = LightEngine()

coinrandom/proof.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class RandomProof:
+    value: float
+    timestamp: str
+    exchanges: list[dict]
+    symbols: list[str]
+    block_hash: str
+    argon2_params: dict
+    final_hash: str
+
+
+@dataclass
+class SuperProof:
+    value: float
+    timestamp: str
+    exchanges: list[dict]
+    block_hash: str
+    argon2_params: dict
+    candidate_count: int
+    selected_symbols: list[str]
+    correlation_matrix: dict[str, dict[str, float]]
+    optimization_result: dict[str, Any]
+    final_hash: str

coinrandom/superheavy/__init__.py

@@ -0,0 +1,18 @@
+from .engine import SuperHeavyEngine
+
+_engine = SuperHeavyEngine()
+
+random = _engine.random
+uniform = _engine.uniform
+randint = _engine.randint
+choice = _engine.choice
+choices = _engine.choices
+sample = _engine.sample
+shuffle = _engine.shuffle
+gauss = _engine.gauss
+random_with_proof = _engine.random_with_proof
+
+__all__ = [
+    "random", "uniform", "randint", "choice", "choices",
+    "sample", "shuffle", "gauss", "random_with_proof",
+]

coinrandom/superheavy/engine.py

@@ -0,0 +1,90 @@
+import hashlib
+import math
+import os
+from datetime import datetime, timezone
+from typing import Any, MutableSequence, Sequence
+
+from ..core import mix_entropy, bytes_to_float
+from ..heavy.engine import _collect_entropy, _argon2_stretch, ARGON2_TIME_COST, ARGON2_MEMORY_COST, ARGON2_PARALLELISM, ARGON2_HASH_LEN
+from ..proof import SuperProof
+from .optimizer import select_min_correlation_symbols
+
+
+class SuperHeavyEngine:
+    def __init__(self):
+        self._argon2_params = {
+            "time_cost": ARGON2_TIME_COST,
+            "memory_cost_kb": ARGON2_MEMORY_COST,
+            "parallelism": ARGON2_PARALLELISM,
+            "hash_len": ARGON2_HASH_LEN,
+        }
+
+    def _generate(self) -> tuple[bytes, list[str], dict, dict, list[dict], str, str]:
+        # 1단계: 역 포트폴리오 최적화로 최소 상관 코인 선정
+        selected, corr_matrix, opt_result = select_min_correlation_symbols()
+
+        # 2단계: 선정된 코인으로 3거래소 병렬 수집 + ETH 블록 해시
+        raw, records, block_hash = _collect_entropy(selected)
+
+        # 3단계: Argon2 스트레칭
+        mixed = mix_entropy(raw)
+        salt = os.urandom(16)
+        stretched = _argon2_stretch(mixed, salt)
+        final_hash = hashlib.sha256(stretched).hexdigest()
+
+        return stretched, selected, corr_matrix, opt_result, records, block_hash, final_hash
+
+    def random(self) -> float:
+        seed, *_ = self._generate()
+        return bytes_to_float(seed)
+
+    def uniform(self, a: float, b: float) -> float:
+        return a + (b - a) * self.random()
+
+    def randint(self, a: int, b: int) -> int:
+        span = b - a + 1
+        threshold = (2**64) - (2**64 % span)
+        while True:
+            seed, *_ = self._generate()
+            val = int.from_bytes(seed[:8], "big")
+            if val < threshold:
+                return a + (val % span)
+
+    def choice(self, seq: Sequence[Any]) -> Any:
+        return seq[self.randint(0, len(seq) - 1)]
+
+    def choices(self, seq: Sequence[Any], k: int = 1) -> list[Any]:
+        return [self.choice(seq) for _ in range(k)]
+
+    def sample(self, seq: Sequence[Any], k: int) -> list[Any]:
+        pool = list(seq)
+        result = []
+        for _ in range(k):
+            idx = self.randint(0, len(pool) - 1)
+            result.append(pool.pop(idx))
+        return result
+
+    def shuffle(self, seq: MutableSequence[Any]) -> None:
+        for i in range(len(seq) - 1, 0, -1):
+            j = self.randint(0, i)
+            seq[i], seq[j] = seq[j], seq[i]
+
+    def gauss(self, mu: float = 0.0, sigma: float = 1.0) -> float:
+        u1, u2 = self.random(), self.random()
+        z = math.sqrt(-2 * math.log(u1)) * math.cos(2 * math.pi * u2)
+        return mu + sigma * z
+
+    def random_with_proof(self) -> SuperProof:
+        seed, selected, corr_matrix, opt_result, records, block_hash, final_hash = self._generate()
+        return SuperProof(
+            value=bytes_to_float(seed),
+            timestamp=datetime.now(timezone.utc).isoformat(),
+            exchanges=records,
+            block_hash=block_hash,
+            argon2_params=self._argon2_params,
+            candidate_count=len(corr_matrix),
+            selected_symbols=selected,
+            correlation_matrix=corr_matrix,
+            optimization_result=opt_result,
+            final_hash=final_hash,
+        )

coinrandom/superheavy/optimizer.py

@@ -0,0 +1,96 @@
+"""
+역 포트폴리오 최적화로 최소 상관관계 코인 조합을 선정한다.
+Markowitz 최대 분산화 포트폴리오와 동일한 수식:
+    maximize  Σᵢ Σⱼ wᵢwⱼ(1 - ρᵢⱼ)
+    s.t.      Σwᵢ = 1,  wᵢ >= 0
+"""
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import numpy as np
+import requests
+from scipy.optimize import minimize
+
+CANDIDATE_SYMBOLS = [
+    "BTCUSDT", "ETHUSDT", "SOLUSDT", "XMRUSDT", "LINKUSDT",
+    "DOGEUSDT", "ATOMUSDT", "AVAXUSDT", "DOTUSDT", "LTCUSDT",
+    "UNIUSDT", "AAVEUSDT", "MKRUSDT", "CRVUSDT", "MATICUSDT",
+    "INJUSDT", "SUIUSDT", "SEIUSDT", "TIAUSDT", "RENDERUSDT",
+]
+KLINE_URL = "https://api.binance.com/api/v3/klines"
+TOP_N = 8
+
+
+def _fetch_returns(symbol: str, limit: int = 60) -> tuple[str, list[float]]:
+    try:
+        resp = requests.get(
+            KLINE_URL,
+            params={"symbol": symbol, "interval": "1m", "limit": limit},
+            timeout=5,
+        )
+        closes = [float(k[4]) for k in resp.json()]
+        returns = [closes[i] / closes[i - 1] - 1 for i in range(1, len(closes))]
+        return symbol, returns
+    except Exception:
+        return symbol, []
+
+
+def _build_correlation_matrix(symbols: list[str]) -> tuple[np.ndarray, list[str]]:
+    returns_map: dict[str, list[float]] = {}
+
+    with ThreadPoolExecutor(max_workers=10) as ex:
+        futures = {ex.submit(_fetch_returns, s): s for s in symbols}
+        for f in as_completed(futures):
+            sym, rets = f.result()
+            if len(rets) >= 30:
+                returns_map[sym] = rets
+
+    valid = list(returns_map.keys())
+    if len(valid) < 2:
+        return np.eye(len(symbols)), symbols
+
+    min_len = min(len(returns_map[s]) for s in valid)
+    matrix = np.array([returns_map[s][:min_len] for s in valid])
+    corr = np.corrcoef(matrix)
+    return corr, valid
+
+
+def select_min_correlation_symbols(n: int = TOP_N) -> tuple[list[str], dict, dict]:
+    print(f"  [SuperHeavy] 후보 {len(CANDIDATE_SYMBOLS)}개 코인 수익률 데이터 수집 중...", flush=True)
+    corr, valid = _build_correlation_matrix(CANDIDATE_SYMBOLS)
+    print(f"  [SuperHeavy] {len(valid)}개 유효, 상관관계 행렬 완성 → 최적화 시작", flush=True)
+    k = len(valid)
+
+    if k <= n:
+        corr_dict = {valid[i]: {valid[j]: float(corr[i, j]) for j in range(k)} for i in range(k)}
+        return valid, corr_dict, {"method": "all_selected", "n_candidates": k}
+
+    # 목적함수: 음수 → minimize = maximize 분산화
+    def objective(w):
+        return -float(w @ (1 - corr) @ w)
+
+    def jac(w):
+        return -2 * (1 - corr) @ w
+
+    constraints = [{"type": "eq", "fun": lambda w: np.sum(w) - 1}]
+    bounds = [(0, 1)] * k
+    w0 = np.ones(k) / k
+
+    result = minimize(objective, w0, jac=jac, method="SLSQP",
+                      bounds=bounds, constraints=constraints,
+                      options={"ftol": 1e-9, "maxiter": 1000})
+
+    top_idx = np.argsort(result.x)[-n:]
+    selected = [valid[i] for i in top_idx]
+
+    corr_dict = {
+        valid[i]: {valid[j]: round(float(corr[i, j]), 4) for j in range(k)}
+        for i in range(k)
+    }
+    opt_info = {
+        "method": "SLSQP",
+        "n_candidates": k,
+        "success": bool(result.success),
+        "objective_value": float(-result.fun),
+        "weights": {valid[i]: round(float(result.x[i]), 4) for i in range(k)},
+    }
+    return selected, corr_dict, opt_info

coinrandom-0.1.0.dist-info/METADATA

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: coinrandom
+Version: 0.1.0
+Summary: True random numbers sourced from live cryptocurrency market data
+Author-email: dglst <woo9910203626@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/LETUED/coinrandom
+Project-URL: Repository, https://github.com/LETUED/coinrandom
+Project-URL: Bug Tracker, https://github.com/LETUED/coinrandom/issues
+Project-URL: Changelog, https://github.com/LETUED/coinrandom/blob/main/CHANGELOG.md
+Keywords: random,entropy,cryptocurrency,bitcoin,randomness,cryptography,DRBG,verifiable-random,proof
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Requires-Dist: argon2-cffi>=21.0
+Provides-Extra: superheavy
+Requires-Dist: numpy>=1.24; extra == "superheavy"
+Requires-Dist: scipy>=1.10; extra == "superheavy"
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+
+# coinrandom
+
+> True random numbers sourced from live cryptocurrency market data.
+
+```python
+import coinrandom
+
+coinrandom.random()        # 0.7182818...
+coinrandom.randint(1, 100) # 42
+coinrandom.choice(["a", "b", "c"])
+```
+
+---
+
+## Why coinrandom?
+
+Cryptocurrency markets trade 24/7 globally. At the tick level — individual trade prices, quantities, timestamps, and buyer/seller direction — the data is highly unpredictable. The Efficient Market Hypothesis (EMH) says no one can consistently predict short-term market movements. **coinrandom uses this unpredictability as an entropy source.**
+
+### Trust Model
+
+> Even with the full source code published, no one can predict the output in advance — because no one can predict the coin market.
+
+This is an application of **Kerckhoffs's principle**: security depends on the unpredictability of the market, not on keeping the algorithm secret. Each value generated by Heavy/SuperHeavy comes with a `RandomProof` — a verifiable audit trail showing exactly which market data produced the result.
+
+**Honest limits:** coinrandom provides *computational security* (like AES/RSA), not *information-theoretic security* (like Chainlink VRF). The trust model is economic, not mathematical. For cryptographic key generation, use `secrets`. For smart contract RNG, use Chainlink VRF.
+
+---
+
+## Installation
+
+```bash
+pip install coinrandom                     # Light + Heavy
+pip install "coinrandom[superheavy]"       # + SuperHeavy (numpy, scipy)
+```
+
+No API keys. No configuration.
+
+---
+
+## Three Tiers
+
+| Tier | Speed | Entropy source | Proof | Use case |
+|------|-------|---------------|-------|----------|
+| **Light** | ~1ms | Binance tick + Argon2 | No | High-volume generation |
+| **Heavy** | ~2s | 3 exchanges + ETH block hash + Argon2 | Yes | Raffles, NFT mints, DAO votes |
+| **SuperHeavy** | ~30s | Portfolio-optimized coins + Heavy pipeline | Yes | Maximum entropy, auditable |
+
+All tiers return the same API — drop-in replacement for Python's `random` module.
+
+---
+
+## Usage
+
+### Light (default)
+
+```python
+import coinrandom
+
+coinrandom.random()              # float in [0.0, 1.0)
+coinrandom.uniform(1.5, 9.5)
+coinrandom.randint(1, 100)
+coinrandom.choice(["a", "b", "c"])
+coinrandom.choices(["a", "b", "c"], k=5)
+coinrandom.sample(range(100), k=10)
+
+lst = [1, 2, 3, 4, 5]
+coinrandom.shuffle(lst)
+
+coinrandom.gauss(mu=0.0, sigma=1.0)
+```
+
+### Heavy — with proof
+
+```python
+from coinrandom.heavy import HeavyEngine
+
+engine = HeavyEngine()
+value, proof = engine.random_with_proof()
+
+print(value)               # 0.3571428...
+print(proof.exchanges)     # [{"name": "binance", "symbols": [...], ...}, ...]
+print(proof.block_hash)    # "0xabc123..."
+print(proof.final_hash)    # SHA-512 of the combined entropy
+```
+
+### SuperHeavy — portfolio-optimized entropy
+
+```python
+from coinrandom.superheavy import SuperHeavyEngine
+
+engine = SuperHeavyEngine()
+value, proof = engine.random_with_proof()
+
+print(proof.selected_symbols)       # coins selected by inverse portfolio optimization
+print(proof.correlation_matrix)     # correlation matrix of candidates
+print(proof.optimization_result)    # scipy SLSQP result
+```
+
+SuperHeavy runs inverse Markowitz portfolio optimization to select the **least-correlated coins** as entropy sources — maximizing entropy diversity.
+
+---
+
+## Design Principles
+
+1. **No API keys** — works out of the box with `pip install`
+2. **Uniform API** — every tier exposes the same functions as `random`
+3. **No stdlib random** — custom HashDRBG (SHA-512 counter-based), Mersenne Twister not used anywhere
+4. **Open-source safe** — Kerckhoffs's principle: publishing the algorithm doesn't compromise security
+5. **Intentionally heavy** — Heavy/SuperHeavy: each call runs the full entropy pipeline. "Slow = costly to manipulate."
+
+---
+
+## Internals
+
+```
+coinrandom/
+├── __init__.py          # Light tier as default API
+├── core.py              # fetch_binance_entropy, mix_entropy
+├── proof.py             # RandomProof, SuperProof dataclasses
+├── light/               # HashDRBG + Argon2 (t=1, m=8MB) reseed cache
+├── heavy/               # 3 exchanges parallel + ETH block hash + Argon2 (t=4, m=64MB)
+└── superheavy/          # Inverse portfolio optimization → Heavy pipeline
+```
+
+### HashDRBG
+
+Custom SHA-512 counter-based DRBG. No `import random` anywhere in the codebase.
+
+```python
+# Simplified
+state = argon2(mix_entropy(coin_data, os.urandom(32)))
+output = sha512(state + counter)  # per call
+```
+
+### Manipulation resistance
+
+Heavy mode requires simultaneously moving 32+ coins across Binance, Upbit, and Coinbase in the exact direction needed — estimated cost: billions of dollars. SuperHeavy additionally hides the target coins until optimization runs.
+
+---
+
+## Versioning
+
+This project follows [Semantic Versioning](https://semver.org/):
+
+- `PATCH` — bug fixes, internal improvements
+- `MINOR` — new features, backward-compatible
+- `MAJOR` — stable API declaration or breaking changes
+
+Current status: `0.x` (API stabilizing, not yet guaranteed stable)
+
+---
+
+## License
+
+MIT

coinrandom-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+coinrandom/__init__.py,sha256=LUgoF5iMVbVk3XDA_Nc94qnwWabEcD3soj9hLTTilVQ,188
+coinrandom/core.py,sha256=e3zAvT40AhqzG0PT6e7dtZOzg7i5IpIKYUJW1u1AlwA,1030
+coinrandom/functions.py,sha256=u7WQCBuBFxvvcU4iFRUGVfktZpgSt-wK0e9aB_C7G1o,1526
+coinrandom/proof.py,sha256=i_vY4OmVEyfjR7aIR0c7Z-A0bTI1VoZ9MgQacB80Ge4,544
+coinrandom/heavy/__init__.py,sha256=b740x6RKfupmtd2XlmXUsn5sn_U7AumHB5nMHlIGR_U,429
+coinrandom/heavy/engine.py,sha256=zdVYwKMckRM7srlqg5qJyfhSLIlnO0BB4PF0scQI04g,7728
+coinrandom/light/__init__.py,sha256=zDwvMWhZr5ex2cilcRimwgtrj40y55R4txfUfTrq9k0,322
+coinrandom/light/engine.py,sha256=PVg5NAaGlkz3MrzFL6iCxTrhIIYndISqgpfSvG2lfmc,3644
+coinrandom/superheavy/__init__.py,sha256=5AYS52NS4PNqjOZmtt5ylZTngeBA5qnXxqvRkBT-tF8,439
+coinrandom/superheavy/engine.py,sha256=PUHwhKKTDYZsNeeBNwKd_rKzezG0_ZScxhYFd3loXyU,3341
+coinrandom/superheavy/optimizer.py,sha256=InZXN2Tnck-8AIbhcpRlatJaA8M3P8Y1eJluJf47N7s,3418
+coinrandom-0.1.0.dist-info/METADATA,sha256=bv2BhUySZ5PVcDgWRB6Tc4ioDEq-rGIPvuuBBVxG1xY,6582
+coinrandom-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+coinrandom-0.1.0.dist-info/top_level.txt,sha256=twziXgHaTo-ZVJ_fXl3s1Hfk9u3z-TqBPWsiZEIpOnk,11
+coinrandom-0.1.0.dist-info/RECORD,,

coinrandom-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

coinrandom-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+coinrandom