OptoPuts

OptoPuts is a mini options desk for ETH, built around one question: "what would it take for a person to buy protection on their crypto the way they buy insurance on anything else ?". Today that requires reading an options chain, understanding implied volatility, and trusting a centralized venue. OptoPuts replaces all three. You state what you want: "protect my ETH below $1,770 for the next week. I am afraid of Trump tweeting something". A Claude agent understands the request and tells you how to protect yourself against this scenario, what would this position pay, where it breaks even, what the worst case costs, and why the current market makes it cheap or expensive right now. Every number it states comes from mathematical tools we built and can only call, never from the model itself, so nothing in the explanation is invented.

Accepting a quote mints the contract itself as a token on Hedera, held in a wallet, transferable to anyone before expiry, with whoever holds it at the end receiving the payout. The desk that sold it can only sell what it has already set aside the worst case for, so every open position is fully collateralized by construction, and a refused quote means that the treasury could not cover it. Expiry needs no one's cooperation, settlement is set the moment the trade happens and pays out on its own.

The result is an options desk with an unusual property for either world it borrows from. Unlike a traditional desk, you do not have to trust it, the prices are checkable, the books are public, the collateral is provable, and the payout is automatic. Unlike most DeFi, you do not have to already be an expert to use it, the interface is a conversation, and the explanation comes before the trade.

The math :

The pricing core is Black-Scholes with closed-form Greeks. Volatility is realized, annualized from hourly log returns over 24-hour, 7-day and 30-day windows. The three window estimates are fitted into a term structure interpolated linearly in variance-time, and clamped flat outside the observed range. Each quote draws its sigma (volatility) from that curve at its own time to maturity (exipry). A regime classifier places today's 7-day vol as a percentile within its trailing 30-day distribution and labels it calm, elevated or stressed. Strategies are defined as moneyness templates that resolve into explicit legs at current spot. All this was done using Python.

The backend, and what the partners gave us:

A Python service holds three things: the pricing engine, a small client that fetches and caches data from The Graph, and the agent loop. The agent is Claude Sonnet 5 through the Anthropic SDK, streaming its answers and calling tools as it goes.

Hedera gave us all three settlement pieces as built-in services, no smart contract needed. HTS mints each option series as a token. HCS records every event in a public log. A Scheduled Transaction locks in settlement at the moment of the trade. One catch: a Scheduled Transaction fixes its transfer amount when it is created, but the payout is only known at expiry. So we split settlement in two. The schedule holds a tiny symbolic transfer, with the maximum payout written in its memo, and stands as the public promise to pay. The actual money moves at expiry through a payment endpoint that can never pay the same contract twice, triggered by a background job that checks for expired contracts every few seconds. Before any mint, the desk checks its own treasury balance and refuses to sell anything it could not pay out in the worst case. If that check cannot run, the desk refuses to sell at all.

The Graph is the project's entire market-data layer: hourly candles and live spot from the official Uniswap v3 mainnet subgraph, plus the USDC variable borrow rate from the Aave v3 subgraph .

Tech stack :

React 19/TypeScript/Vite frontend talking to a Python/FastAPI backend, with a Node.js sidecar handling all Hedera chain operations. The frontend uses no router, a landing and a desk view are swapped via pushState (preserving the invite-key query string), streams the chat protocol through a hand-rolled SSE client built on fetch.

The backend runs FastAPI with dependencies managed by uv; POST /chat streams SSE from an agent loop built on the Anthropic API with tool use.

For containerization, backend and sidecar run together in a single Docker image built on python:3.12-slim with Node 20 added, with the sidecar bound to loopback only (it holds no authentication and moves treasury funds, so keeping it unreachable from outside the container is the security boundary). GitHub Actions runs pytest, a frontend build, and a Docker build, then gates a push-to-deploy job that redeploys Railway for the backend and sidecar and Vercel for the frontend on every green merge to main, skipping the backend redeploy when only frontend files changed. All secrets live in the platforms' environment stores, and an opt-in demo-key header gate protects the public chat endpoint from unauthenticated API spend.