Osif ungar

מודול 3 — מתמטיקה של Dynamic Yield

The Formulas

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

המטרה של המודול

אחרי המודול הזה תדע:

לחשב ידנית Dynamic Yield לכל משתמש במערכת
למדוד Coverage Ratio של פרוטוקול (שלך או של אחר)
לזהות מתי Circuit Breaker חייב להידלק
להשתמש במחשבון האינטראקטיבי לסימולציות מהירות

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 בחלון נוסף.

הזן את המספרים של תרחיש 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)