# ZEROBASE Economic Model Overview (HackMD)

This document provides the economic model for ZEROBASE (ZBT) including LaTeX formulas, Python code, and precomputed quarterly buyback figures.

---

## 1. Buyback Model Formulas

1. **Annual Arbitrage Revenue**

$$
R_{ ext{arb}}^{ ext{annual}} = C_{ ext{total}} imes r_{ ext{arb}}
$$

2. **Quarterly Arbitrage Revenue**

$$
R_{ ext{arb}}^{ ext{quarter}} = rac{R_{ ext{arb}}^{ ext{annual}}}{4}
$$

3. **Monthly Sharing Revenue**

$$
R_{ ext{share}}^{ ext{monthly}} = r_{ ext{share}}
$$

4. **Quarterly Protocol Sharing Income**

$$
R_{ ext{share}}^{ ext{protocol, quarter}} = r_{ ext{share}} imes 0.5 imes 3
$$

5. **DAO Buyback Funds**

$$
B_{ ext{DAO}} = igl(R_{ ext{arb}}^{ ext{quarter}} + R_{ ext{share}}^{ ext{protocol, quarter}}igr) imes 0.8
$$

6. **Quarterly Buyback Amount**

$$
Q_{ ext{buy}} = B_{ ext{DAO}}
$$

---

## 2. Precomputed Quarterly Buyback Table

Below are the quarterly buyback amounts (USD) for combinations of total arbitrage funds (C\_total) and monthly sharing revenue (r\_share):

| C\_total (USD) | r\_share\_monthly (USD) | Quarterly Buyback (USD) |
| -------------: | ----------------------: | ----------------------: |
| 50,000,000 | 20,000 | 510,000 |
| 50,000,000 | 100,000 | 750,000 |
| 50,000,000 | 200,000 | 1,110,000 |
| 200,000,000 | 20,000 | 2,010,000 |
| 200,000,000 | 100,000 | 2,250,000 |
| 200,000,000 | 200,000 | 2,610,000 |
| 500,000,000 | 20,000 | 5,010,000 |
| 500,000,000 | 100,000 | 5,250,000 |
| 500,000,000 | 200,000 | 5,610,000 |

*This table by running the following Python code block and printing the pivot table.*

import numpy as np
import pandas as pd
C_totals = [50_000_000, 200_000_000, 500_000_000]
r_arb = 0.05
r_shares = [20_000, 100_000, 200_000]
data = []
for C in C_totals:
    for r_share in r_shares:
        rev_arb_q = C * r_arb / 4
        rev_share_q = r_share * 0.5 * 3
        buyback = (rev_arb_q + rev_share_q) * 0.8
        data.append({'C_total (USD)': C, 'r_share_monthly (USD)': r_share, 'Quarterly Buyback (USD)': buyback})
df = pd.DataFrame(data)
df.pivot(index='C_total (USD)', columns='r_share_monthly (USD)', values='Quarterly Buyback (USD)')

---

## 3. 3D Surface Plot

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

C_vals = np.linspace(50e6, 500e6, 50)
R_vals = np.linspace(20_000, 200_000, 50)
C_grid, R_grid = np.meshgrid(C_vals, R_vals)
Z = ((C_grid * r_arb / 4) + (R_grid * 0.5 * 3)) * 0.8

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(C_grid, R_grid, Z)
ax.set_xlabel('C_total (USD)')
ax.set_ylabel('r_share_monthly (USD)')
ax.set_zlabel('Quarterly Buyback (USD)')
fig.savefig('quarterly_buyback_surface.png', dpi=150)
plt.show()

> **Note on Monotonicity**:
> The 3D surface appears strictly increasing because the buyback formula is a linear combination of `$C_{total}`\$ and `$r_{share}`\$. As either input increases, `$Q_{buy}`\$ increases proportionally, resulting in a planar surface without curvature.
>
> To enhance interpretability, consider:
>
> 1. **Log scales**: e.g., `ax.set_xscale('log')` and/or `ax.set_zscale('log')` to reveal differences at smaller values.
> 2. **Relative metrics**: Plot deviations or percentage changes from a baseline scenario.
> 3. **Non-linear structures**: Incorporate tiered fees or caps to introduce curvature and concave/convex regions.
---

## 4. Deposit Incentive Example (Binance Booster)

**Given:**

* FDV = \$300,000,000 → Price \$P=0.3\$ USD/ZBT
* Annual yield \$r=0.18\$
* Target tokens = 5,000,000 ZBT

**Required deposit \$X\$:**

$$
X imes r = P imes 5,000,000
$$

$$
X = rac{0.3 imes 5,000,000}{0.18} pprox 8,333,333 ext{ USD}
$$

**Protocol revenue:**

$$
ext{Revenue} = X imes r = 8,333,333 imes 0.18 pprox 1,500,000 ext{ USD}
$$

---

## 5. One-Month Deposit Scenario

* Monthly rate = 1.5% (0.18/12)
* Price = 0.3 USD/ZBT
* Target tokens = 5,000,000 ZBT

$$
X_{1m} imes 0.015 = 0.3 imes 5,000,000
$$

$$
X_{1m} = rac{0.3 imes 5,000,000}{0.015} = 100,000,000 ext{ USD}
$$

$$
ext{Revenue}_{1m} = X_{1m} imes 0.015 = 1,500,000 ext{ USD}
$$

# ZBT Price Support Simulation for HackMD

Below are the **key parameters** and the **daily-resolution simulation script** for ZBT price‐support under a dip‐buy strategy. Reference [ZEROBAE Token Release Rules](https://docs.google.com/document/d/1X8aSlFRwWRcgb1c9iZ3IBbNr2EHRWo6D/edit?usp=sharing&ouid=114510789265643554619&rtpof=true&sd=true)

---

## Parameters and Design Rationale

| Parameter | Value / Formula | Reasoning |
|---------------------------|--------------------------------------------------------------|---------------------------------------------------------------------------------------------|
| **Simulation horizon** | 60 months → ~1,800 trading days | Covers the full vesting period and quarterly buyback cycles. |
| **Time step (dt)** | 1/252 (one trading day) | Typical trading-year convention for GBM. |
| **Drift (μ)** | 0.0 (0% daily) | Neutral assumption—no long‐term price drift. |
| **Volatility (σ)** | 0.02 daily (~32% annualized) | Matches typical crypto volatility; adds realistic random price fluctuations. |
| **Initial price (P₀)** | 8,040,000 USD / 105,000,000 ZBT ≈ \$0.0766 | Derived from initial market cap and circulating supply. |
| **Monthly release → Daily**| Use your 60‐month release schedule ÷ 30 days | Splits token issuance evenly per day for smooth supply input. |
| **Quarterly budgets (USD)**| 600 k / 1.5 M / 3 M | Reflects DAO buyback funds at three protocol‐revenue tiers. |
| **Tranche size** | \$50,000 per dip‐buy | Matches observed max depth per side within 2% slippage across exchanges. |
| **Dip threshold** | 5% (price falls 5% below rolling max) | Captures meaningful short‐term dips without over‐reacting to noise. |
| **Slippage cap** | 2% per tranche | Aligns with real market depth constraints (2% max per \$50k tranche). |
| **Max tranches/quarter** | 100 | Limits execution frequency and ensures budget pacing across quarter. |
| **Quarterly reset** | Every 63 trading days | Approximate quarter length to reset rolling max and budget counters. |

---

## Full Python Script (Daily GBM + Dip‐Buy)

import numpy as np
import matplotlib.pyplot as plt

#  Simulation time frame: daily for 60 months (~1800 trading days)
days = 60 * 30  # approximate
\#  GBM parameters
dt = 1/252               # one trading day
mu = 0.0                # daily drift
sigma = 0.02            # daily volatility (~32% annualized)

#  Initial conditions
P0 = 8_040_000 / 105_000_000  # ~$0.0766 USD/ZBT

#  Build daily issuance schedule (tokens/day)
# Replace placeholder list with your 60 monthly totals
monthly_release_tokens = [
    # e.g. 0, 0, ..., up to 60 values
]
daily_release = np.repeat(np.array(monthly_release_tokens) / 30, 30)[:days]

#  Buyback strategy parameters
quarterly_budgets = [600_000, 1_500_000, 3_000_000]  # USD per quarter
tranche_usd = 50_000     # USD per dip-buy tranche
dip_thresh = 0.05        # 5% dip trigger
slippage_cap = 0.02      # 2% max price change per tranche
max_tranches = 100       # per quarter maximum

#  Run one simulation
def run_simulation(Q_budget):
    prices = np.zeros(days)
    prices[0] = P0
    rolling_max = P0
    budget_remain = Q_budget
    tranches_used = 0
    day_in_quarter = 0

    for t in range(1, days):
        # GBM price step
        z = np.random.normal()
        prices[t] = prices[t-1] * np.exp((mu - 0.5*sigma**2)*dt + sigma*np.sqrt(dt)*z)
        rolling_max = max(rolling_max, prices[t])
        day_in_quarter += 1

        # Dip-buy execution
        if (prices[t] <= rolling_max * (1 - dip_thresh)
            and budget_remain >= tranche_usd
            and tranches_used < max_tranches):
            # enforce slippage cap
            buy_price = min(prices[t], prices[t-1] * (1 + slippage_cap))
            budget_remain -= tranche_usd
            tranches_used += 1
            # (optional) record tokens bought: tranche_usd / buy_price

        # Reset at quarter end
        if day_in_quarter >= 63:
            day_in_quarter = 0
            rolling_max = prices[t]
            budget_remain = Q_budget
            tranches_used = 0

    return prices

#  Plot multiple scenarios
def plot_simulations():
    plt.figure(figsize=(10, 6))
    for Q in quarterly_budgets:
        path = run_simulation(Q)
        plt.plot(path, label=f'${Q:,}/quarter')
    plt.xlabel('Trading Days')
    plt.ylabel('Simulated Price (USD)')
    plt.title('ZBT Price Support: Daily GBM + Dip-Buy')
    plt.legend()
    plt.grid(True)
    plt.show()

# Execute
def main():
    plot_simulations()

if __name__ == '__main__':
    main()

---

Readers can then execute the script interactively, customize the `monthly_release_tokens`, and observe how different buyback budgets affect ZBT’s theoretical support price.

*Copy the above content into HackMD; it fully supports MathJax, tables, and fenced code blocks.*