GRIZK DOCUMENTATION

01Overview

grizk has two halves. The engine scores tokenized equities on Robinhood Chain from public inputs and publishes the scores every block. The pool sells parametric cover priced from those scores and pays automatically when a peril's trigger holds for its window.

Covered perils: P1 depeg, P2 halt, P3 custodian, P4 oracle. Not covered: price. There are no adjusters, no claim forms and no reversals.

02Vocabulary

03Quickstart

npm i -g @grizk/cli
grizk score TSLAx                 # 41 · factors · band 3.2%
grizk quote TSLAx 10000 90d       # $80.00
grizk cover buy TSLAx --notional 10000 --term 90d   # signs, pays USDC

04Install

npm i -g @grizk/cli        # or: npm i @grizk/sdk

Targets Robinhood Chain mainnet; GRIZK_NETWORK=testnet for the test pool.

05Buy a first cover

1. grizk score <asset> — read the score and its factors.
2. grizk quote — see the premium and the formula that produced it.
3. grizk cover buy — sign; premium leaves in USDC; cover is active next block.
4. grizk cover ls — your active covers, expiries and any running breach timers.

06Perils

All covers include all four perils. There is no à la carte.

07Triggers & windows

Recovery inside the window cancels the timer. Timers and cancellations are public events (§25).

08Payout formulas

P1  notional × (0.97 − TWAP_at_trigger)         cap 0.30 × notional
P2  0.50 × notional at day 5; 0.50 at day 20 if unresolved
P3  1.00 × notional
P4  realised loss during window                  cap 0.15 × notional

Payout is in USDC to the wallet holding the cover at trigger. Cover closes on payout.

09Scores

SCORE = 0.30·f1 + 0.20·f2 + 0.20·f3 + 0.15·f4 + 0.15·f5     fᵢ ∈ [0,100]
f1 custodian · f2 liquidity · f3 peg history · f4 oracle · f5 underlying
rounded UP to the nearest integer

Factor inputs and their current values are published per asset per block and retrievable with grizk score --factors.

10Bands & terms

0–20 → 0.6%   21–40 → 1.4%   41–60 → 3.2%   61–80 → 7.5%   81–100 → not offered
term multiplier: 30d ×0.32 · 90d ×1.00 · 180d ×1.85
premium = notional × band% × multiplier × 90/360

11Covers

A cover is (asset, notional, term, holder). It cannot be edited; buy another to extend. It can be cancelled before expiry for a pro-rata refund minus a 10% cancellation fee, except while a breach timer on that asset is running.

12The pool

Two tranches: junior (first loss, 70% of premiums, 30-day exit) and senior (loss after junior, 30% of premiums, 7-day exit). Deposits and withdrawals are on-chain; exits during a running breach timer on any asset are honoured after resolution.

13Caps & solvency

• Per asset: active notional ≤ 12% of pool capital.
• Per custodian: ≤ 25%.
• Solvency floor 1.5×: below it, no new covers.

All three are enforced in the cover contract at purchase.

14Architecture

feeds (price · attestation · halt · secondaries) ──▶ Engine (on-chain scores, breach timers)
                                                        │ score, band
buyer ── buy cover ──▶ CoverContract ◀── caps/solvency ── PoolContract ◀── underwriters
                            │ trigger                       │ pay
                            └──────── payout in USDC ◀──────┘

The engine is a set of contracts and a keeper network that posts factor inputs. No off-chain component can change a score without posting the inputs that produced it.

15Inputs & feeds

Feed operators post a bond and are slashed for provably wrong values.

16Score computation

Each factor is computed by a public function of its inputs (source in the engine repo). Factors are recomputed when inputs change and at least daily. The score history per asset is retained on-chain for 2 years.

17Breach timers

A timer is a per-asset, per-peril on-chain record: start block, condition snapshot, window. Anyone can call poke(asset, peril) to advance or cancel a timer; keepers do so every block. When now − start ≥ window and the condition still holds, poke executes payout.

18Cover contract

Holds active covers per asset. Enforces caps and solvency at purchase, computes payout per peril formula on trigger, and transfers USDC from the pool. Non-upgradeable; parameter changes are deployed as new versions that apply to new covers only.

19Pool contract

Holds tranche balances, accrues premiums, pays covers on instruction from the cover contract, and enforces exit notices. Publishes solvency, exposure per asset and per custodian, and payout history.

20Default registry

Issuers and custodians may post a default notice against themselves; a governance quorum may post one against any custodian with evidence hash. A notice triggers P3 immediately. False notices by quorum members are slashable and reversible only before payout.

21Governance

Weights, bands, windows, caps and feed sets change by vote with 30 days' notice, never for active covers. Emergency power is limited to pausing new cover sales; it cannot pause payouts.

22CLI

23SDK

import { grizk } from "@grizk/sdk";
await grizk.score("TSLAx");                     // { score: 41, factors: {...}, band: 3.2 }
await grizk.quote("TSLAx", 10000, "90d");       // { premium: 80.00, formula: "…" }
await grizk.cover.buy({ asset: "TSLAx", notional: 10000, term: "90d" });
await grizk.timers();                           // running breach timers

24Contract interface

interface IGrizkCover {
  function score(address asset) external view returns (uint8);
  function quote(address asset, uint256 notional, uint32 termDays) external view returns (uint256);
  function buy(address asset, uint256 notional, uint32 termDays) external returns (uint256 coverId);
  function cancel(uint256 coverId) external;
  function poke(address asset, uint8 peril) external;   // advance/cancel/execute timer
}
interface IGrizkPool {
  function deposit(uint8 tranche, uint256 amt) external;
  function requestExit(uint8 tranche, uint256 amt) external;
  function solvency() external view returns (uint256);  // 1e4 = 1.00×
}

25Events

ScoreUpdated(asset, score, factorsHash)
CoverBought(coverId, asset, notional, termDays, premium)
BreachStarted(asset, peril, startBlock, snapshotHash)
BreachCancelled(asset, peril, block)
Paid(asset, peril, covers, totalNotional, totalPaid)
SolvencyUpdated(ratio)

26Errors

27Fees

• Premium: as quoted; no add-ons.
• Cancellation: 10% of unused premium.
• Pool operating share: 8% of premiums for feeds and keepers, published on the board.

28Guide: recompute a premium

1. grizk score TSLAx --factors → f1..f5.
2. Score = 0.30·f1 + 0.20·f2 + 0.20·f3 + 0.15·f4 + 0.15·f5, round up.
3. Band from §10.
4. Premium = notional × band% × term multiplier × 90/360.
5. Compare with grizk quote. If they differ, file it; the engine is wrong or the docs are.

29Guide: underwrite

1. Read the pool and the payout history by peril.
2. Pick a tranche. Junior for yield with first loss; senior for lower, steadier return.
3. grizk underwrite deposit junior 50000.
4. Watch grizk timers; a running P3 timer is the one that matters.
5. Exit with notice: grizk underwrite exit junior 50000; honoured after any running breach resolves.

30Guide: run a feed

Post a bond, register a key, run the feed client for one or more inputs. Values are checked against other operators; provable deviation is slashed. Operators are paid from the pool's operating share.

31Buyer checklist

• Read the factors, not just the score.
• Check whether a breach timer is running before buying; if it is, you can't.
• Match term to how long you'll hold; cancellation costs 10%.
• Keep the asset in the covered wallet.
• Remember: price is not a peril.

32FAQ

Is this insurance?

It is a parametric contract on Robinhood Chain. grizk is not a regulated insurer and this is not a policy.

Can a payout be reversed?

No. Faulty inputs are the feed operator's liability, recovered from their bond.

Can I cover just one peril?

No. All four, always.

What if the pool can't pay?

Caps and the solvency floor exist to prevent it. If a payout exceeds junior, senior pays. If it exceeds both, covers are paid pro-rata and the shortfall is published.

Who sets the score?

A public function of public inputs. Nobody sets it.

33Glossary

band — score→premium range. breach timer — running trigger clock. cover — one parametric contract. factor — one of five score inputs. peril — covered failure. pool — underwriting capital. solvency — capital ÷ notional. tranche — junior or senior. trigger — readable payout condition. window — required duration of trigger.