Osif ungar

מודול 6 — יישום: SLH בשידור חי

Live Case Study

זמן לימוד: 120 דקות · רמה: Pro · תנאי קדם: מודולים 1-5

המודול האחרון — ואת האמת הכי חשובה

כל 5 המודולים הקודמים היו תיאוריה. במודול הזה אני מראה לך איך SLH מיישמת את זה בפועל, כולל מה שלא עובד עדיין.

אחרי המודול תהיה לך:

הבנה מלאה של אקוסיסטם SLH הפנימי
יכולת לקרוא את /status ולדעת אם המערכת בריאה
תבנית קוד להעתקה למערכת שלך
Checklist סיום + quiz ל-Certificate NFT

1. סקירת ארכיטקטורה SLH

┌──────────────────────────────────────────────────┐
│  Frontend Layer                                   │
│  ─ 43 HTML pages (GitHub Pages)                  │
│  ─ /status.html ← live Coverage Ratio           │
│  ─ /academia.html ← course catalog               │
│  ─ /wallet.html ← user portfolio                 │
└──────────────────────────────────────────────────┘
                      │
┌──────────────────────────────────────────────────┐
│  API Layer — FastAPI on Railway                   │
│  ─ 113 endpoints, /api/* prefix                   │
│  ─ /api/academia/* ← course commerce             │
│  ─ /api/treasury/* ← public treasury data       │
│  ─ /api/yield/* ← dynamic yield calculations    │
│  ─ /api/risk/* ← circuit breaker state          │
└──────────────────────────────────────────────────┘
                      │
┌──────────────────────────────────────────────────┐
│  Bot Layer — 25 Telegram bots                    │
│  ─ @WEWORK_teamviwer_bot ← payments             │
│  ─ @SLH_Academy_bot ← course access             │
│  ─ @SLHGuardianBot ← fraud detection            │
│  ─ ...22 more                                    │
└──────────────────────────────────────────────────┘
                      │
┌──────────────────────────────────────────────────┐
│  Data Layer                                       │
│  ─ PostgreSQL 15 (Railway): ledger, users        │
│  ─ Redis 7: sessions, rate limits                │
│  ─ BSC chain: SLH token + treasury wallet       │
│  ─ TON chain: future treasury wallet             │
└──────────────────────────────────────────────────┘

2. Self-Test: SLH מול Course #1

נעבור על כל שאלה שלימדנו:

Flag 1: APY קבוע?

היסטורית: ❌ כן (48% / 55% / 60% / 65%) אחרי overhaul 2026-04-20: ✅ Dynamic Yield בלבד Evidence: DYNAMIC_YIELD_SPEC_20260420.md

Flag 2: Referral עמוק?

היסטורית: ❌ 10 דרגות אחרי overhaul: ✅ 2 דרגות בלבד (tier1: 20%, tier2: 5%) Evidence: COPY_OVERHAUL_URGENT_20260420.md

Flag 3: Treasury שקוף?

נוכחי: ⚠️ ארנק יחיד, לא רב-שכבתי, לא מתרענן חי ETA לריפוי: 90 ימים (Multi-sig BSC + TON) Evidence: /status.html עם Treasury widget (בבנייה)

Flag 4: ריכוז Supply?

נוכחי: 🔴 Founder מחזיק 98% מ-SLH מדיניות: חתימת vesting schedule 36 חודש + time-lock Evidence: [TBD] — חוזה חכם חדש + audit

Flag 5: CR פומבי?

נוכחי: ❌ לא חי ETA: עדכון הבא ל-/status יוסיף Live CR widget Evidence: פורמולה ב-DYNAMIC_YIELD_SPEC, נדרשת API endpoint

Flag 6: שיווק FOMO?

נוכחי: ❌ “פספסת ביטקוין” קיים ETA ל-fix: COPY_OVERHAUL_URGENT_20260420.md מפרט כל תיקון Evidence: git commit הקרוב

Flag 7: ישות משפטית?

נוכחי: ⚠️ עוסק מורשה (individual), לא חברה ETA: Q1 2026 — רישום חברה בע”מ ישראלית Evidence: [TBD]

ציון SLH: 4/7 passed, 3/7 in progress. זה לא מושלם — אבל זה אמת.

3. הדשבורד הציבורי: `/status.html`

מה יופיע אחרי overhaul:

┌──────────────────────────────────────────────────┐
│  SLH Spark · Live Status                          │
│  2026-04-21 14:32 UTC · Refreshed 2 min ago     │
├──────────────────────────────────────────────────┤
│  ECONOMIC HEALTH                                  │
│  ─ TVL:              $287,500                     │
│  ─ R_t (MTD):         $8,240                      │
│  ─ C_t (MTD):         $3,100                      │
│  ─ Ref_t (MTD):         $820                      │
│  ─ Net_t:             $4,320                      │
│  ─ P_t (distributed): $2,160                      │
│  ─ Implied APY:       9.0%  [past period]        │
│  ─ CR_t:              2.35 ✓ (target ≥ 1.5)      │
│                                                   │
│  TREASURY (Layer 1+2+3)                           │
│  ─ Layer 1:    $22,400  (operating)              │
│  ─ Layer 2:    $95,000  (multi-sig, pending)    │
│  ─ Layer 3:         $0  (not yet)                │
│  ─ Buffer Ratio: 41% ✓ (target ≥ 30%)            │
│                                                   │
│  LIQUIDITY                                        │
│  ─ BSC (PancakeSwap): $1,200 ⚠️ thin            │
│  ─ TON (STON.fi):     [not deployed]            │
│  ─ Fiat reserve:      $8,500                     │
│  ─ Run Threshold:     12% ⚠️ (target ≥ 30%)     │
│                                                   │
│  CIRCUIT BREAKERS                                 │
│  ─ Coverage Guardrail:   ✓ Ready                 │
│  ─ Withdrawal Throttle:  ✓ Ready                 │
│  ─ Deposit Freeze:       ✓ Ready                 │
│  ─ Buffer Recovery:      ✓ Ready                 │
│  ─ Oracle Freeze:        ⚠️ Not yet wired        │
│                                                   │
│  KNOWN ISSUES                                     │
│  ─ JWT_SECRET: empty (blocks launch)             │
│  ─ 22 bots still polling (webhook migration)    │
│  ─ Layer 3 cold storage not yet deployed        │
│  ─ Token ownership not renounced                 │
│                                                   │
│  [Last 12 distributions] [Treasury audit log]   │
└──────────────────────────────────────────────────┘

כל מספר כאן — ניתן לאימות.

TVL מוחזר מ-SELECT SUM(balance) FROM user_stakes WHERE active = true
R_t מצטבר מ-SELECT SUM(amount) FROM revenue_ledger WHERE month = current
CR_t מחושב בצד ה-API כל 60 שניות
Buffer נקרא ישירות מ-BSC RPC (eth_getBalance)

לא דמו. לא mock.

4. Walkthrough: קוד Dynamic Yield בפועל

4.1 הנוסחאות במודל Python

# File: D:/SLH_ECOSYSTEM/api/dynamic_yield.py
from decimal import Decimal
from dataclasses import dataclass

@dataclass
class YieldPeriod:
    U: Decimal      # TVL
    R: Decimal      # Revenue
    C: Decimal      # Costs
    Ref: Decimal    # Referrals
    W: Decimal      # Withdrawals
    B: Decimal      # Buffer
    L: Decimal      # Liquid
    k: Decimal      # Distribution coefficient

def calculate_net(p: YieldPeriod) -> Decimal:
    return max(Decimal(0), p.R - p.C - p.Ref)

def calculate_pool(p: YieldPeriod) -> Decimal:
    net = calculate_net(p)
    return p.k * net

def calculate_user_yield(p: YieldPeriod, user_balance: Decimal) -> Decimal:
    if p.U == 0:
        return Decimal(0)
    pool = calculate_pool(p)
    return (user_balance / p.U) * pool

def calculate_cr(p: YieldPeriod) -> Decimal:
    net = calculate_net(p)
    pool = calculate_pool(p)
    denominator = pool + p.W
    if denominator == 0:
        return Decimal("999")  # effectively infinity
    return (net + p.B) / denominator

def implied_apy(p: YieldPeriod, periods_per_year: int = 12) -> Decimal:
    if p.U == 0:
        return Decimal(0)
    pool = calculate_pool(p)
    return (pool / p.U) * periods_per_year

4.2 Circuit Breakers כקוד

# File: D:/SLH_ECOSYSTEM/api/risk_engine.py
from enum import Enum

class BreakerState(Enum):
    GREEN = "green"
    YELLOW = "yellow"
    ORANGE = "orange"
    RED = "red"
    BLACK = "black"

class RiskEngine:
    def __init__(self, config):
        self.config = config
        self.active_breakers = set()

    def evaluate(self, state):
        self.active_breakers.clear()

        # Breaker 5: Oracle (highest priority)
        oracle_drift = abs(state.price_internal - state.price_oracle) / state.price_oracle
        if oracle_drift > self.config.oracle_threshold:
            self.active_breakers.add("ORACLE_FREEZE")
            return BreakerState.BLACK

        cr = state.calculate_cr()

        # Breaker 3: Deposit Freeze
        if cr < 0.5:
            self.active_breakers.add("DEPOSIT_FREEZE")

        # Breaker 1: Coverage Guardrail
        if cr < 1.0:
            self.active_breakers.add("COVERAGE_GUARDRAIL")

        # Breaker 2: Withdrawal Throttle
        withdrawal_ratio = state.W_24h / state.U
        if withdrawal_ratio > 0.15:
            self.active_breakers.add("WITHDRAWAL_THROTTLE")

        # Breaker 4: Buffer Recovery
        if state.B < 0.10 * state.U:
            self.active_breakers.add("BUFFER_RECOVERY")

        if "DEPOSIT_FREEZE" in self.active_breakers:
            return BreakerState.RED
        if len(self.active_breakers) >= 2:
            return BreakerState.ORANGE
        if len(self.active_breakers) == 1:
            return BreakerState.YELLOW
        return BreakerState.GREEN

    def allow_deposit(self, amount):
        if "DEPOSIT_FREEZE" in self.active_breakers:
            return False, "Deposits frozen — CR below 0.5"
        return True, None

    def allow_withdrawal(self, user, amount):
        if "WITHDRAWAL_THROTTLE" in self.active_breakers:
            daily_limit = 0.01 * user.balance
            if user.withdrawn_today + amount > daily_limit:
                return False, f"Daily throttle limit: ${daily_limit}"
        return True, None

4.3 API Endpoint

# File: D:/SLH_ECOSYSTEM/api/main.py (excerpt)

@app.get("/api/yield/state")
async def get_yield_state():
    """Public endpoint — returns current yield state."""
    period = await load_current_period()
    engine = RiskEngine(config)
    breaker_state = engine.evaluate(period)

    return {
        "timestamp": datetime.utcnow().isoformat(),
        "U": float(period.U),
        "R_mtd": float(period.R),
        "C_mtd": float(period.C),
        "Ref_mtd": float(period.Ref),
        "Net": float(calculate_net(period)),
        "P": float(calculate_pool(period)),
        "CR": float(calculate_cr(period)),
        "APY_implied": float(implied_apy(period)),
        "Buffer": float(period.B),
        "Buffer_ratio": float(period.B / period.U) if period.U > 0 else 0,
        "state": breaker_state.value,
        "active_breakers": list(engine.active_breakers),
    }

5. מה SLH עדיין חסרה (Honest Gaps)

Gap 1: Oracle integration

הפורמולה של Breaker 5 מחייבת השוואה למחיר on-chain. כרגע אין oracle — PancakeSwap נזיל מאוד. פתרון: Chainlink TWAP או self-reported עם multisig.

Gap 2: Layer 3 Treasury

אין cold storage לעת עתה. צריך hardware wallet + 2-of-3 signers מוגדרים + procedure לבדיקה רבעונית.

Gap 3: Insurance fund

אין Insurance Module כמו של Aave. פתרון עתידי: allocation of 10% from R to insurance pool, separate from Buffer.

Gap 4: Decentralized governance

כל שינוי k, thresholds, breakers דורש כרגע החלטה של founder. יעד: SLH holder vote.

Gap 5: Audit חיצוני

הקוד הכלכלי לא עבר audit מקצועי. תקציב נדרש: $20K-$50K. אחרי Course #1 revenue.

6. תבנית להעתקה למערכת שלך

קובץ: D:/SLH_ECOSYSTEM/ops/DYNAMIC_YIELD_TEMPLATE.md

Your Protocol: _______________

Step 1 - Define your variables:
  U (TVL) starting estimate: _______
  R sources: ____________________
  C monthly estimate: _______
  Ref budget %: _______

Step 2 - Set initial config:
  k: _______ (suggested: 0.5)
  Buffer target %: _______ (suggested: 30%)
  CR targets: red < ___ / yellow ___ / green > ___

Step 3 - Implement formulas (copy Python from 4.1 above)

Step 4 - Implement breakers (copy Python from 4.2 above)

Step 5 - Build transparent dashboard

Step 6 - Test with simulator (treasury_simulation.py)

Step 7 - Deploy with migration path for existing users

Step 8 - Publish to status page, link from marketing

7. Quiz — Certificate NFT

ענה על כל 10 השאלות ב-≥80% כדי לקבל Certificate NFT.

מה ההבדל בין Revenue Engine ו-Reward Engine?
כתוב את הנוסחה של CR_t.
מה קורה כש-CR < 0.5?
למה Referral של 10 דרגות הוא דגל אדום?
הגדר Run Threshold.
תן דוגמה של Hybrid System שקוף.
כמה שכבות Treasury מומלצות ומה תפקיד כל אחת?
מה ההבדל בין Buffer ל-Insurance Fund?
למה Oracle Freeze הוא Breaker ברמה הגבוהה ביותר?
מה שלושת הדגלים ש-SLH עדיין לא עוברת במלואם?

הגשה:

שלח את התשובות ל-@SLH_Academy_bot או קישור הגשה. ה-NFT יונפק תוך 48 שעות אחרי ציון עובר.

8. מה הלאה

Course #2 (בתכנון):

Tokenomics Architecture — איך לעצב multi-token economy שלא מתמוטט.

Course #3 (בתכנון):

Smart Contract Safety — audit yourself, common exploits, OpenZeppelin patterns.

Course #4 (בתכנון):

DeFi Regulation & Legal — מה מותר ואסור, איך לבנות פרוטוקול MiCA-compliant.

Community:

הצטרף לקהילת Alumni ב-Telegram: @SLH_Academy_Alumni דיונים, Q&A חודשי עם Osif, עדכוני content.

9. תודה

אם הגעת עד כאן — עשית משהו שרוב האנשים בקריפטו לא עושים: השתמשת במספרים, לא באינטואיציה.

הידע שלמדת כאן הוא ההגנה הטובה ביותר מפני הונאות, גם כאלה שלא קיימות עדיין. תשתמש בו.

ואם SLH עצמה יום אחד לא תעמוד בקריטריונים שלה — ידעת להזהיר. זה הניצחון הגדול של הקורס הזה.

Final Checklist

קראתי 6 מודולים
הרצתי את המחשבון האינטראקטיבי
הרצתי את treasury_simulation.py לפחות בתרחיש אחד
עברתי את הקוויז ב-≥80%
הבנתי את ה-gaps של SLH עצמה
שמרתי את ה-cheatsheet של הנוסחאות
הצטרפתי לקהילת Alumni

הקורס הושלם.

→ בקש Certificate NFT → שתף ב-Twitter → חזור לקטלוג

“First profit, then yield.” — Osif Ungar, 2026-04-20