Bootstrap Loan

A loan with no upfront collateral. The protocol mints a fresh .qom, stakes it into QNS Staking with a lien, and routes the position's ZAP emissions back to retire the borrower's debt. The loan deleverages whenever the (skim-adjusted) emission yield exceeds the borrow APR — formally $\gamma \;=\; (1-\alpha)\,\bar e\,\bar p / D_0 > r_b$. Under proposed assumptions a tier-1 mint loan retires itself in ≈6 months; the borrower walks away holding the .qom plus residual ZAP at unlock. The closest external analog is Alchemix v3's self-repaying CDP — but Alchemix repays from a generic yield aggregator, not from the collateral's own intrinsic emission stream. All numbers on this page are proposed; final values fixed at official launch.

Things to know before opening a Bootstrap loan

• Your .qom is locked. It stays in QNS Staking until both (a) the loan's debt clears AND (b) the QNS Staking lock duration expires. You can't trade, transfer, or use the .qom elsewhere during that window.
• The deleveraging schedule depends on ZAP/QOM price. The "≈6 months payoff" you'll see below is a base-case assumption. If the ZAP/QOM ratio drops significantly, the loan slows down or stalls; if it stays low past the lock window, the fallback paths kick in.
• A small skim runs on every emission. A proposed 3% of every routed ZAP emission goes to the protocol reserve before the rest applies to your debt. This is baked into the closed-form payoff time as the $\alpha$ term and is the price of using the Bootstrap mechanic.
• Your downside is bounded to losing the .qom. If the loan can't deleverage and the borrower doesn't top up, the contract sells the .qom at TWAP to clear the debt. The reserve absorbs any final shortfall — you never owe more than the value of the .qom itself.

QNS Staking in plain English (read this first if equations scare you)

Bootstrap composes two things: a loan and a staking position. You don't need to understand the math below to grasp the picture — just the staking primitive it leans on.

QNS Staking lets a wallet lock a .qom domain NFT inside a contract for a chosen duration. While locked, the position emits ZAP (the ecosystem reward token) on a deterministic schedule baked into the staking contract:

   ┌──────────────────────────────────────────────────────────────┐
   │                       Q N S   S T A K I N G                    │
   │                                                                │
   │   You own a .qom NFT       Lock it for time T                 │
   │   ┌───────────┐                                                │
   │   │ alice.qom │ ──── stake ───►  ┌──────────────────────┐     │
   │   └───────────┘                  │  Position #N          │     │
   │                                  │  ───────────          │     │
   │      (NFT held by                │  weight w             │     │
   │       staking contract           │  rate r (ZAP/sec)     │     │
   │       until unstake)             │  end time T_end       │     │
   │                                  │  locked ZAP balance   │     │
   │                                  └──────────┬───────────┘     │
   │                                             │                  │
   │            every block, the position earns:                    │
   │                                             ▼                  │
   │            ZAP/sec  =  r  ×  w   (rate × weight multiplier)    │
   │                                                                │
   │            weight w depends on:                                │
   │              • domain character length (shorter = bigger)      │
   │              • lock duration (longer = bigger, up to 2×)       │
   │                                                                │
   │   When you unstake (after lock expires):                       │
   │      ┌───────────┐                                             │
   │      │ alice.qom │ ◄──── back to your wallet                  │
   │      └───────────┘                                             │
   │      + accrued ZAP balance                                     │
   └──────────────────────────────────────────────────────────────┘

Three things to remember about the math symbols below:

• $\bar e$ = ZAP per year your specific position earns. It's just r × w × seconds_per_year.
• $\bar p$ = current ZAP/QOM exchange rate (read from the QomX market). It tells the protocol how much QOM your ZAP emissions are worth.
• $\bar e \,\bar p$ together = your position's annualized cash flow, denominated in QOM. This is the engine that pays back the loan.

The "lien" primitive. QNS Staking has admin hooks setLien(positionId, lienHolder) and clearLien(positionId). A lien marks a position as "spoken for" — the user can't unstake while it's set, and the lien holder gets first dibs on the position's ZAP emissions. Bootstrap uses this to redirect emissions to the lending pool until the debt clears, then releases the lien so the user can take possession of their .qom.

That's it. The borrower sees: "I'll get a .qom, the protocol will silently route my staking yield to repay the loan, and I'll have the .qom free and clear when it's done." The math below is just the time-to-payoff calculation given the specific rate and price assumptions.

The Bootstrap loan flow

Borrower signs one tx: "open a Bootstrap Loan"
   │
   ▼
Lending pool ──── borrows QOM (against itself) ───► QNS Controller
   │                                                     │
   │                                                     │  (mints fresh .qom)
   │                                                     ▼
   │                                          QNS Staking escrow
   │                                          (NFT held by the staking
   │                                           contract; lien held by
   │                                           the lending pool)
   │                                                     │
   │                                                     ▼
   │                                          ZAP emissions accrue at rate ē
   │                                                     │
   │   ◄──── auto-routed via lien ──────────────────────┘
   │   (ZAP sold to QOM at the TWAP, (1−α) applied to debt,
   │    α skim routed to the protocol reserve)
   ▼
Debt principal D(t) decays per the ODE below
   │
   ▼
When D(t) = 0, the lien clears.
You unstake to receive the .qom into your wallet,
plus any post-loan staking rewards continuing to accrue.

Borrower lifecycle — every possible outcome

Two terminal states: ✅ debt clears in finite time and the borrower walks off with both the .qom and any residual ZAP, or ⚠️ the position can't deleverage and the contract sells the .qom at TWAP to cover the debt (with the reserve absorbing any final shortfall — borrower never owes more than the .qom itself). The math below derives exactly when each branch fires; everything reduces to whether γ > r_b.

The math, in one ODE

Let $D(t)$ be the borrower's outstanding QOM debt at time $t$, $r_b$ the Bootstrap APR (proposed flat 6%), $\bar e$ the staked position's average ZAP emission rate (ZAP per year), $\bar p$ the average ZAP/QOM TWAP, and $\alpha$ the deleverage skim (proposed 3%). Each block, interest accrues at $r_b D$ and lien-routed emissions arrive at $(1-\alpha)\,\bar e\,\bar p$ in QOM-equivalent terms. The continuous-time balance is

$$\frac{\mathrm dD}{\mathrm dt} \;=\; r_b\, D(t) \;-\; (1-\alpha)\,\bar e\,\bar p.$$

This is a first-order linear ODE with solution

$$D(t) \;=\; \frac{(1-\alpha)\,\bar e\,\bar p}{r_b} \;+\; \left(D_0 - \frac{(1-\alpha)\,\bar e\,\bar p}{r_b}\right) e^{r_b t}.$$

Setting $D(t^\*) = 0$ and solving for $t^\*$ gives the closed-form time to full deleverage:

$$\boxed{\;t^\* \;=\; \frac{1}{r_b}\,\ln\!\!\left(\dfrac{(1-\alpha)\,\bar e\,\bar p}{(1-\alpha)\,\bar e\,\bar p \;-\; r_b\, D_0}\right)\;}$$

This is finite if and only if the denominator is positive, i.e.

$$(1-\alpha)\,\bar e\,\bar p \;>\; r_b\, D_0 \quad\Longleftrightarrow\quad \gamma \;\equiv\; \frac{(1-\alpha)\,\bar e\,\bar p}{D_0} \;>\; r_b.$$

The dimensionless ratio $\gamma$ is the position's annualized cash-flow yield on debt — if it exceeds the borrow APR, the loan retires itself. Below that threshold, debt grows without bound and the lien remains open until either the borrower tops up or the post-grace fallback engages (see What can leave residual debt).

Plotted: debt trajectory under proposed base assumptions

For a tier-1 Bootstrap loan with $D_0 = 26$ USD, $r_b = 6\%$, $\alpha = 3\%$, and annualized emission cash-flow $(1-\alpha)\,\bar e\,\bar p \approx 52$ USD — the typical 1.5×-multiplier yield on a tier-1 stake — the position deleverages along the curve below.

Bootstrap debt trajectory under proposed base assumptions ($D_0 = 26$ USD, $r_b = 6\%$, cash-flow ratio $\gamma \approx 200\%$). The curve is convex-up because the deleveraging rate is dominated by inflows, not by interest decay — interest is barely a rounding error at this $\gamma$.

Sensitivity grid — time to full deleverage (months)

How does $t^\*$ move with realistic ZAP-price and lock-multiplier scenarios? Each cell is the time in months at which $D(t) = 0$, holding D_0 = \26$,$r_b = 6%$,$\alpha = 3%$.

ZAP price scenario \ stake mult	1.0×	1.25×	1.5× (base)	1.75×	2.0×
−50%	∞	22.4	14.0	10.4	8.4
−25%	12.4	9.6	7.8	6.6	5.7
base	8.5	6.7	5.5	4.7	4.1
+50%	5.5	4.4	3.6	3.1	2.7
+100%	4.1	3.3	2.7	2.3	2.0

Row labels are ZAP-price scenarios as % deviation from the proposed design-point ZAP/QOM ratio (read from the QomX pool TWAP); column labels are QNS Staking lock multipliers. Pricing is QOM-relative throughout — there is no QOM/USD oracle in the system.

The only red cell is the conjunction of two adverse moves: ZAP halves and the borrower locks at the minimum 1.0× multiplier. Even there the position doesn't go to bad debt — it just remains under lien past the lock window, with the post-grace fallback paths (see below) clearing the residual.

Break-even condition

Solving $\gamma > r_b$ for the price-scenario boundary at the proposed $\bar e$, $\alpha$, $r_b$:

$$\bar p_{\min} \;=\; \frac{r_b\, D_0}{(1-\alpha)\,\bar e}.$$

For the base-case tier-1 loan with $r_b = 6\%$, $D_0$ equal to the proposed mint-cost equivalent in QOM, $\alpha = 3\%$, and $\bar e \approx 300$ ZAP/yr at the 1.5× multiplier, the break-even ZAP/QOM ratio is $\bar p_{\min}$ roughly 3% of the design-point ratio — i.e. ZAP would have to lose 97% of its value in QOM terms before the loan stops deleveraging in finite time. This is the structural buffer that makes Bootstrap a low-borrower-stress product: the cash-flow yield on debt is so dominant over the borrow APR that the loan is effectively self-amortizing under any non-catastrophic ZAP/QOM path. (Note: the only ratio that matters is ZAP/QOM read from the QomX pool TWAP — a QOM/USD swing leaves the position unchanged.)

What the borrower experiences

• One transaction. You sign once. The pool borrows QOM to itself, the QNS controller mints a .qom, the contract stakes it into QNS Staking, and the lien is set.
• The .qom sits in the staking escrow during the loan. It is yours economically — name reserved, not transferable, not re-mintable — but custody is the staking contract's until the lien clears.
• No interest in cash. Your debt accrues at $r_b$, but no QOM moves out of your wallet. Repayment comes entirely from the emission stream.
• Loan closes when $D(t) = 0$. The lien clears automatically. Call unstake() on QNS Staking to take possession of the .qom; any post-loan emissions continue to accrue to you.

Why this is a different shape than Aave / Alchemix

Property	Aave/Compound	Alchemix v3 (CDP, self-repaying)	Alchemix SRENS	Forge Bootstrap
Collateral	ERC-20 token	ETH/stETH-class yield asset	Alchemix CDP	A fresh, freshly-staked .qom
Cash flow that services the loan	Borrower's wallet	Generic yield aggregator under the CDP	Borrower's existing CDP yield	Collateral's own intrinsic emissions
Lien primitive at the registry layer	n/a	n/a	n/a	QNS Staking setLien / clearLien hooks
Liquidation trigger	Oracle-priced LTV crossing	Backing-loss only, not market price	Renewal-failure window	Cash-flow shortfall vs. residual debt
Time-to-payoff is deterministic	No (depends on rate path)	Variable (yield-source dependent)	n/a	Yes — closed-form $t^\*$ above

The structural advantage Bootstrap has over Alchemix v3 is that the cash-flow source is the collateral — there is no separate yield aggregator that could under-perform, no MYT-equivalent governance surface, no rebalancing risk. The contract reads QNS Staking emissions and applies them; the schedule is hard-coded into the staking contract's state.

The structural advantage Bootstrap has over Alchemix SRENS is scope: SRENS auto-renews ENS names from a separate Alchemix CDP. Bootstrap originates the loan, stakes the collateral, and serves the loan — all from the collateral's own emission stream — in a single primitive.

What can leave residual debt

If ZAP price falls and emissions track below the modeled schedule over a full lock cycle, a Bootstrap position can finish its lock with debt outstanding. Recovery is layered:

1. The lien stays open. Position not released; emissions continue to route to the pool.
2. .qom as fallback collateral. If continued emissions plus borrower top-up cannot retire the debt, the contract has direct recourse to the .qom itself: unstake → sell at TWAP → apply to debt.
3. Reserve absorption. Any unrecoverable residual is covered by the protocol reserve, not by lenders.

The Bootstrap LTV is sized so that under reasonable model assumptions, emissions cover the debt with cushion. The cushion absorbs ordinary noise; the reserve absorbs tail events.

Total interest paid over the life of the loan. Integrating the ODE solution gives total interest

$$I_{\text{total}} \;=\; r_b \int_0^{t^\*} D(t)\,\mathrm dt \;=\; \frac{r_b\, D_0\, t^\*}{2} + O(r_b^2),$$

i.e. for small $r_b$ the borrower pays approximately half the simple-interest amount over the loan term. Under the proposed parameters ($r_b = 6\%$, $t^\* \approx 0.5$ yr, $D_0 = 26$ USD), $I_{\text{total}} \approx 0.39$ USD — the interest charge is dwarfed by the deleverage skim, which contributes ≈1.56 USD over the life of the loan and is the protocol's actual revenue line on this product.

Implied APY for the borrower's locked emissions. Even with the proposed 3% skim, the borrower retains $1 - \alpha = 97\%$ of every routed ZAP, applied to debt that costs $r_b = 6\%$. The implicit return on locked rewards is therefore the staking multiplier minus a small wedge — ≈98% of the headline yield of the underlying stake. That ratio is the cleanest summary of why Bootstrap is attractive: you get most of the staking yield while having paid no upfront cash, and you keep the .qom at the end.

tip

A loan that, in expectation, costs nothing — and may pay you. That product doesn't exist on Aave because Aave doesn't have QNS Staking's deterministic emission schedule and registry-level lien hooks to compose with. The closest external prior art is Alchemix's self-repaying CDP, which uses generic yield aggregation rather than the collateral's own intrinsic cash flow.