The problem ThetaGuard solves

Institutional crypto traders have long had access to sophisticated on-chain options-allowing them to hedge portfolios, lock in yields, and structure cash flows with precision. However, everyday retail users have been completely left behind.

The barriers to entry for retail downside protection are severe:

Complexity: Understanding strike prices, expiries, deltas, and margin requirements requires deep financial expertise.

Custodial Risk: Centralized platforms that abstract this complexity hold user funds and have a long history of insolvency or disappearing with deposits.

Gas Friction: Non-custodial platforms require users to pay native tokens (like ETH) for gas, creating a massive bootstrapping problem for users whose savings are entirely in stablecoins.

Tooling Gap: No product exists that wraps institutional-grade on-chain options in a consumer-friendly interface suitable for a migrant worker, freelancer, or vulnerable community member.

ThetaGuard fills this gap. We take the full institutional power of the Thetanuts OptionBook and OptionFactory on Base Mainnet and wrap it in four plain-language consumer products. It requires zero options knowledge to use, abstracts away gas fees, and requires no central custodian to trust.

What People Can Use It For
ThetaGuard offers four distinct products that make downside protection easy, safe, and accessible:

1. Savings Shield - "Protect what I have"
   Use Case: Anyone holding crypto who wants a hard floor on its dollar value.

Example: A user has $200 in ETH and is worried about a market crash in the next 30 days. They don't want to sell-they believe in ETH long-term-but they can't afford to lose half their savings. They pay a small premium (e.g., $4) and receive a 30-day cash-settled put option via Thetanuts. If ETH crashes, they claim the difference in USDC. If ETH goes up, they keep all the upside.

2. Remit-Lock - "Lock value during transfer"
   Use Case: Migrant workers sending money home, or anyone doing cross-border crypto transfers.

Example: A sender converts $500 to crypto to send internationally, but the recipient's off-ramp takes 3 days to verify. The exchange rate could crash in that window. Remit-Lock automatically buys a short-dated put to guarantee the $500 value for the exact duration of the transfer.

3. Wage Floor - "Guarantee my crypto income"
   Use Case: Freelancers, DAO contributors, and anyone paid in crypto on a recurring basis.

Example: A freelancer gets paid $2,000/month in ETH. They set up a Wage Floor: ThetaGuard automatically schedules a rolling monthly put option protecting this income. If the market crashes, they claim the difference; if the market is up, they keep the upside and pay only the small rolling premium.

4. Mutual Aid Pool - "Community-funded protection"
   Use Case: Community contributors and economically vulnerable users.

Example: Community members voluntarily contribute USDC to a shared pool. Verified vulnerable users (e.g., users in economically distressed regions) can apply for subsidized protection funded from the pool. This brings institutional-grade downside protection to people who could never afford the premium themselves.

How It Makes Tasks Safer
ThetaGuard makes hedging exponentially safer because it is 100% non-custodial. Every protection purchase is a real encodeFillOrder() call against the live Thetanuts OptionBook on Base mainnet. Our Next.js web app and mobile clients talk to an isolated Node.js sidecar that returns unsigned EIP-1559 calldata. The user's wallet signs the transaction directly-our backend never touches a private key or user funds.

Challenges we ran into

Building a consumer-friendly wrapper around complex on-chain options presented several unique technical and product challenges:

1. Bridging the Rust Backend with the TypeScript SDK
   The official @thetanuts-finance/thetanuts-client SDK is built for Node.js/TypeScript, but we wanted our core backend-responsible for indexing, notifications, and high-performance database interactions-to be written in Rust using Axum.

The Hurdle: We couldn't natively call the TypeScript SDK methods directly from our Rust binaries.

The Solution: We implemented a Node.js Sidecar architectural pattern. We built a lightweight Express.js bridge (the Backend-for-Frontend or BFF) that runs alongside the Rust backend. The Rust server acts as the primary API gateway, securely proxying SDK requests to the sidecar, which handles the complex encodeFillOrder() calldata generation and returns the payload. This allowed us to keep the performance of Rust while fully utilizing the official Thetanuts TS SDK.

2. Dependency Hell & Web3 Ecosystem Conflicts
   During the development of our Next.js web application, we ran into severe build failures and internal 500 errors related to wallet connectors.

The Hurdle: The ecosystem moves fast. Updating our @wagmi/connectors and Coinbase SDK integrations introduced hidden peer dependency requirements for specific, bleeding-edge packages (@x402/evm and @x402/svm) required by @base-org/account. Our Next.js builds started failing entirely because Webpack couldn't resolve these nested dependencies.

The Solution: We spent considerable time doing a deep audit of our package-lock.json dependency tree. We manually resolved the conflicts by installing the exact required peer dependencies, cleaning up deprecated Webpack configurations in next.config.js, and isolating our wallet provider logic into a clean Providers.tsx wrapper to ensure the app booted safely.

3. Cross-Platform Mobile Networking
   We built native mobile clients for both iOS (Swift) and Android (Kotlin) alongside the web app.

The Hurdle: In the early stages, both mobile apps had hardcoded localhost:8080 (or 10.0.2.2:8080) API endpoints. This worked fine on the simulator, but the moment we needed to build for physical devices or prepare for a production release, the hardcoded network paths completely broke the apps.

The Solution: We integrated dynamic build configurations into both mobile clients. For Android, we injected BuildConfig fields directly into the build.gradle.kts to dynamically set the API URL based on the build type (Debug vs. Release) and fed that into our Hilt NetworkModule. For iOS, we built a custom AppConfig.swift struct utilizing #if DEBUG compiler macros to safely switch environments at compile time.

4. The UX Challenge: Abstracting "Put Options"
   The Hurdle: If you tell a retail user to "buy a cash-settled 30-day put option," they will close the app. The traditional DeFi terminal aesthetic is terrifying to the average consumer.

The Solution: We spent multiple iterations completely overhauling the UI. We built a unified "glassmorphism" design system with vibrant neon accents (green, cyan, purple) and dynamic micro-animations. More importantly, we abstracted the financial jargon entirely. We created products named "Savings Shield" and "Remit-Lock", framing the user journey around their goals (e.g., "Protect my transfer for 3 days") rather than the underlying financial instrument.