Docs

Everweek buys Stock Tokens on Robinhood Chain on a schedule: one USDG deposit, then a buy every hour, day, week or month until it is spent. One router contract trades USDG and the 27 listed Stock Tokens through their Uniswap pools, and refuses any fill that lands too far from the Chainlink price of the stock. Next to recurring buys it runs market swaps, limit orders with brackets, stock to stock trades in one transaction and EIP-2612 permits instead of approvals.

Overview

Every Stock Token on Robinhood Chain has two prices: the price its Uniswap pool will pay right now, and the price Chainlink reports from the stock market. Most of the time they agree. When a pool is thin, has not been arbitraged since the last move, or is being sandwiched, they do not, and a normal swap fills at the pool's price anyway.

Everweek reads Chainlink inside the contract and turns it into a hard minimum for every leg of every trade. You keep the pool's liquidity and the pool's price when it is fair; you get a revert when it is not.

• Market swaps with a floor from Chainlink at the band you choose.
• Limit orders that wait in the contract and never fill at a worse price than your limit.
• Stock to stock in one transaction, both legs checked.
• Permit: the first trade of a token is one signature and one transaction.
• Charts and data: candles of each pool, the Chainlink line, and the live gap between them.

Recurring buys

A plan holds USDG in the contract and spends it on one Stock Token in equal slices, one slice per period.

Creating. createPlan(token, total, perBuy, every) moves total USDG into the contract. perBuy is the size of each buy, at least $2; every is the time between buys in seconds, at least one hour. The first buy is due at once. createPlanWithPermit does the same with a USDG permit signature instead of an approval.

Running. runPlan(id) may be called by anyone once the plan is due. It spends one slice: $0.05 goes to the caller for gas, 0.1% to the treasury, and the rest buys the stock on its pool with a minimum out of 1.5% under Chainlink. The stock goes straight to the owner's wallet, never stays in the contract. The next buy is due every seconds later. If the pool is too far from Chainlink, the call reverts and the plan keeps waiting for the next check.

The last slice. When what is left is smaller than two slices, the last buy takes all of it, so no dust is stranded. When nothing is left, the plan closes by itself.

Stopping. closePlan(id), from the owner only, closes the plan and sends every unspent USDG back at once. No fee, no waiting.

Reading. getPlan(id) returns the owner, the next due time, the period, whether it is open, the token, the slice and what is left. plansCount() and duePlans(from, count) list them for keepers.

Example. $500 into NVDA, $50 every week: ten buys over about nine weeks. If NVDA is $201 in week one and $188 in week two, the second buy gets more shares. That is the point of buying on a schedule: you do not have to guess the dip.

A market swap, step by step

Calling swap(tokenIn, tokenOut, amountIn, minOut, slipBps, to):

• The router checks both tokens are USDG or a listed Stock Token, and takes amountIn of tokenIn from you.
• USDG to a stock: 0.1% is set aside as the fee, the rest buys the stock on its pool with a minimum out from Chainlink, and the stock goes straight to to.
• A stock to USDG: the stock is sold on its pool with a minimum out from Chainlink, 0.1% of the USDG is the fee, the rest goes to to.
• A stock to another stock: sold to USDG, 0.1% fee, the rest buys the other stock, both legs with their own Chainlink minimum.
• Finally the total out must reach minOut. The app sets minOut to the floor returned by quote.

If any check fails, the whole transaction reverts. The router never keeps a balance between trades.

The Chainlink floor

For each pool leg the router computes the amount Chainlink says you should get, then takes off your band. Buying NVDA with 1,000 USDG at a Chainlink price of $217.07 and a 0.5% band:

• After the 0.1% fee, 999 USDG buys the stock.
• Fair amount at Chainlink: 999 / 217.07 = 4.6022 NVDA.
• Floor at 0.5%: 4.6022 × 0.995 = 4.5792 NVDA.
• If the pool delivers 4.5792 NVDA or more, the trade goes through. If it would deliver less, the transaction reverts.

The same check runs on sells (minimum USDG out from the Chainlink value of what you sell) and on each leg of a stock to stock trade. quote(tokenIn, tokenOut, amountIn, slipBps) returns the fair amount and the floor, so you can see both before you sign.

Choosing a band

The band is how far from Chainlink you accept a fill. You pick it per trade: 0.3%, 0.5%, 1% or 1.5%. It can never be looser than the router's cap, 1.5% at launch.

• 0.3%: deep pools (NVDA, AAPL, GOOGL, SPY) during market hours.
• 0.5%: the default, fine for most trades of a few hundred dollars.
• 1% to 1.5%: thinner pools, bigger size, or a pool fee of 1% (TSM, DELL, SNDK, GME).

The pool fee is part of what the pool delivers, so a 1% fee pool cannot fill inside a 0.3% band. The app shows the live gap between each pool and Chainlink, which is the quickest way to pick.

Stock to stock

Rotating from TSLA to NVDA on a usual swap page takes two swaps through USDG and two approvals. Everweek does it in one call: the TSLA leg is sold with a Chainlink floor, 0.1% is taken from the USDG in the middle, and the NVDA leg is bought with its own floor. The floor returned by quote counts the band twice, once per leg.

Permit instead of approve

USDG and the Stock Tokens implement EIP-2612. swapWithPermit and placeOrderWithPermit take the allowance as a signature for exactly the amount of the trade, so nothing stays approved after it.

• USDG signs with the domain name "Global Dollar", version 1, chain 4663.
• Stock Tokens publish their domain through eip712Domain() (EIP-5267); the app reads it before asking you to sign.
• If someone submits your permit first, the router ignores the failed permit and uses the allowance that is already there.
• If your wallet cannot sign typed data, the app falls back to a normal approve for the exact amount.

Orders and brackets

placeOrder(token, buy, amount, limit, stop, expiry) creates an order on one Stock Token with up to two triggers. Either price may be 0, not both:

• Sell with a bracket: take profit when Chainlink is at or over limit, or stop out when it is at or under stop. The stop must sit below the target.
• Buy with a bracket: buy the dip at or under limit, or the breakout at or over stop. The breakout must sit above the dip.
• Whichever trigger Chainlink reaches first fills the whole order; the other goes with it.
• At the limit the fill must be no worse than the limit price. At the stop the order fills like a market order, inside your band of Chainlink: a stop protects you from holding on, it does not promise the stop price.

The details of each side:

• Buy: amount is USDG to spend. It fills when Chainlink is at or under limit.
• Sell: amount is the Stock Token to sell. It fills when Chainlink is at or over limit.
• limit is a USD price with 8 decimals, the same units as Chainlink. expiry is a Unix time, or 0 for an order with no end.
• The minimum order is 2 USDG (or 2 USDG worth of the stock).
• What you put in is held by the router, in your order, until it fills, expires or you cancel.

The fill. fill(id) checks Chainlink has reached the limit, then trades on the pool with the usual Chainlink floor and one more check: the price you actually get must be no worse than your limit. A buy of 500 USDG with a $195 limit must deliver at least (500 − fees) / 195 NVDA; a sell must deliver at least the amount times $195. If the pool cannot meet that yet, the fill reverts and the order keeps waiting.

Cancel and expiry. cancel(id) returns everything in the order to you, at any time, from the owner of the order only. Once an order passes its expiry, any fill call closes it and returns the funds instead of trading.

due(from, count) lists the open orders that can be filled or closed now. getOrder(id) and ordersCount() read the book.

The keeper

A Cloudflare worker checks every few minutes. It calls runPlan on every due plan and fill on every due limit order. It earns $0.05 per fill from the order, which pays its gas; it refuels its own ETH from that USDG. Anyone else may call fill too and earn the same fee, so orders do not depend on Everweek's keeper staying up.

Fees

Example: buying $1,000 of NVDA costs $1 to Everweek and about $0.50 to the 0.05% pool. A $500 limit buy costs $0.50 plus $0.05.

Pools and routes

Each Stock Token trades through its deepest Uniswap pool against USDG. COIN, MSTR and SPY route through WETH, because that is where their liquidity sits; each of their legs is still checked against Chainlink as a whole.

Market hours and weekends

Chainlink stock feeds update while the market is open and pause between sessions. The router accepts a Chainlink answer up to 3.5 days old, so it keeps working over weekends using the last close. Pools keep trading 24/7, so a pool that runs away from Friday's close is refused until Chainlink catches up on Monday. Limit orders likewise fill on Chainlink, not on weekend pool moves.

The app

• Markets: the 27 Stock Tokens with Chainlink price and 24h change.
• Chart: candles of the deepest pool from GeckoTerminal (15m, 1h, 4h, 1d), the Chainlink price as a dashed line, and your open limits as lines.
• Order panel: Market (buy or sell with a band), Limit (price, amount, expiry) and Stock to stock.
• Orders: your open orders with cancel, your history, and the limit book of the stock grouped by price.

For bots and integrators

Everything the app does is plain contract calls. A buy with viem:

const [fair, floor] = await client.readContract({ address: ROUTER, abi, functionName: "quote", args: [USDG, NVDA, 1_000_000000n, 50] });
await wallet.writeContract({ address: ROUTER, abi, functionName: "swap", args: [USDG, NVDA, 1_000_000000n, floor, 50, me] });

// sell 2.5 NVDA: target $230, stop $205, valid for 7 days
await wallet.writeContract({ address: ROUTER, abi, functionName: "placeOrder", args: [NVDA, false, 2_500000000000000000n, 23000000000n, 20500000000n, now + 7n * 86400n] });
// recurring buys: $500 into NVDA, $50 every week
await wallet.writeContract({ address: ROUTER, abi, functionName: "createPlan", args: [NVDA, 500_000000n, 50_000000n, 604800] });

The site serves /api/prices (Chainlink and 24h change), /api/pegs (pool price, address, liquidity and volume per stock) and /api/orders?a=0x… (the open book and one trader's orders) and /api/plans?a=0x… (one wallet's recurring plans).

Events

• Swapped(trader, tokenIn, tokenOut, amountIn, amountOut, usdSide)
• Placed(id, owner, token, buy, amount, limit, stop, expiry)
• Filled(id, atStop, usdSide, tokenSide, by)
• Closed(id, expired) for a cancel or an expiry
• PlanCreated(id, owner, token, total, perBuy, every), PlanRun(id, usdSide, tokenSide, left, by), PlanClosed(id, refund)

Owner limits

The owner of the router can list Stock Tokens and set their routes, change the price adapter, set the band cap (up to 5%), the fee (up to 0.5%), the fill fee (up to $0.50) and the treasury. There is no function that moves a trader's tokens or an order's funds anywhere except through a trade that passes the checks, or back to the trader.

Risks

• Unaudited software. Size accordingly.
• The floor relies on Chainlink. A wrong or stale feed would set a wrong floor; the router refuses answers older than 3.5 days.
• A floor stops bad fills. It does not make a trade a good idea, and it does not protect against the stock itself moving.
• Limit orders fill when Chainlink reaches the limit and the pool can meet it; in a thin pool an order may wait longer than the chart suggests.
• Stock Tokens track their stocks through Robinhood; their own terms and risks apply.

FAQ

Does Everweek have its own liquidity? No. It routes through the existing Uniswap pools and adds the checks.

Why did my swap revert? The pool was outside your band of Chainlink, or the total was under minOut. Try a wider band, a smaller size, or wait for the pool to come back in line.

Can a limit order fill at a worse price? No. The contract checks the fill against your limit and reverts otherwise.

What happens to my order if the keeper stops? Nothing is lost. Anyone can fill it, and you can cancel at any time.

Token

The Everweek token launches on pons. Its contract address appears on the home page and here once it is live. Always check the address on this site before trading.

Contracts