Overcover

Parametric insurance · settled on contract rules

connecting…

Programmable parametric risk · live on NEAR testnet

Insurance for businesses that cannot afford to wait for a claims process.

Overcover covers one clearly-defined event at a time: a public index reading — rainfall or temperature — meeting a set trigger, in a named city, on a named date. Each product states its own trigger and direction, so the payout follows from contract rules, no adjuster, no queue.

Reading the pool from the contract…

The risk is outside; the cover is inside A field of falling rain lines above a ground line. Under an unbroken arc of protection, a sheltered row of units stands dry. The arc marks where the contract's rules take over. the contract's rules take over here

Outside: the risk, measured by a public index. Inside: the cover, defined in advance and backed by reserved capital. The arc is the set of rules the contract enforces — not a promise on a page.

—

Capital backing policies live

—

Reserved for potential payouts

—

Policies currently in force

—

Settlements already paid out

What Overcover covers, and who it is for

One risk at a time, defined in advance. No underwriting interview, no claim form.

The risk it covers

A named city's public index — rainfall or temperature — meets a trigger defined in the product on an agreed date. That single, objectively measurable event is the whole contract. If it happens, the policy pays. If it does not, it does not — and the premium is retained by the pool.

Because the trigger is a public reading rather than an assessed loss, there is nothing to argue about and no adjuster to wait for.

Who it is for

Operators whose revenue depends on a condition they do not control and cannot wait weeks to settle: growers and agricultural suppliers, event and outdoor operators, logistics and cold-chain routes, and the software agents that run them.

It is a poor fit for a loss that needs assessing after the fact — that is what a traditional policy is for.

Built for institutions, operators and autonomous agents

Capital, terms and settlement are all on the record. Read them before you commit, and verify them without trusting this page.

Capital-backed, not promised

Every payout is reserved at purchase

The moment a policy is bought, its maximum payout is reserved from the pool and can no longer be withdrawn while the policy is live. The contract re-checks reserved ≤ capital after every state change and refuses any transaction that would leave the pool promising more than it holds.

The pool's identity — capital = deposits − withdrawals + premiums + forfeited bonds − payouts — is computed on-chain and shown live below.

Programmable and immutable

Cover is a product, defined before purchase

A product fixes the city, index, trigger, premium rate, payout bounds and capacity cap. Once published it cannot change, so a buyer is never re-priced and there is no discretion at settlement. Any account may underwrite a product with a stake, and any account may provide pool capital — the contract judges the terms, not a committee.

The same catalogue is published machine-readably in products.json, so software can price and buy cover without a human in the loop.

Verifiable, not trusted

Settlement is a rule, and the result is on the record

An index reading is finalised only by a quorum of independent operators who each sign with their own key. Anyone may challenge a reading by posting a bond, and an independent resolver quorum — separate from the operators, and unable to vote twice — decides. The owner cannot set the index or resolve a dispute alone.

Every figure on this page is a direct contract read, reproducible from public JSON-RPC. The security model and its limits are stated in full under What you should know before trusting this.

From buying cover to getting paid

Eight steps. Each is a real contract rule, and the actor who triggers it is named.

  1. 01

    Choose protection

    Pick an available risk product: a city, an index and a trigger level, published in advance.

    youlist_products
  2. 02

    Understand the coverage

    Read the trigger, the premium, the maximum payout, the capacity left and the observation date. These are fixed when the product is published and cannot change afterwards.

    youget_product
  3. 03

    Buy the policy

    Pay the premium the product fixes, with the exact amount attached as the deposit. The payout is reserved from the pool at that moment, so the promise is backed immediately.

    policyholderbuy_cover
  4. 04

    The risk is observed

    An attestor submits the index reading for the agreed date, signed with ed25519. The contract checks the signature, the freshness and a single-use nonce before it accepts the value.

    attestorreport_observation
  5. 05

    The reading can be challenged

    For a short window, anyone may dispute the reading by posting a bond and a counter-value. A reading under dispute cannot settle a policy.

    anyonechallenge_observation
  6. 06

    A dispute is resolved

    The contract owner decides. Upholding the reading forfeits the challenger's bond into the pool; rejecting it nullifies the reading and returns the bond. This step is a human decision — see the disclosures below.

    ownerresolve_dispute
  7. 07

    Eligibility and settlement

    Once the window has passed, the contract compares the validated reading to the trigger. If it meets the trigger the beneficiary is paid; if not, no payout is made. Either way the reservation is released, and this can happen only once.

    anyoneresolve
  8. 08

    The result is verifiable

    The payout, the released reservation and the pool identity are contract state. Every figure on this page can be reproduced from a public RPC endpoint, without trusting the page.

    anyoneget_pool · reconcile

Cover available now

Each card is an immutable risk definition read from the contract. Capacity is a hard cap on the total outstanding payout for that product.

Loading products…

The insurance factory — anyone can add cover

A discovery agent reads a real public weather forecast and prepares a proposal. Anyone — not just the protocol owner — submits it with propose_product. The contract decides whether it qualifies under fixed underwriting rules; a qualifying proposal activates as an immutable product with no owner transaction. Products shown as active are read from the contract, not from this page.

Loading the discovery feed…

Price a policy

A live quote computed by the contract's own quote view — the same number buy_cover would charge for these terms.

—
Premium you pay now—
Payout reserved from the pool—
Premium rate—
Capacity remaining after this policy—
This is a read-only quote. It reads the contract and holds no key. Buying happens in the panel below, where you sign the transaction in your own wallet — this page never sees your private key and never signs for you.

Buy this cover with your own wallet

You sign the transaction in your wallet. Overcover never sees your key, and the premium is fixed by the contract — not by this page.

The signed reading is taken on this date. It must be in the future.
Default: your connected account.

What happens when you press Buy: the page re-reads the contract's own quote and re-checks the destination's deployed module, then your wallet asks you to approve a single buy_cover call with exactly that premium attached, sent to the address shown above. If you decline, nothing happens. If the contract refuses (capacity, bounds, pause), you see the contract's own reason and no policy is created.

An autonomous agent can buy cover too

The same contract, driven by software instead of a person. The agent has its own account and its own key; a human sets hard spending limits in advance. This console evaluates a purchase with the agent's own spending-policy engine, read-only in your browser — or connect a local agent service you run yourself to watch it act.

Agent console

Public mode evaluates a purchase with the same spending-policy engine the agent service runs — read-only, in your browser, with no key and nothing signed. Local mode connects to an agent service you run yourself (see agent/README.md) to watch it decide and buy within limits.

What the agent can do. It can read the contract and call buy_cover. It cannot call any owner-only method, and every purchase is checked against the spending limits before anything is sent. If a limit refuses the purchase, no transaction is created and no funds move. Public mode holds no key and signs nothing; only a local service you run can send a purchase.

Can the pool pay what it has promised?

The pool's job is to honour every policy it has written. These are its figures, read live from the contract.

Capital backing policies

—NEAR

Total capital in the pool. Deposits and premiums, less what has already been paid out.

Reserved for potential payouts

—NEAR

Set aside the moment each policy was bought, so it cannot be withdrawn while the policy is live.

reserved —% of capital free to underwrite —
Reserved for outstanding policies Free capital, available to underwrite new cover
reserved ≤ capital …

Re-checked on-chain after every state change. If it could ever be false the pool would be promising money it does not hold — so the contract refuses the transaction instead.

reconcile …

Every NEAR in the pool is accounted for by an identity computed on-chain, not asserted here.

Reading the contract…

Free capital to underwrite

—

Policies in force

—

Premiums collected

—

Paid to beneficiaries

—

Deposited by providers

—

Withdrawn by providers

—

Capital is what the pool holds. Reserved is the part already promised to live policies and unavailable to withdraw. Free capital is what remains to underwrite new cover. Reconcile checks that capital equals deposits − withdrawals + premiums + forfeited bonds − payouts.

Policies written

Cover in force and cover settled. Payout, premium and status are contract state; nothing is inferred.

Loading policies…

Observations & disputes

Signed index readings. A reading marked challenged was disputed; one marked nullified was rejected and can never settle a policy.

Loading observations…

How this differs from a traditional claim

Not that one is better in every case — they answer different questions. A traditional policy assesses a loss after the fact; Overcover settles a condition defined in advance.

A traditional claim

  • The loss is reported, then assessed by an adjuster.
  • The payout is decided after the event, at someone's discretion.
  • Payment arrives on a queue measured in weeks.
  • The policy wording is long, and its interpretation is contestable.

How Overcover settles

  • The trigger is a public reading, fixed in the product before you buy.
  • Eligibility is a comparison — reading against trigger — not a judgement call.
  • The payout is reserved from capital the pool already holds.
  • Settlement can be replayed and checked by anyone, on-chain.

Defined conditions

The city, index, trigger, premium and payout bounds are published before purchase and cannot change afterwards. There is no re-pricing after the fact.

Reserved payout

The moment a policy is bought, its payout is reserved. The contract refuses any transaction that would leave the pool promising more than it holds.

Bonded, challengeable reading

The attestor's reading is signed and verified on-chain, and anyone may dispute it with a bond. A disputed reading cannot settle a policy.

What you should know before trusting this

  • Testnet only, unaudited. This runs on NEAR testnet with test funds. The contract has not been professionally audited and is not for real money.
  • Single trusted attestor. The index reading is currently signed by one key, not a decentralised oracle. It can be challenged, but the challenge is not yet trustless.
  • The owner resolves disputes. Step 06 is a human decision by the contract owner. The owner has no power to move pool capital, but it does decide disputes.
  • 60-second challenge window. The live demonstration uses a 60-second window; a production deployment would use a longer one.
  • Parametric, not indemnity. A payout follows the reading meeting the trigger. It does not compensate an assessed loss, and a loss that does not meet the trigger is not covered.

Check it for yourself

Everything above is a direct read. Reproduce it, or check it on a block explorer, without trusting this page.

Contract account · NEAR testnet

—

Deployed code hash

—

Attestor · dispute bond · challenge window

—

Pool identity, computed on-chain

—

Data source

Public NEAR testnet JSON-RPC (—), call_function views. No server, no API key.

Reproduce these figures

…

Machine-readable catalogue (for agents)

products.json · schema — every product, the trigger rule, the premium formula and the exact buy_cover call shape, generated from this contract, not written by hand.

Verified links

Sample settlements from the recorded demo

Honest deployment status

What is live, what is not, and what is blocked

The product vision is fixed; its deployment is not yet complete. This ledger separates code that exists from code that is deployed, and names every external authority it depends on. It is updated by hand and does not change without evidence.

Deployment status of each capability. “Live” means verified against the deployed contract on NEAR testnet; it does not mean audited.
CapabilityStatusEvidence
Capital pool, policy purchase, reserved payout, oracle quorum, bonded dispute, deterministic settlement Live · testnet The full lifecycle runs on-chain against the contract this page reads. Every figure on this page is a direct contract read.
SEC-1 legacy migrate() guard (a third party cannot seize the contract) Live · testnet Deployed to contract.ovc-v3-ctl-2f6c4c.testnet (code hash CQR8x1kW…, wasm sha256 a97034e6…), proven 40/40 by npm run verify:controlled-v3. Closing it on the legacy v1 address still needs that account's owner key (see below).
SEC-6/7/9 settlement fixes (release reserved capital on a terminal, no-pay settlement) Built, not deployed This source builds reproducibly to wasm sha256 811e0427…; the live v3 module (a97034e6…) predates it. The code-only, state-preserving redeploy is prepared and reversible but needs the operator signing key. npm run verify:proof reports SOURCE AHEAD OF DEPLOYMENT.
Legacy v1 containment (set_paused) Blocked The legacy address contract.attestor-overcover.testnet is read-only here and buying is refused. Contract-level pausing needs the legacy owner key, which the deployment automation does not hold. See authority recovery.
Human purchase of cover on the hardened module Available · testnet The console signs one buy_cover against the live v3 account with the visitor's own wallet. The human purchase recorded in the project history was made against the legacy module; it is not evidence of a purchase on v3, and a recorded human v3 purchase is still outstanding.
Hardware-attested external observations (TDX adapter) Prototype · not deployed The adapter builds reproducibly and its attestation path is tested, but it is not published. It is optional provenance: it never replaces operator signatures, oracle quorum or disputes.
Independent third-party security audit Not performed No external audit has occurred. The adversarial suites and proofs in the repository are the project's own; they are not a substitute for an audit.

Common questions

Frequently asked questions

Short, direct answers to what operators, agents and reviewers ask first. Everything here is a property of the deployed contract, not a marketing claim.

What exactly does Overcover cover?

A single, publicly measurable event: a named city's rainfall or temperature reading meeting a trigger fixed in the product before you buy, on an agreed date. If the reading meets the trigger the policy pays its reserved payout; if it does not, it pays nothing and the premium is retained by the pool. It is parametric, not indemnity — it does not assess a loss after the fact.

Who is Overcover for?

Operators whose revenue depends on a condition they do not control and cannot wait weeks to settle — growers and agricultural suppliers, event and outdoor operators, logistics and cold-chain routes — and the software agents that run them. It is a poor fit for a loss that needs assessing after the fact.

How is the payout guaranteed?

The moment a policy is bought, its maximum payout is reserved from the pool and cannot be withdrawn while the policy is live. The contract re-checks reserved ≤ capital after every state change and refuses any transaction that would leave the pool promising more than it holds. The pool identity capital = deposits − withdrawals + premiums + forfeited bonds − payouts is computed on-chain and shown live.

How does an autonomous agent buy cover?

The agent has its own NEAR account and key, and a human sets hard spending limits in advance. It reads the same machine-readable catalogue (products.json) a person reads, calls the contract's own quote view, and signs a single buy_cover call — identical to the one a human wallet signs. The public console can evaluate a purchase with the agent's spending-policy engine read-only, but it holds no key and signs nothing.

Who decides the reading, and can it be disputed?

A reading is finalised only by a quorum of independent operators who each sign with their own key; no single operator and not the owner can set the value alone. For a short window anyone may dispute a reading by posting a bond and a counter-value. A quorum of independent resolvers — separate from the operators, and unable to vote twice — decides; the owner cannot resolve a dispute alone.

How is settlement verified?

Settlement is a single comparison, reading against trigger, run once when the challenge window has passed. The payout, the released reservation and the pool identity are all contract state, readable from public JSON-RPC without trusting the page. The console reproduces every figure from a public RPC endpoint, and a failed read is shown as stale or “no data” — never as live.

Which NEAR contract is current, and which is legacy?

The current, hardened contract — the default for new cover — is contract.ovc-v3-ctl-2f6c4c.testnet. The original v1 module lives at contract.attestor-overcover.testnet; it is readable for the record but is not a purchase destination, and the console labels it “Legacy build” and disables buying there. The console decides which is which by reading the deployed code hash, not from a label on the page.

Is this ready for real money?

No. Overcover runs on NEAR testnet with test funds only, and the contract has not been professionally audited. It is a working prototype: the full lifecycle — purchase, oracle quorum, bonded dispute, settlement and pool accounting — runs on-chain, but it is not for real funds yet.

Connect a wallet

A NEAR wallet holds your account and signs transactions. Overcover never sees your key — you approve each action inside the wallet.