stryk

$STRYK: supply locked. Check: app.streamflow.finance/contract/solan… CA: fYA8w94VaLFkM7Tm85n7CegrhbW5qg2AEkuw1YUpump

Worth a second read now: the auction essay. When it was published, the Dutch auction was a settlement design on paper — the decay schedule, what a bid actually is, what happens to a bidder who defaults. Since then the maker seat became staked collateral on Solana mainnet, and the first EpochRecords exist on-chain. The paragraph about defaults reads differently now that the slash it describes is a live instruction. And if the build log about compute ceilings left you wanting the full tour of the engine, the fixed-point essay takes that same Q64.64 machinery apart line by line:

And when a maker defaults, the slash is a burn, not a transfer. This is the part worth staring at. If slashed collateral routed to a treasury, the entity holding the slash authority would earn money by slashing — an incentive you do not want anywhere near a discretionary penalty. Burning it instead sends the value to every holder pro rata, including the LPs the default just hurt, and pays the slasher exactly nothing. The request is capped at the staker's live balance, and the burn is a CPI against the mint. Total slashed to date is a public field on the config account. Today it reads zero. The design is judged by what that field does under stress, and it is on-chain either way. stryk.fi/stake

Two numbers in the staking design are load-bearing. Neither is a price. The cooldown is seven days because the epoch is seven days. Every stake re-arms it. So a maker cannot post collateral on Thursday, win Friday's auction, and pull the collateral before that same epoch settles the following Friday. The window you are locked for is exactly the window your bid can still fail in. Top up your stake mid-week and the clock restarts -- deeper commitment is also longer commitment. That is the design, not a side effect.

Build log, July 6. Two upgrades in one day, and the same lesson both times. The scheduler first. next_friday_utc folded the weekday with a +3 offset, which maps Monday to zero, not Friday — 1970 began on a Thursday. Every computed expiry landed three days early, and the unit tests agreed with the bug because they encoded the same arithmetic. v0.8.1 fixed the offset and pinned the tests to a calendar instead: a year-long sweep asserting every expiry is a Friday 08:00 UTC, strictly in the future. It shipped before any epoch had ever opened, so no immutable record carries a wrong date. Then the first real open_epoch was attempted — in simulation, nothing landed — and the on-chain Black-Scholes path, which had never executed outside tests, blew through the 1.4 million compute-unit ceiling on its first run. v0.8.2 reworked the hot fixed-point paths, and the rework surfaced a second thing: the wide-division routine was silently dropping a bit for divisors above 2^127. The replacement was differential-fuzzed against the old quotient — in the regime where the old code was exact — across roughly 1.2 million cases, then the whole flow was rehearsed on a local test validator before mainnet saw any of it: covered-call opens near 740k units, puts near 680k, delta-neutral 34k. The first live epochs opened the same day, under that binary. A path that has never run will fail on its first run. The only thing you get to choose is where that first run happens. Program: Giz81HxC3yX1iBQ2EvUJcwfnhEFDyi9Ydt4dxS31vYoH

Every weekly roll writes a receipt the page cannot edit. Since v0.3.0 the executor persists an EpochRecord account per vault per epoch, written in two halves: open_epoch stamps the strike and the premium target when the week is armed, settle_epoch finalizes the settlement price and the outcome when it expires. Immutable once written. No instruction exists to amend one. Right now five of those records sit on mainnet with their open half stamped — strike and premium target, written the moment epoch 1 was armed — and their settle half empty, because nothing has expired yet. The empty half fills at the first settlement: Friday, July 10, 08:00 UTC. A tab is coming to the discharge log that reads them straight from the program, the moment they exist. stryk.fi/discharge

Five receipts are already on mainnet. Their result fields are empty. Epoch 1 opened on all five reservoirs, and the program wrote an EpochRecord for each one at open: vault, strike, premium target, expiry — stamped before anyone knows how the week ends. The settlement price and the outcome get written exactly once, at expiry, Friday 08:00 UTC. There is no instruction to amend a record after that. The receipt form is public before the result is. We think that is the right order. Program: Giz81HxC3yX1iBQ2EvUJcwfnhEFDyi9Ydt4dxS31vYoH

The about page is open. Walk across the dam. stryk.fi/about It starts from zero: wild weeks scare most people out of the market, a reservoir is how you face them. Then it hands you the cursor. Hover the dam drawing and each of its five parts lights up — reservoir, sluice gates, turbine, discharge channel, observatory — and each one is a real page of this site doing a real job. Hover the four plain words and the finance term hiding underneath fades in. Hover the five moves and the scene replays the week: fill, price, auction, discharge, roll. No forecasts anywhere on it, and no trading skill required to read it. The dam does the same disciplined thing every week, in public, on Solana. This page just walks you from the picture to the machinery, as deep as you want to go. And at the bottom, the section this whole site is built around: do not take this page's word for it. Every claim above it has a primary source — a live page, a measured feed, or an account on Solana. stryk.fi/about

Volatility has two prices. There is the price it charges the unprepared — the forced exits, the weeks you wish you had held nothing at all. And there is the price it pays to whatever is built to hold it: every option premium, anywhere, is someone paying to move storm risk onto a structure that can carry it. Same storm, both times. Which price you meet depends on whether the reservoir was standing before the clouds arrived. We do not forecast weather here. We pour concrete.

Most protocol pages assume you already know what a covered call is. We are building the other page. The one you send to the person who asked "so what does this thing actually do" — no Greeks, no basis points, just a dam, the storm that fills it, and the Friday the water is let through. You will be able to walk the whole machine with a cursor: every part of the drawing is a real page of this site doing a real job. Opening soon. stryk.fi

/3 Where the line goes is the whole craft. Draw it too low and you hand the storm away for less than it is worth. Draw it too high and nobody pays for the risk. STRYK's reservoirs draw it by the same fixed rule every week — a rule, not a mood — and the rule, the line, and the payment all land on a public ledger, in that order. That is the whole product: a reservoir that sells the top of the storm and keeps the receipt. stryk.fi

/2 Three ways Friday can end. The sky stays quiet and the water sits below the line: you keep the reservoir and the payment. The water climbs but stops short: same outcome. The storm is large enough to cross the line: the trader takes what sits above it — exactly the overflow you agreed to give up when the line was drawn. You keep everything up to the line, every time. What you sold was the top of one week's storm, and you were paid for it in advance, whatever the sky decided to do.

/1 A covered call, explained with nothing but a dam. You own a reservoir that catches rain. Each week a trader offers the same deal: I pay you now, and if the water climbs past a line we draw on the wall by Friday, everything above the line is mine. If it never reaches the line, I paid you for nothing. That payment is the premium. Taking that deal every week is a covered call.

$STRYK utility, as it stands on-chain today. Not a roadmap — every line below is a live instruction on the mainnet program. Stake it: stake_stryk moves real tokens into a program-owned vault. 7-day cooldown, re-armed on every top-up. Quote with it: 25,000 staked $STRYK is the maker seat. With the stake config attached, clear_auction refuses a fill from anyone below it. Publish with it: 100,000 staked $STRYK opens register_strategy — your template becomes a permanent registry entry the executor can read. Lose it if you default: slash_stake burns the penalty from the stake vault. Burned, not transferred. Supply down, every holder's share of what remains up, nobody profits from pulling the trigger. What it still is not: a yield claim, a rebase, a treasury raise. Depositing, simulating, forking, reading — free, forever. CA: fYA8w94VaLFkM7Tm85n7CegrhbW5qg2AEkuw1YUpump stryk.fi/stake

A reservoir does not chase the rain. It is built where the rain will fall, and it waits.

The publish flow is open. stryk.fi/registry Scroll past the five live entries and there is now a form. Type a kind tag — lowercase snake_case, at most 32 bytes — and the page derives your entry PDA in front of you, from ["stryk-strategy", kind_tag], the same seeds anyone can re-derive to audit it. Point it at a spec URL, and if your staked $STRYK clears the on-chain publish threshold, register_strategy is yours to call. The requirements panel does not gate you politely in the dark. It tells you exactly where you stand: wallet not connected, no stake account, stake below the threshold, or gate open — each state read from the chain, not from a database. One honest footnote, same as it appears in the program's own documentation: the registry authority keeps a bootstrap exception, so first-party templates could ship while the staking pool grows. The exception is written into the code comments, not hidden behind them. Write strategies for free, forever. Stake to put them where the executor looks. stryk.fi/registry

Writing a strategy is free. It always will be. Fork a reservoir in crates/vault, run it against the same Q64.64 engine the settler uses, compare your numbers with stryk-cli. None of that asks who you are or what you hold. Publishing it — writing your template into the on-chain strategy registry that the executor reads — is different. That entry is a permanent account other people's money will eventually route through. Since v0.8.0 the gate in front of it is not a whitelist and not a committee. It is collateral: staked $STRYK, checked by the program at the moment you call the instruction. The publish surface opens soon. stryk.fi/registry

The stake page is open. stryk.fi/stake Every figure on it is read from the v0.8.0 staking accounts on Solana mainnet at request time: the maker threshold (25,000 $STRYK), the publish threshold (100,000 $STRYK), the 7-day cooldown, the pool totals, and — once you connect a wallet — your own seat. When a read fails, the page says so instead of inventing a number. The mechanics, in one paragraph: staked $STRYK is the maker seat. It sits in a program-owned stake vault, moved there by a real transfer CPI, not bookkeeping. Every stake re-arms the cooldown, so a maker cannot quote a Friday auction and vanish before that epoch settles. A seat that wins and defaults is slashed — and the slash is a burn against the mint, not a transfer to anyone. One detail for the token-standard readers: $STRYK is a Token-2022 mint, so the entire staking path runs through the token interface — transfer_checked in, transfer_checked out, burn on slash. The first seat on the board is ours: one raw unit, staked by the authority wallet to prove the path end to end on mainnet — the transfer, the cooldown arming, the account layout. It is a receipt, not a position. The pool starts from zero in public. CA: fYA8w94VaLFkM7Tm85n7CegrhbW5qg2AEkuw1YUpump stryk.fi/stake

The executor learned to hold collateral. v0.8.0 landed on mainnet today— the loader trail is public, as always. Five new instructions: stake, unstake, slash, and the config that binds them. $STRYK staking is now written into the program itself: publishing a strategy template takes a staked position, qualifying as an auction maker takes a staked position, and defaulting burns it. The first stake is already sitting on-chain. The surface opens soon. Program: Giz81HxC3yX1iBQ2EvUJcwfnhEFDyi9Ydt4dxS31vYoH

@he517606 okay

@strykfi Although I don't know the specific details of this project, I hope you can make an effort to get it seen by the public.

One program ID, two clusters. Giz81HxC3yX1iBQ2EvUJcwfnhEFDyi9Ydt4dxS31vYoH is live on Solana mainnet and on devnet — the same address on both. Mainnet carries the five reservoirs, the strategy registry, and everything the site reads by default. Devnet carries the same executor and the same five vault accounts, initialized during the devnet phase before mainnet went live. The Mainnet | Devnet toggle on stryk.fi surfaces points the Explorer links at whichever cluster you want to inspect. Pick one, open the program, read the accounts. The framework does not mind which chain you audit it on. stryk.fi/reservoirs