Build1 distinct publisher3 min readPublished
A dev.to walkthrough deploys a Groth16 price oracle on Arbitrum for under 2.5 cents per proof. Most of that money is the 280,000 gas verification, so the budget tracks L2 gas rather than cryptography.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
Take the per-proof budget apart before deciding whether it transfers. Proving is $0.003 and verifying is about $0.02 [8][9]. Those sum to $0.023, inside the guide's own ceiling of under $0.025 per proof [1][10]. Verification is therefore about 87 percent of the money [2]. Halving the proving cost saves $0.0015 [6]; the line that moves your invoice is Arbitrum gas.
The $0.02 is where the transferability question lives. 280,000 gas at $0.02 works out to roughly $0.071 per million gas [4]. The results table gives the gas and the dollar figure without stating the ETH price or L2 gas price in effect at measurement [21]. For your deployment to land under 2.5 cents, your gas has to sit near that level at settlement, and your verifier has to be the same 247 lines doing the same pairing check [3].
The proof-size row is listed as 47 KB of compressed calldata [7], sitting next to a 280,000 gas verification cost [9], and the table does not say whether the gas figure covers posting that calldata [21]. On an L2 those are two different things to pay for. If the gas number is the pairing check alone, the last row is a floor rather than a price.
The 100x claim over RISC Zero rests on 10M iterations of recursive Fibonacci, picked because it matches the oracle's cycle count [11]. The oracle's 10.2M cycles are HTTP, JSON and float math [5], and the author's stated reason for needing SP1's continuations is that a coprocessor doing HTTPS and JSON parsing is heavy on syscalls [13]. Fibonacci matches on cycle count and on nothing else. For the ratio to carry into your workload, execution has to split into segments that prove in parallel [12], and the syscall-heavy stretches must not serialise them. The figure I would quote for this oracle is the end-to-end one: 10.2M cycles in 2.3 seconds is about 4.4M cycles per second [5].
What the contract learns is narrow, and the guide states it precisely: verify this Groth16 proof, and if it is valid then price_cex > price_dex is true [18]. It is true of the bytes the guest was handed, and the guest gets its bytes by calling the endpoints named in its input struct, a Binance ticker and a 0x quote [19][2]. Proving you parsed a response correctly is a different thing from knowing the response was honest, so the promise of doing this without trusting an external oracle network [1] resolves to trading a signed feed for an unsigned fetch whose parsing is checkable.
Two parts of this are good craft. The Groth16 wrapper reuses the perpetual powers of tau, so a new circuit needs no new ceremony [14], which removes a coordination problem rather than a compute one. And full std support means reqwest, serde_json, alloy and tracing compile into a guest that is just a Rust binary targeting RISC-V [15][16]. The manifest shows where the real boundary sits: the fixed crate is pinned because Solidity has no floats [17]. Floats are fine inside the zkVM; fixed point is what crosses to the contract.
Ranked by verification strength, evidence, and original report placement.
SP1 supports full Rust std, so reqwest for HTTPS, serde_json for parsing, alloy for ETH ABI encoding and tracing for debug logs all work inside the zkVM; the author says RISC Zero requires no_std and manual memory management for complex crates.
The dev.to tutorial deploys a ZK coprocessor on Arbitrum using SP1 (Succinct Processor 1), building a ZK price oracle that cryptographically proves a CEX price exceeds a DEX price to trigger on-chain arbitrage execution, described as working without trusting any external oracle network.
The SP1 guest program, written in Rust, fetches JSON APIs, parses floats, compares prices and commits to the result; the SP1 host drives execution and generates Groth16 proofs via the SP1 Network.
The Solidity verifier is 247 lines and verifies Groth16 proofs on-chain for about 280k gas.
An arbitrage executor contract atomically verifies the proof and then executes the swap, alongside a CI/CD pipeline for automated proving, verification and deployment.
Measured guest cycles for the price oracle: 10.2M cycles, attributed to HTTP, JSON and float math.
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · August 31, 2026
Follow any of these and your For You feed starts watching them — no settings page required.
build
The Elixir arbitrage roadmap that puts the Rust parser third, not first1 distinct publisher
invest
Ceffu moved $120M out of Ethena's custody wallets, and nobody has said why1 distinct publisher
build
TypeScript 7.0 is a build-infrastructure release: re-budget CI, then check your toolchain1 distinct publisher
build
The only way to prove a contract test can fail is to ship a server that lies1 distinct publisher
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
One author, one terminal
Cycles, seconds, kilobytes and cents all come from the same dev.to walkthrough, measured by the person recommending the toolchain. Internally it holds together — proving plus verification lands at $0.023, exactly inside the sub-2.5-cent ceiling the table claims — and a gas count is the sort of thing a reader could check against a deployed verifier. What never appears is anything from outside the author's own machine: the cross-zkVM Fibonacci run behind the "~100x over RISC Zero" line is described but its numbers are withheld, and the $0.02 floats free of the ETH price and L2 gas price it must assume.
No one but the author
Nothing in this reporting shows anyone else running this. There is no deployed contract address, no counterparty, no proof volume, no team reproducing the 2.3-second run — and a tutorial's own demo is not uptake. A pinned sp1-sdk 4.0.0 tells us what the author compiled against, not that anything is in use, so we record the gap rather than dress the version string up as usage.
Framing outruns the table
"Zero to Production" and "without trusting any external oracle network" sit on top of a guest that fetches api.binance.com and a 0x quote: the proof binds the comparison, not the endpoints it read, and the guide never says so. The 100x claim is delivered as a takeaway rather than a measurement. Curiously, the piece undersells its own best material — the most portable finding is a table row nobody in the text pauses on, that verification is roughly 87 percent of the itemised bill and about 6.7 times what proving costs.
Advocacy first, benchmark later
The guide opens by explaining why one zkVM "wins", names its competitor's weaknesses precisely — no_std, manual memory management — and keeps its own comparison numbers off the page. Proving runs through a paid external network at three tenths of a cent per proof, so the recommended path is also a metered one. No affiliation between the author and the toolchain's makers is disclosed anywhere in this material, so we cannot call it a vendor post; we can only note that an advocacy piece and a benchmark pull in opposite directions and here only the advocacy is legible.
Enough to reason from, not to budget on
We are confident about what the guide says and much less about what it implies. The arithmetic on its table is safe — $0.003 plus $0.02 is $0.023, the ratio is about 6.7 to one, throughput is roughly 4.4M cycles a second — and it stays safe only while Arbitrum gas and SP1 Network pricing hold, neither of which the piece dates or bounds. One publisher, one author, one unreplicated run: a good starting hypothesis about ZK coprocessor costs on an L2, not a line item.