# מודול 3 — מתמטיקה של Dynamic Yield
**The Formulas**
*זמן לימוד: 75 דקות · רמה: Pro · תנאי קדם: מודולים 1-2*
---
## המטרה של המודול
אחרי המודול הזה תדע:
1. לחשב ידנית Dynamic Yield לכל משתמש במערכת
2. למדוד Coverage Ratio של פרוטוקול (שלך או של אחר)
3. לזהות מתי Circuit Breaker חייב להידלק
4. להשתמש במחשבון האינטראקטיבי לסימולציות מהירות
---
## 1. המשתנים הרשמיים
מכאן ואילך, כשנדבר על מערכת, נשתמש בשפה אחידה:
| סמל | משמעות | יחידה |
|---|---|---|
| `U_t` | TVL: סך מה שמשתמשים הפקידו בזמן t | $ |
| `R_t` | Revenue: כסף חיצוני שנכנס בתקופה t | $ |
| `C_t` | Costs: עלויות תפעול בתקופה t | $ |
| `Ref_t` | Referrals: תשלומי שותפים בתקופה t | $ |
| `W_t` | Withdrawals: משיכות בתקופה t | $ |
| `B_t` | Buffer: כרית ביטחון (treasury) | $ |
| `L_t` | Liquid: נכסים שיכולים להשתחרר ב-24h | $ |
| `k` | מקדם חלוקה (0 ≤ k ≤ 0.7) | ratio |
| `balance_user` | יתרת משתמש בודד | $ |
*הערה על t:* התקופה יכולה להיות יום, שבוע, או חודש. חשוב לקבוע ועקבי. SLH עובד ב-**חודשים קלנדריים** עבור חלוקות, עם מדידות יומיות של CR.
---
## 2. הנוסחה הראשית
### 2.1 Net Revenue Available
```
Net_t = max(0, R_t - C_t - Ref_t)
```
**מה היא עושה:**
לוקחת את ההכנסות, מחסירה עלויות ו-referrals. אם יצא שלילי → 0 (לא צוברים חוב לחלוקה).
**דוגמה מספרית:**
```
R_t = $12,000 (הכנסות מכל המקורות)
C_t = $4,000 (עלויות: שרתים, משכורות, gas)
Ref_t = $1,500 (שילמנו 10% ל-tier 1 affiliates)
Net_t = max(0, 12000 - 4000 - 1500) = $6,500
```
### 2.2 Pool Distribution
```
P_t = k × Net_t
```
**מה היא עושה:**
מחליטה איזה חלק מה-Net יחולק בפועל. השאר נכנס ל-Buffer.
**דוגמה (ממשיך):**
```
k = 0.5 (ברירת מחדל — חצי מתחלק)
P_t = 0.5 × $6,500 = $3,250
```
$3,250 יחולקו לכל ה-stakers. $3,250 נשארו ב-Buffer.
**גבולות:**
- `k ≤ 0.7` — אף פעם לא מחלקים יותר מ-70% (30% מינימום לחיזוק).
- `k` לא עולה אם CR < 1.5 (ראה 2.4).
### 2.3 Yield Per User
```
Yield_user = (balance_user / U_t) × P_t
```
**דוגמה:**
```
U_t = $100,000 (TVL של המערכת)
Alice balance = $2,500
Bob balance = $5,000
Charlie balance = $92,500
Alice yield = (2500 / 100000) × 3250 = $81.25
Bob yield = (5000 / 100000) × 3250 = $162.50
Charlie yield = (92500 / 100000) × 3250 = $3,006.25
Check: 81.25 + 162.50 + 3006.25 = $3,250 ✓
```
### 2.4 Implied APY (מה שהמשתמש רואה)
```
APY_implied = (P_t / U_t) × periods_per_year
```
**דוגמה (חודשי):**
```
P_t = $3,250
U_t = $100,000
periods = 12 (חודשים בשנה)
APY = (3250 / 100000) × 12 = 0.39 = 39%
```
⚠️ **הערה חשובה:**
39% הוא *האקסטרפולציה* של חודש זה. הוא לא תחזית, לא הבטחה.
חודש הבא R_t יכול להיות $4,000 או $24,000. APY יזוז.
---
## 3. Coverage Ratio (המדד הקריטי ביותר)
```
CR_t = (Net_t + B_t) / (P_t + W_t)
```
**מה זה אומר:**
"כמה כסף יש לי, יחסית למה שאני חייב לשלם."
CR = 1.0 — איזון מושלם
CR > 1.5 — בריא
CR = 2.0 — יעד אופטימלי
CR < 1.0 — **אסון. Circuit Breaker חייב לפעול.**
### דוגמה חישובית:
```
Net_t = $6,500
B_t = $25,000 (buffer שנצבר מ-quarters קודמים)
P_t = $3,250
W_t = $8,000 (משיכות שבוצעו החודש)
CR_t = (6500 + 25000) / (3250 + 8000)
= 31500 / 11250
= 2.80
```
CR_t = **2.80** → ירוק. המערכת בריאה.
### מה קורה ב-CR נמוך?
```
Scenario stressed:
R_t = $3,000 (חודש חלש)
C_t = $4,000 (עלויות קבועות)
Ref_t = $500
Net_t = max(0, 3000-4000-500) = $0 (!)
B_t = $25,000
P_t = 0.5 × $0 = $0
W_t = $30,000 (אנשים נבהלו, מושכים)
CR_t = (0 + 25000) / (0 + 30000) = 0.83
```
CR_t = **0.83** → אדום. יופעל Circuit Breaker.
* `k` מופחת אוטומטית ב-20%
* משיכות ב-throttle של 1% / ארנק / יום
* Buffer Recovery Mode: 100% מ-Net הבא → B_t
---
## 4. Run Threshold (מבחן הבהלה)
```
Run_Threshold = L_t / U_t
```
**פירוש:** איזה אחוז מה-TVL יכול לצאת מיידית בלי קריסה.
**דוגמה:**
```
L_t = $40,000 (ב-liquidity: on-chain + fiat reserves)
U_t = $100,000
Run_Threshold = 0.40 = 40%
```
המערכת תומכת במשיכת **עד 40% תוך 24h** בלי נזק מבני.
מעבר לכך — throttling הכרחי.
**כלל אצבע:**
- Run_Threshold ≥ 0.30 → עמיד ברוב ה-runs
- Run_Threshold = 0.10-0.30 → פגיע לבהלות קטנות
- Run_Threshold < 0.10 → Bank run מזיק. חובה להעלות בדחיפות.
---
## 5. תרגול ידני (5 תרחישים)
**תרחיש A — חודש רגיל:**
```
U_t = $500,000
R_t = $35,000
C_t = $12,000
Ref_t = $4,000
W_t = $15,000
B_t = $120,000
k = 0.5
```
חשב: Net_t, P_t, CR_t, APY_implied, Yield למשתמש עם balance $10,000.
פתרון
```
Net_t = 35000 - 12000 - 4000 = $19,000
P_t = 0.5 × 19000 = $9,500
CR_t = (19000 + 120000) / (9500 + 15000) = 139000 / 24500 = 5.67 ✓ ירוק מאוד
APY = (9500 / 500000) × 12 = 22.8%
Yield_user = (10000 / 500000) × 9500 = $190
```
**תרחיש B — רבעון שיא:**
```
U_t = $800,000
R_t = $90,000
C_t = $20,000
Ref_t = $12,000
W_t = $25,000
B_t = $200,000
k = 0.6 (הועלה כי CR גבוה לאורך זמן)
```
פתרון
```
Net_t = 90000 - 20000 - 12000 = $58,000
P_t = 0.6 × 58000 = $34,800
CR_t = (58000 + 200000) / (34800 + 25000) = 258000 / 59800 = 4.31 ✓
APY = (34800 / 800000) × 12 = 52.2%
```
APY גבוה! אבל לא מובטח — זה תוצאה של חודש שיא. אם חודש הבא חלש → 10%.
**תרחיש C — Bear market:**
```
U_t = $400,000
R_t = $8,000
C_t = $11,000
Ref_t = $1,000
W_t = $50,000
B_t = $80,000
k = 0.5
```
פתרון
```
Net_t = max(0, 8000 - 11000 - 1000) = $0
P_t = 0
CR_t = (0 + 80000) / (0 + 50000) = 1.60 ✓ ירוק (רק כי Buffer סופג)
APY = 0%
Yield_user = 0
```
אין חלוקה. אין APY. הכסף בקרן בטוח — Buffer משלם את המשיכות. זה בדיוק מה ש-Dynamic Yield מאפשר: **אפס חלוקה לא שובר את המערכת.**
**תרחיש D — Crisis (mass withdrawal):**
```
U_t = $400,000
R_t = $15,000
C_t = $11,000
Ref_t = $2,000
W_t = $150,000 (38% בהלה!)
B_t = $60,000
L_t = $90,000
k = 0.5
```
פתרון + אכיפת Circuit Breakers
```
Net_t = 15000 - 11000 - 2000 = $2,000
P_t_raw = 0.5 × 2000 = $1,000
CR_t = (2000 + 60000) / (1000 + 150000) = 62000 / 151000 = 0.41 🔴 אדום
Circuit Breakers activated:
[1] CR < 1.0 → k reduced: 0.5 → 0.4
[2] CR < 0.5 → Deposits frozen (withdrawals still allowed)
[3] W_t > 15% of U_t → Throttling: max 1%/wallet/day
[4] B_t < 20% of U_t (60/400 = 15%) → Buffer Recovery: all Net → B
Run_Threshold = L_t / U_t = 90000 / 400000 = 0.225
→ 22.5% משיכות תוך 24h אפשרי. 38% דורש throttling.
→ הבהלה של $150K תצטרך להתפרש על ~17 ימים במקום 1.
No defaults. No cascade failure. MVP passed.
```
**תרחיש E — Recovery:**
```
U_t = $350,000 (אחרי withdrawals)
R_t = $28,000 (השוק חזר)
C_t = $12,000
Ref_t = $3,000
W_t = $5,000
B_t = $45,000
k = 0.4 (מופחת אחרי crisis — מתאושש)
```
פתרון
```
Net_t = 28000 - 12000 - 3000 = $13,000
P_t = 0.4 × 13000 = $5,200
CR_t = (13000 + 45000) / (5200 + 5000) = 58000 / 10200 = 5.69 ✓
APY = (5200 / 350000) × 12 = 17.8%
```
Buffer עדיין נמוך (45K < 15% of TVL = 52K).
אזור Buffer Recovery נמשך → P_t עובר לחיזוק ה-Buffer.
אחרי 2-3 חודשים כאלה → B_t יחזור לרמה בריאה. ואז k יעלה שוב ל-0.5.
---
## 6. המחשבון האינטראקטיבי
פתח את [Dynamic Yield Calculator](/academy/course-1-dynamic-yield/calculator.html) בחלון נוסף.
הזן את המספרים של תרחיש D (Crisis). המחשבון יראה:
- מצב הצבעים של CR
- אילו Circuit Breakers הופעלו
- כמה ימים יידרשו לסיום המשיכות בהתחשב ב-throttling
- גרף Buffer לאורך 12 חודשים הבאים (בהנחה של התאוששות הדרגתית)
**תרגיל:**
שחק עם הפרמטרים. מה המינימום B_t שמחזיק את המערכת ב-Bank run של 50%?
---
## 7. שגיאות נפוצות בחישוב
⚠️ **טעות 1:** לא להכליל את Ref_t ב-Net.
Ref_t הוא תשלום שמוצא מהמערכת. חייב לחסר לפני חלוקה לסטייקרים.
⚠️ **טעות 2:** לכלול הפקדות חדשות ב-R_t.
הפקדות הן **התחייבויות** (אתה חייב להחזיר אותם), לא הכנסות.
⚠️ **טעות 3:** לחשב CR רק על הרבעון הנוכחי.
CR צריך להיבדק **יומית**, עם trailing 30-day window ל-Run Threshold.
⚠️ **טעות 4:** להתעלם מ-Costs (C_t).
Costs כוללות **כל דבר**: infra, payroll, gas, חוץ מ-refunds. חייב להיות ציבורי.
---
## 8. סיכום נוסחאות (Cheatsheet)
```
Net_t = max(0, R_t - C_t - Ref_t)
P_t = k × Net_t [k ≤ 0.7]
Yield_user = (balance_user / U_t) × P_t
APY_implied = (P_t / U_t) × periods_per_year
CR_t = (Net_t + B_t) / (P_t + W_t) [target ≥ 1.5]
Run_Threshold = L_t / U_t [target ≥ 0.30]
Circuit Breakers:
CR < 1.0 → k ×= 0.8, pause new deposits
CR < 0.5 → freeze deposits, withdrawals open
W > 15% U → throttle 1%/wallet/day
B < 10% U → 100% Net → Buffer until B ≥ 15%
```
**הדבקה, שמירה, הדפסה.** זו הליבה של הקורס.
---
## 9. תרגיל סיום מודול
קח את המערכת שלך (או פרוטוקול שאתה עוקב). מלא:
```
U_t = _______
R_t = _______
C_t = _______
Ref_t = _______
W_t = _______
B_t = _______
L_t = _______
k = _______
חשב:
Net_t = _______
P_t = _______
CR_t = _______
Run_Threshold = _______
ירוק/צהוב/אדום? _______
```
שלח תוצאות לקהילת הקורס לדיון.
---
**המודול הבא:** Treasury & Coverage Ratio — איך מגדירים Buffer נכון, איך בונים Multi-layer Treasury, ו-walkthrough חי של Treasury של SLH.
[→ המשך למודול 4: Treasury Engineering (Pro)](/academy/course-1-dynamic-yield/module-4.html)