SpiralStake: the agent assembles the transaction, the wallet signs it

SpiralStake at spiralstake.x402.press returns unsigned leverage transactions and the approvals that accompany them, at $0.006125 a build on Base. An agent can assemble a position without holding a key.

What it is

SpiralStake is an HTTP gateway at https://spiralstake.x402.press to Spiral Stake’s leverage execution layer on Morpho. Its two paid endpoints both return unsigned transactions rather than executing anything. Positions are non-custodial and isolated per user in their own proxy contracts; the gateway states that it never holds a private key, and that three independent firms audited its contracts. We did not examine those reports.

The paid call buys assembly, not execution. It returns approvals, a transaction and metadata for the wallet holder to sign, and nothing reaches a chain until that signature exists. An agent can read markets, compare strategies, simulate outcomes and prepare a transaction, and cannot spend a token while doing so. Authority stays with the key.

Payment runs through the x402 two-round handshake, in the exact scheme only: the first request returns HTTP 402 with the amount due and the accepted payments, and the retry carrying payment returns the bundle. No account, no key, no monthly bill.

The chain you sign on and the chain you pay on are separate decisions. The build body takes a chainId of 1 (Ethereum, the default) or 4663 (Robinhood Chain), and the free reads serve those two alone. Payment settles on seven chains.

What you get

The two paid operations

Table 1. The paid operations. Source: GET /tools and /openapi.json, 30 October 2026.

strategyId is the Morpho market id from the strategy list. payToken is the token funding the position: the collateral when it is held directly, any token when it must be swapped in, the zero address for native ETH. amount is in human units, as a string. userAddress is the wallet that will sign; approvals and ownership are built for it, not for the caller. leverage and desiredLtv are alternatives.

The manage call takes the position index — id, from GET /v1/positions/{address} — and one of six actions: close, increase_leverage, add_collateral, remove_collateral, repay, borrow. amount is required for all but the first two, payToken for add_collateral and repay, full for repay alone, clearing the whole debt. slippage defaults to 0.005 and is capped at 0.01.

The bundle

The response carries approvals — a to and data pair per token that must be allowed before it can be spent — plus tx with an address, calldata and value, and meta with expiresAt and signingUrl. It names the contract path it built for: swapAndLeverage for an open, closePosition for a close.

Because the deliverable is data, everything a signer would check is available before the key is touched: router, calldata, value, approvals, deadline. The gateway’s involvement ends there, and so does its liability. The example at GET /tools shows a one-minute gap between build and expiry; treat the window as short, and read the value returned with your own bundle.

The free reads

GET /v1/strategies lists strategies with an optional chain_id; POST /v1/strategies lists them with a filter body; GET /v1/strategies/{strategy_id} returns one. A record carries the collateral and loan tokens, the Morpho market id, whether the pair is correlated, the market’s maximum leverage and a ladder from 1× to it at each loan-to-value step, liquidity, the oracle, and current rates. This review quotes none of the rates: they move.

GET /v1/prices returns prices with an asOf timestamp and a stale flag. GET /v1/positions/{address} returns open and closed positions. POST /v1/simulate needs no wallet and costs nothing: it returns the effective loan-to-value the position would reach rather than the requested one, the price impact at that moment, the swap route priced against, the flash-loan amount, the minimum output and the slippage applied.

GET /tools returns both paid operations with their input schemas. GET and POST /feedback read and submit feedback; the record was empty when we looked. /health, /about, /openapi.json and /llms.txt are unbilled, and GET /persona publishes a machine-readable persona the service invites an agent to adopt — a prompt, not a control: nothing in it restricts what the endpoint will build.

What it costs

Table 2. Price per paid call in US dollars, by settlement chain and asset. Both operations are priced alike. Source: live 402 challenge decoded on 30 October 2026, and /about.

One scheme is offered, exact: no metered ceiling, so the amount in the challenge is the whole price, paid before the work. The challenge also carries maxTimeoutSeconds of 300 — a five-minute window.

Only payment moves the price. Arbitrum at $0.00525 is 14% below Base, Polygon at $0.004375 29% below, Avalanche at $0.00175 71% below; Ethereum mainnet at $2.625 is 428 times the Base price for an identical assembly. Base, Robinhood and Arc quote the same amount, Robinhood in Global Dollar, and Base alone also accepts EURC.

None of it decides anything. One dollar of stablecoin covers 163 builds — more assembly than a person will review in a month.

How an agent uses it

Illustrative worked example, not a measurement. A treasury agent watches one market pair. In a month it screens ten strategies, simulates the three that pass its filters, then builds one opening transaction and one adjustment.

• 10 strategy reads + 3 simulations = $0.00
• 1 × POST /v1/build/leverage-tx = $0.006125
• 1 × POST /v1/build/manage-tx = $0.006125
• Total for the month: $0.01225, about $0.147 a year

A busier agent, rebalancing a book and assembling twenty transactions a month: 20 × $0.006125 = $0.1225, about $1.47 a year — eleven cents a month more.

The metered cost is negligible against the decision it supports. Two dollars of stablecoin buys 326 builds; there is no volume at which the price of assembly becomes the reason to refuse it. The constraints that matter sit elsewhere: whether an agent should hold this kind of authority, and who watches the position once it is signed. The agent reads, compares, simulates and assembles; the person keeps the key and the decision.

The order the service documents is reads, then simulation, then build, and it is worth keeping: the preview is free, and it is the only place the agent learns what the position would actually look like — effective rather than requested loan-to-value, price impact, minimum output after slippage.

Two habits keep an agent inside the limits: pass chainId explicitly, since the default is mainnet, and settle on the chain with the cheapest accepted price — the payment, not the body, sets the fee.

Where it stops

Leverage can be liquidated. A leveraged position can be closed by the protocol at a loss, and an agent that assembles one is not managing that risk. The call returns a transaction and stops.

The agent does not sign, and cannot. The transaction is unsigned, it expires, and it must be signed by the wallet holder or by a signing service the client controls. That is the control and also the limit: a workflow needing action within seconds of a market move cannot be built on this pattern.

Slippage is capped at 0.01. A build asking for more is refused, so a market moving faster than the cap cannot be served through this endpoint.

Position chains and payment chains are different sets. Builds target chain 1 or 4663 and the reads serve those two alone; anything else is refused, with chain_id=8453 returning Unsupported chainId '8453'. Supported: 1, 4663. Base is where many buyers will pay, not where the position will sit. Because chainId defaults to 1, an agent that omits it builds a mainnet position with mainnet gas; if its client settles on mainnet too, the same assembly costs $2.625 rather than $0.006125 — 428 times more for an identical bundle.

Market risk sits in the Morpho markets, not in the service. Rates, liquidity, collateral factors and oracle prices belong to the market. The service reports them, and the price impact and swap route behind the preview; it does not underwrite any of it.

Beta, and no paper behind it. The card labels its maturity beta: no service-level agreement, no signed instrument behind a call, an empty feedback record, and an undocumented filter body on POST /v1/strategies — of the keys we tried, only chainId narrowed the list. If uptime, support or a contract matters, this endpoint does not supply them.

When not to use it

You want a custodian or an executor. This service never holds funds and never signs. It assembles and returns; the keys and the sending stay with you. A mandate to act without a human signature is not a mandate it can serve.

You want a view on whether to lever up. It assembles what it is asked to assemble. The decision, the sizing and the consequences are the caller’s.

You are not prepared to sign and watch a leveraged position. Liquidation is a real outcome, not a tail case, and nothing here watches the position for you. A position nobody is watching is a position nobody has sized.

For everyone else the decision is small and reversible: no account, no commitment, no minimum.

How to start

1. Call GET /tools and GET /v1/strategies?chain_id=1. Both are free, and together they confirm the base URL, the input schema and the chains served before any money moves.
2. Send POST /v1/simulate with a strategyId, payToken, amount, leverage and chainId. It is free and needs no wallet. GET on that path returns HTTP 405.
3. Send POST /v1/build/leverage-tx with the four required fields and an explicit chainId. The first attempt returns HTTP 402, accepting payment on seven chains; pay one in USDC, or in EURC on Base, and present it on the retry. The window is five minutes.
4. Read approvals, tx and meta before signing. Sign the approvals, then the transaction, from the wallet named in userAddress, or hand the bundle to the signer that holds it. If meta.expiresAt has passed, rebuild.
5. Call GET /v1/positions/{address} to confirm the position and its index, which is the id every later manage call needs.

The whole integration is a payment step around an HTTP client. The only state an agent needs is a float: $5 covers a busy treasury several times over.

Method note

The 402 challenge on POST /v1/build/leverage-tx was decoded on 30 October 2026: eight accepted payments, all exact — USDC at 6125 on Base, 5250 on Arbitrum, 4375 on Polygon, 1750 on Avalanche and 2625000 on Ethereum; EURC at 6125 on Base; Global Dollar at 6125 on Robinhood Chain; USDC at 6125 on Arc. Each is in its asset’s smallest unit, and the timeout is 300 seconds. The amounts agree with /about and /.well-known/x402.json; parameter names come from GET /tools and /openapi.json.

The free reads were exercised the same day: 48 strategies on chain 1 and 12 on 4663; chain_id=8453 refused; GET /v1/simulate returning 405 and the POST 200; GET /feedback empty. A two-times simulation returned an effective loan-to-value of 50.09% against 50.00% requested; no rate or return figure from that response is quoted, by policy. No latency or uptime figure is published, and none is implied.

The treasury example is arithmetic. Prices are the live challenge’s; counts are 30 October 2026 and will drift.

Filed under Service Reviews · Tags: x402, defi, spiralstake, non-custodial

Related reviews: DeepSeek review · Qwen review · HyperFusion review · Wolfram Alpha review · ElevenLabs review · Mage review

Background: what x402 is, and how a payment works

All seven reviews: the services reviewed

Marketplace: SpiralStake on x402.press — prices per chain, operations and the metered ceiling.